ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from vscode bead496a613e475819f89f08e9e882b841bc1fe8 (#14883)

Browse Source 
* Merge from vscode bead496a613e475819f89f08e9e882b841bc1fe8

* Bump distro

* Upgrade GCC to 4.9 due to yarn install errors

* Update build image

* Fix bootstrap base url

* Bump distro

* Fix build errors

* Update source map file

* Disable checkbox for blocking migration issues (#15131)

* disable checkbox for blocking issues

* wip

* disable checkbox fixes

* fix strings

* Remove duplicate tsec command

* Default to off for tab color if settings not present

* re-skip failing tests

* Fix mocha error

* Bump sqlite version & fix notebooks search view

* Turn off esbuild warnings

* Update esbuild log level

* Fix overflowactionbar tests

* Fix ts-ignore in dropdown tests

* cleanup/fixes

* Fix hygiene

* Bundle in entire zone.js module

* Remove extra constructor param

* bump distro for web compile break

* bump distro for web compile break v2

* Undo log level change

* New distro

* Fix integration test scripts

* remove the "no yarn.lock changes" workflow

* fix scripts v2

* Update unit test scripts

* Ensure ads-kerberos2 updates in .vscodeignore

* Try fix unit tests

* Upload crash reports

* remove nogpu

* always upload crashes

* Use bash script

* Consolidate data/ext dir names

* Create in tmp directory

Co-authored-by: chlafreniere <hichise@gmail.com>
Co-authored-by: Christopher Suh <chsuh@microsoft.com>
Co-authored-by: chgagnon <chgagnon@microsoft.com>
This commit is contained in:
Karl Burtram
2021-04-27 14:01:59 -07:00
committed by GitHub
parent 7e1c0076ba
commit 867a963882
1817 changed files with 81812 additions and 50843 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/vs/editor/test/common/model/benchmark/benchmarkUtils.ts
View File

@@ -58,7 +58,7 @@ export class BenchmarkSuite {
let timeDiffTotal = 0;
for (let j = 0; j < this.iterations; j++) {
let factory = benchmark.buildBuffer(builder);
let buffer = factory.create(DefaultEndOfLine.LF);
let buffer = factory.create(DefaultEndOfLine.LF).textBuffer;
benchmark.preCycle(buffer);
let start = process.hrtime();
benchmark.fn(buffer);

22
src/vs/editor/test/common/model/editableTextModel.test.ts
View File

@@ -22,10 +22,10 @@ suite('EditorModel - EditableTextModel.applyEdits updates mightContainRTL', () =
let model = createEditableTextModelFromString(original.join('\n'));
model.setEOL(EndOfLineSequence.LF);
assert.equal(model.mightContainRTL(), before);
assert.strictEqual(model.mightContainRTL(), before);
model.applyEdits(edits);
assert.equal(model.mightContainRTL(), after);
assert.strictEqual(model.mightContainRTL(), after);
model.dispose();
}
@@ -68,10 +68,10 @@ suite('EditorModel - EditableTextModel.applyEdits updates mightContainNonBasicAS
let model = createEditableTextModelFromString(original.join('\n'));
model.setEOL(EndOfLineSequence.LF);
assert.equal(model.mightContainNonBasicASCII(), before);
assert.strictEqual(model.mightContainNonBasicASCII(), before);
model.applyEdits(edits);
assert.equal(model.mightContainNonBasicASCII(), after);
assert.strictEqual(model.mightContainNonBasicASCII(), after);
model.dispose();
}
@@ -1043,7 +1043,7 @@ suite('EditorModel - EditableTextModel.applyEdits', () => {
test('issue #1580: Changes in line endings are not correctly reflected in the extension host, leading to invalid offsets sent to external refactoring tools', () => {
let model = createEditableTextModelFromString('Hello\nWorld!');
assert.equal(model.getEOL(), '\n');
assert.strictEqual(model.getEOL(), '\n');
let mirrorModel2 = new MirrorTextModel(null!, model.getLinesContent(), model.getEOL(), model.getVersionId());
let mirrorModel2PrevVersionId = model.getVersionId();
@@ -1058,8 +1058,8 @@ suite('EditorModel - EditableTextModel.applyEdits', () => {
});
let assertMirrorModels = () => {
assert.equal(mirrorModel2.getText(), model.getValue(), 'mirror model 2 text OK');
assert.equal(mirrorModel2.version, model.getVersionId(), 'mirror model 2 version OK');
assert.strictEqual(mirrorModel2.getText(), model.getValue(), 'mirror model 2 text OK');
assert.strictEqual(mirrorModel2.version, model.getVersionId(), 'mirror model 2 version OK');
};
model.setEOL(EndOfLineSequence.CRLF);
@@ -1077,16 +1077,16 @@ suite('EditorModel - EditableTextModel.applyEdits', () => {
{ range: new Range(1, 2, 1, 2), text: '"' },
]);
assert.equal(model.getValue(EndOfLinePreference.LF), '"\'"👁\'');
assert.strictEqual(model.getValue(EndOfLinePreference.LF), '"\'"👁\'');
assert.deepEqual(model.validateRange(new Range(1, 3, 1, 4)), new Range(1, 3, 1, 4));
assert.deepStrictEqual(model.validateRange(new Range(1, 3, 1, 4)), new Range(1, 3, 1, 4));
model.applyEdits([
{ range: new Range(1, 1, 1, 2), text: null },
{ range: new Range(1, 3, 1, 4), text: null },
]);
assert.equal(model.getValue(EndOfLinePreference.LF), '\'👁\'');
assert.strictEqual(model.getValue(EndOfLinePreference.LF), '\'👁\'');
model.dispose();
});
@@ -1108,7 +1108,7 @@ suite('EditorModel - EditableTextModel.applyEdits', () => {
model.applyEdits(undoEdits);
assert.deepEqual(model.getValue(), 'line1\nline2\nline3\n');
assert.deepStrictEqual(model.getValue(), 'line1\nline2\nline3\n');
model.dispose();
});

8
src/vs/editor/test/common/model/intervalTree.test.ts
View File

@@ -111,7 +111,7 @@ suite('IntervalTree', () => {
let actualNodes = this._tree.intervalSearch(op.begin, op.end, 0, false, 0);
let actual = actualNodes.map(n => new Interval(n.cachedAbsoluteStart, n.cachedAbsoluteEnd));
let expected = this._oracle.search(new Interval(op.begin, op.end));
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
return;
}
@@ -123,7 +123,7 @@ suite('IntervalTree', () => {
let actual = this._tree.getAllInOrder().map(n => new Interval(n.cachedAbsoluteStart, n.cachedAbsoluteEnd));
let expected = this._oracle.intervals;
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
public getExistingNodeId(index: number): number {
@@ -500,7 +500,7 @@ suite('IntervalTree', () => {
function assertIntervalSearch(start: number, end: number, expected: [number, number][]): void {
let actualNodes = T.intervalSearch(start, end, 0, false, 0);
let actual = actualNodes.map((n) => <[number, number]>[n.cachedAbsoluteStart, n.cachedAbsoluteEnd]);
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
test('cormen 1->2', () => {
@@ -559,7 +559,7 @@ suite('IntervalTree', () => {
let node = new IntervalNode('', nodeStart, nodeEnd);
setNodeStickiness(node, nodeStickiness);
nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers);
assert.deepEqual([node.start, node.end], [expectedNodeStart, expectedNodeEnd], msg);
assert.deepStrictEqual([node.start, node.end], [expectedNodeStart, expectedNodeEnd], msg);
}
test('nodeAcceptEdit', () => {

6
src/vs/editor/test/common/model/linesTextBuffer/linesTextBuffer.test.ts
View File

@@ -33,7 +33,7 @@ suite('PieceTreeTextBuffer._getInverseEdits', () => {
function assertInverseEdits(ops: IValidatedEditOperation[], expected: Range[]): void {
let actual = PieceTreeTextBuffer._getInverseEditRanges(ops);
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
test('single insert', () => {
@@ -282,10 +282,10 @@ suite('PieceTreeTextBuffer._toSingleEditOperation', () => {
}
function testToSingleEditOperation(original: string[], edits: IValidatedEditOperation[], expected: IValidatedEditOperation): void {
const textBuffer = <PieceTreeTextBuffer>createTextBufferFactory(original.join('\n')).create(DefaultEndOfLine.LF);
const textBuffer = <PieceTreeTextBuffer>createTextBufferFactory(original.join('\n')).create(DefaultEndOfLine.LF).textBuffer;
const actual = textBuffer._toSingleEditOperation(edits);
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
test('one edit op is unchanged', () => {

8
src/vs/editor/test/common/model/linesTextBuffer/linesTextBufferBuilder.test.ts
View File

@@ -10,11 +10,11 @@ import { PieceTreeTextBuffer } from 'vs/editor/common/model/pieceTreeTextBuffer/
import { createTextBufferFactory } from 'vs/editor/common/model/textModel';
export function testTextBufferFactory(text: string, eol: string, mightContainNonBasicASCII: boolean, mightContainRTL: boolean): void {
const textBuffer = <PieceTreeTextBuffer>createTextBufferFactory(text).create(DefaultEndOfLine.LF);
const textBuffer = <PieceTreeTextBuffer>createTextBufferFactory(text).create(DefaultEndOfLine.LF).textBuffer;
assert.equal(textBuffer.mightContainNonBasicASCII(), mightContainNonBasicASCII);
assert.equal(textBuffer.mightContainRTL(), mightContainRTL);
assert.equal(textBuffer.getEOL(), eol);
assert.strictEqual(textBuffer.mightContainNonBasicASCII(), mightContainNonBasicASCII);
assert.strictEqual(textBuffer.mightContainRTL(), mightContainRTL);
assert.strictEqual(textBuffer.getEOL(), eol);
}
suite('ModelBuilder', () => {

21
src/vs/editor/test/common/model/linesTextBuffer/textBufferAutoTestUtils.ts
View File

@@ -6,7 +6,7 @@
import { CharCode } from 'vs/base/common/charCode';
import { splitLines } from 'vs/base/common/strings';
import { Range } from 'vs/editor/common/core/range';
import { DefaultEndOfLine, ITextBuffer, ITextBufferBuilder, ValidAnnotatedEditOperation } from 'vs/editor/common/model';
import { ValidAnnotatedEditOperation } from 'vs/editor/common/model';
export function getRandomInt(min: number, max: number): number {
return Math.floor(Math.random() * (max - min + 1)) + min;
@@ -127,25 +127,6 @@ export function generateRandomReplaces(chunks: string[], editCnt: number, search
return ops;
}
export function createMockText(lineCount: number, minColumn: number, maxColumn: number) {
let fixedEOL = getRandomEOLSequence();
let lines: string[] = [];
for (let i = 0; i < lineCount; i++) {
if (i !== 0) {
lines.push(fixedEOL);
}
lines.push(getRandomString(minColumn, maxColumn));
}
return lines.join('');
}
export function createMockBuffer(str: string, bufferBuilder: ITextBufferBuilder): ITextBuffer {
bufferBuilder.acceptChunk(str);
let bufferFactory = bufferBuilder.finish();
let buffer = bufferFactory.create(DefaultEndOfLine.LF);
return buffer;
}
export function generateRandomChunkWithLF(minLength: number, maxLength: number): string {
let length = getRandomInt(minLength, maxLength);
let r = '';

6
src/vs/editor/test/common/model/model.line.test.ts
View File

@@ -39,13 +39,13 @@ function assertLineTokens(__actual: LineTokens, _expected: TestToken[]): void {
type: token.getType()
};
};
assert.deepEqual(actual, expected.map(decode));
assert.deepStrictEqual(actual, expected.map(decode));
}
suite('ModelLine - getIndentLevel', () => {
function assertIndentLevel(text: string, expected: number, tabSize: number = 4): void {
let actual = TextModel.computeIndentLevel(text, tabSize);
assert.equal(actual, expected, text);
assert.strictEqual(actual, expected, text);
}
test('getIndentLevel', () => {
@@ -126,7 +126,7 @@ suite('ModelLinesTokens', () => {
for (let lineIndex = 0; lineIndex < expected.length; lineIndex++) {
const actualLine = model.getLineContent(lineIndex + 1);
const actualTokens = model.getLineTokens(lineIndex + 1);
assert.equal(actualLine, expected[lineIndex].text);
assert.strictEqual(actualLine, expected[lineIndex].text);
assertLineTokens(actualTokens, expected[lineIndex].tokens);
}
}

10
src/vs/editor/test/common/model/model.modes.test.ts
View File

@@ -21,14 +21,14 @@ suite('Editor Model - Model Modes 1', () => {
let calledFor: string[] = [];
function checkAndClear(arr: string[]) {
assert.deepEqual(calledFor, arr);
assert.deepStrictEqual(calledFor, arr);
calledFor = [];
}
const tokenizationSupport: modes.ITokenizationSupport = {
getInitialState: () => NULL_STATE,
tokenize: undefined!,
tokenize2: (line: string, state: modes.IState): TokenizationResult2 => {
tokenize2: (line: string, hasEOL: boolean, state: modes.IState): TokenizationResult2 => {
calledFor.push(line.charAt(0));
return new TokenizationResult2(new Uint32Array(0), state);
}
@@ -106,7 +106,7 @@ suite('Editor Model - Model Modes 1', () => {
checkAndClear(['1', '2', '3', '4', '5']);
thisModel.applyEdits([EditOperation.insert(new Position(1, 1), '0\n-\n+')]);
assert.equal(thisModel.getLineCount(), 7);
assert.strictEqual(thisModel.getLineCount(), 7);
thisModel.forceTokenization(7);
checkAndClear(['0', '-', '+']);
@@ -174,14 +174,14 @@ suite('Editor Model - Model Modes 2', () => {
let calledFor: string[] = [];
function checkAndClear(arr: string[]): void {
assert.deepEqual(calledFor, arr);
assert.deepStrictEqual(calledFor, arr);
calledFor = [];
}
const tokenizationSupport: modes.ITokenizationSupport = {
getInitialState: () => new ModelState2(''),
tokenize: undefined!,
tokenize2: (line: string, state: modes.IState): TokenizationResult2 => {
tokenize2: (line: string, hasEOL: boolean, state: modes.IState): TokenizationResult2 => {
calledFor.push(line);
(<ModelState2>state).prevLineContent = line;
return new TokenizationResult2(new Uint32Array(0), state);

190
src/vs/editor/test/common/model/model.test.ts
View File

@@ -46,50 +46,50 @@ suite('Editor Model - Model', () => {
// --------- insert text
test('model getValue', () => {
assert.equal(thisModel.getValue(), 'My First Line\n\t\tMy Second Line\n Third Line\n\n1');
assert.strictEqual(thisModel.getValue(), 'My First Line\n\t\tMy Second Line\n Third Line\n\n1');
});
test('model insert empty text', () => {
thisModel.applyEdits([EditOperation.insert(new Position(1, 1), '')]);
assert.equal(thisModel.getLineCount(), 5);
assert.equal(thisModel.getLineContent(1), 'My First Line');
assert.strictEqual(thisModel.getLineCount(), 5);
assert.strictEqual(thisModel.getLineContent(1), 'My First Line');
});
test('model insert text without newline 1', () => {
thisModel.applyEdits([EditOperation.insert(new Position(1, 1), 'foo ')]);
assert.equal(thisModel.getLineCount(), 5);
assert.equal(thisModel.getLineContent(1), 'foo My First Line');
assert.strictEqual(thisModel.getLineCount(), 5);
assert.strictEqual(thisModel.getLineContent(1), 'foo My First Line');
});
test('model insert text without newline 2', () => {
thisModel.applyEdits([EditOperation.insert(new Position(1, 3), ' foo')]);
assert.equal(thisModel.getLineCount(), 5);
assert.equal(thisModel.getLineContent(1), 'My foo First Line');
assert.strictEqual(thisModel.getLineCount(), 5);
assert.strictEqual(thisModel.getLineContent(1), 'My foo First Line');
});
test('model insert text with one newline', () => {
thisModel.applyEdits([EditOperation.insert(new Position(1, 3), ' new line\nNo longer')]);
assert.equal(thisModel.getLineCount(), 6);
assert.equal(thisModel.getLineContent(1), 'My new line');
assert.equal(thisModel.getLineContent(2), 'No longer First Line');
assert.strictEqual(thisModel.getLineCount(), 6);
assert.strictEqual(thisModel.getLineContent(1), 'My new line');
assert.strictEqual(thisModel.getLineContent(2), 'No longer First Line');
});
test('model insert text with two newlines', () => {
thisModel.applyEdits([EditOperation.insert(new Position(1, 3), ' new line\nOne more line in the middle\nNo longer')]);
assert.equal(thisModel.getLineCount(), 7);
assert.equal(thisModel.getLineContent(1), 'My new line');
assert.equal(thisModel.getLineContent(2), 'One more line in the middle');
assert.equal(thisModel.getLineContent(3), 'No longer First Line');
assert.strictEqual(thisModel.getLineCount(), 7);
assert.strictEqual(thisModel.getLineContent(1), 'My new line');
assert.strictEqual(thisModel.getLineContent(2), 'One more line in the middle');
assert.strictEqual(thisModel.getLineContent(3), 'No longer First Line');
});
test('model insert text with many newlines', () => {
thisModel.applyEdits([EditOperation.insert(new Position(1, 3), '\n\n\n\n')]);
assert.equal(thisModel.getLineCount(), 9);
assert.equal(thisModel.getLineContent(1), 'My');
assert.equal(thisModel.getLineContent(2), '');
assert.equal(thisModel.getLineContent(3), '');
assert.equal(thisModel.getLineContent(4), '');
assert.equal(thisModel.getLineContent(5), ' First Line');
assert.strictEqual(thisModel.getLineCount(), 9);
assert.strictEqual(thisModel.getLineContent(1), 'My');
assert.strictEqual(thisModel.getLineContent(2), '');
assert.strictEqual(thisModel.getLineContent(3), '');
assert.strictEqual(thisModel.getLineContent(4), '');
assert.strictEqual(thisModel.getLineContent(5), ' First Line');
});
@@ -111,7 +111,7 @@ suite('Editor Model - Model', () => {
e = _e;
});
thisModel.applyEdits([EditOperation.insert(new Position(1, 1), 'foo ')]);
assert.deepEqual(e, new ModelRawContentChangedEvent(
assert.deepStrictEqual(e, new ModelRawContentChangedEvent(
[
new ModelRawLineChanged(1, 'foo My First Line')
],
@@ -130,7 +130,7 @@ suite('Editor Model - Model', () => {
e = _e;
});
thisModel.applyEdits([EditOperation.insert(new Position(1, 3), ' new line\nNo longer')]);
assert.deepEqual(e, new ModelRawContentChangedEvent(
assert.deepStrictEqual(e, new ModelRawContentChangedEvent(
[
new ModelRawLineChanged(1, 'My new line'),
new ModelRawLinesInserted(2, 2, ['No longer First Line']),
@@ -146,47 +146,47 @@ suite('Editor Model - Model', () => {
test('model delete empty text', () => {
thisModel.applyEdits([EditOperation.delete(new Range(1, 1, 1, 1))]);
assert.equal(thisModel.getLineCount(), 5);
assert.equal(thisModel.getLineContent(1), 'My First Line');
assert.strictEqual(thisModel.getLineCount(), 5);
assert.strictEqual(thisModel.getLineContent(1), 'My First Line');
});
test('model delete text from one line', () => {
thisModel.applyEdits([EditOperation.delete(new Range(1, 1, 1, 2))]);
assert.equal(thisModel.getLineCount(), 5);
assert.equal(thisModel.getLineContent(1), 'y First Line');
assert.strictEqual(thisModel.getLineCount(), 5);
assert.strictEqual(thisModel.getLineContent(1), 'y First Line');
});
test('model delete text from one line 2', () => {
thisModel.applyEdits([EditOperation.insert(new Position(1, 1), 'a')]);
assert.equal(thisModel.getLineContent(1), 'aMy First Line');
assert.strictEqual(thisModel.getLineContent(1), 'aMy First Line');
thisModel.applyEdits([EditOperation.delete(new Range(1, 2, 1, 4))]);
assert.equal(thisModel.getLineCount(), 5);
assert.equal(thisModel.getLineContent(1), 'a First Line');
assert.strictEqual(thisModel.getLineCount(), 5);
assert.strictEqual(thisModel.getLineContent(1), 'a First Line');
});
test('model delete all text from a line', () => {
thisModel.applyEdits([EditOperation.delete(new Range(1, 1, 1, 14))]);
assert.equal(thisModel.getLineCount(), 5);
assert.equal(thisModel.getLineContent(1), '');
assert.strictEqual(thisModel.getLineCount(), 5);
assert.strictEqual(thisModel.getLineContent(1), '');
});
test('model delete text from two lines', () => {
thisModel.applyEdits([EditOperation.delete(new Range(1, 4, 2, 6))]);
assert.equal(thisModel.getLineCount(), 4);
assert.equal(thisModel.getLineContent(1), 'My Second Line');
assert.strictEqual(thisModel.getLineCount(), 4);
assert.strictEqual(thisModel.getLineContent(1), 'My Second Line');
});
test('model delete text from many lines', () => {
thisModel.applyEdits([EditOperation.delete(new Range(1, 4, 3, 5))]);
assert.equal(thisModel.getLineCount(), 3);
assert.equal(thisModel.getLineContent(1), 'My Third Line');
assert.strictEqual(thisModel.getLineCount(), 3);
assert.strictEqual(thisModel.getLineContent(1), 'My Third Line');
});
test('model delete everything', () => {
thisModel.applyEdits([EditOperation.delete(new Range(1, 1, 5, 2))]);
assert.equal(thisModel.getLineCount(), 1);
assert.equal(thisModel.getLineContent(1), '');
assert.strictEqual(thisModel.getLineCount(), 1);
assert.strictEqual(thisModel.getLineContent(1), '');
});
// --------- delete text eventing
@@ -207,7 +207,7 @@ suite('Editor Model - Model', () => {
e = _e;
});
thisModel.applyEdits([EditOperation.delete(new Range(1, 1, 1, 2))]);
assert.deepEqual(e, new ModelRawContentChangedEvent(
assert.deepStrictEqual(e, new ModelRawContentChangedEvent(
[
new ModelRawLineChanged(1, 'y First Line'),
],
@@ -226,7 +226,7 @@ suite('Editor Model - Model', () => {
e = _e;
});
thisModel.applyEdits([EditOperation.delete(new Range(1, 1, 1, 14))]);
assert.deepEqual(e, new ModelRawContentChangedEvent(
assert.deepStrictEqual(e, new ModelRawContentChangedEvent(
[
new ModelRawLineChanged(1, ''),
],
@@ -245,7 +245,7 @@ suite('Editor Model - Model', () => {
e = _e;
});
thisModel.applyEdits([EditOperation.delete(new Range(1, 4, 2, 6))]);
assert.deepEqual(e, new ModelRawContentChangedEvent(
assert.deepStrictEqual(e, new ModelRawContentChangedEvent(
[
new ModelRawLineChanged(1, 'My Second Line'),
new ModelRawLinesDeleted(2, 2),
@@ -265,7 +265,7 @@ suite('Editor Model - Model', () => {
e = _e;
});
thisModel.applyEdits([EditOperation.delete(new Range(1, 4, 3, 5))]);
assert.deepEqual(e, new ModelRawContentChangedEvent(
assert.deepStrictEqual(e, new ModelRawContentChangedEvent(
[
new ModelRawLineChanged(1, 'My Third Line'),
new ModelRawLinesDeleted(2, 3),
@@ -279,31 +279,31 @@ suite('Editor Model - Model', () => {
// --------- getValueInRange
test('getValueInRange', () => {
assert.equal(thisModel.getValueInRange(new Range(1, 1, 1, 1)), '');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 1, 2)), 'M');
assert.equal(thisModel.getValueInRange(new Range(1, 2, 1, 3)), 'y');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 1, 14)), 'My First Line');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 2, 1)), 'My First Line\n');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 2, 2)), 'My First Line\n\t');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 2, 3)), 'My First Line\n\t\t');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 2, 17)), 'My First Line\n\t\tMy Second Line');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 3, 1)), 'My First Line\n\t\tMy Second Line\n');
assert.equal(thisModel.getValueInRange(new Range(1, 1, 4, 1)), 'My First Line\n\t\tMy Second Line\n Third Line\n');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 1, 1)), '');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 1, 2)), 'M');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 2, 1, 3)), 'y');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 1, 14)), 'My First Line');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 2, 1)), 'My First Line\n');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 2, 2)), 'My First Line\n\t');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 2, 3)), 'My First Line\n\t\t');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 2, 17)), 'My First Line\n\t\tMy Second Line');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 3, 1)), 'My First Line\n\t\tMy Second Line\n');
assert.strictEqual(thisModel.getValueInRange(new Range(1, 1, 4, 1)), 'My First Line\n\t\tMy Second Line\n Third Line\n');
});
// --------- getValueLengthInRange
test('getValueLengthInRange', () => {
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 1, 1)), ''.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 1, 2)), 'M'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 2, 1, 3)), 'y'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 1, 14)), 'My First Line'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 2, 1)), 'My First Line\n'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 2, 2)), 'My First Line\n\t'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 2, 3)), 'My First Line\n\t\t'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 2, 17)), 'My First Line\n\t\tMy Second Line'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 3, 1)), 'My First Line\n\t\tMy Second Line\n'.length);
assert.equal(thisModel.getValueLengthInRange(new Range(1, 1, 4, 1)), 'My First Line\n\t\tMy Second Line\n Third Line\n'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 1, 1)), ''.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 1, 2)), 'M'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 2, 1, 3)), 'y'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 1, 14)), 'My First Line'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 2, 1)), 'My First Line\n'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 2, 2)), 'My First Line\n\t'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 2, 3)), 'My First Line\n\t\t'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 2, 17)), 'My First Line\n\t\tMy Second Line'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 3, 1)), 'My First Line\n\t\tMy Second Line\n'.length);
assert.strictEqual(thisModel.getValueLengthInRange(new Range(1, 1, 4, 1)), 'My First Line\n\t\tMy Second Line\n Third Line\n'.length);
});
// --------- setValue
@@ -316,7 +316,7 @@ suite('Editor Model - Model', () => {
e = _e;
});
thisModel.setValue('new value');
assert.deepEqual(e, new ModelRawContentChangedEvent(
assert.deepStrictEqual(e, new ModelRawContentChangedEvent(
[
new ModelRawFlush()
],
@@ -332,8 +332,8 @@ suite('Editor Model - Model', () => {
{ range: new Range(1, 1, 1, 1), text: 'b' },
], true);
assert.deepEqual(res[0].range, new Range(2, 1, 2, 2));
assert.deepEqual(res[1].range, new Range(1, 1, 1, 2));
assert.deepStrictEqual(res[0].range, new Range(2, 1, 2, 2));
assert.deepStrictEqual(res[1].range, new Range(1, 1, 1, 2));
});
});
@@ -358,17 +358,17 @@ suite('Editor Model - Model Line Separators', () => {
});
test('model getValue', () => {
assert.equal(thisModel.getValue(), 'My First Line\u2028\t\tMy Second Line\n Third Line\u2028\n1');
assert.strictEqual(thisModel.getValue(), 'My First Line\u2028\t\tMy Second Line\n Third Line\u2028\n1');
});
test('model lines', () => {
assert.equal(thisModel.getLineCount(), 3);
assert.strictEqual(thisModel.getLineCount(), 3);
});
test('Bug 13333:Model should line break on lonely CR too', () => {
let model = createTextModel('Hello\rWorld!\r\nAnother line');
assert.equal(model.getLineCount(), 3);
assert.equal(model.getValue(), 'Hello\r\nWorld!\r\nAnother line');
assert.strictEqual(model.getLineCount(), 3);
assert.strictEqual(model.getValue(), 'Hello\r\nWorld!\r\nAnother line');
model.dispose();
});
});
@@ -389,7 +389,7 @@ suite('Editor Model - Words', () => {
this._register(TokenizationRegistry.register(this.getLanguageIdentifier().language, {
getInitialState: (): IState => NULL_STATE,
tokenize: undefined!,
tokenize2: (line: string, state: IState): TokenizationResult2 => {
tokenize2: (line: string, hasEOL: boolean, state: IState): TokenizationResult2 => {
const tokensArr: number[] = [];
let prevLanguageId: LanguageIdentifier | undefined = undefined;
for (let i = 0; i < line.length; i++) {
@@ -434,17 +434,17 @@ suite('Editor Model - Words', () => {
const thisModel = createTextModel(text.join('\n'));
disposables.push(thisModel);
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 1)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 2)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 4)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 5)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 6)), { word: 'text', startColumn: 6, endColumn: 10 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 19)), { word: 'some', startColumn: 15, endColumn: 19 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 20)), null);
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 21)), { word: 'words', startColumn: 21, endColumn: 26 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 26)), { word: 'words', startColumn: 21, endColumn: 26 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 27)), null);
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 28)), null);
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 1)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 2)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 4)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 5)), { word: 'This', startColumn: 1, endColumn: 5 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 6)), { word: 'text', startColumn: 6, endColumn: 10 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 19)), { word: 'some', startColumn: 15, endColumn: 19 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 20)), null);
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 21)), { word: 'words', startColumn: 21, endColumn: 26 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 26)), { word: 'words', startColumn: 21, endColumn: 26 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 27)), null);
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 28)), null);
});
test('getWordAtPosition at embedded language boundaries', () => {
@@ -455,13 +455,13 @@ suite('Editor Model - Words', () => {
const model = createTextModel('ab<xx>ab<x>', undefined, outerMode.getLanguageIdentifier());
disposables.push(model);
assert.deepEqual(model.getWordAtPosition(new Position(1, 1)), { word: 'ab', startColumn: 1, endColumn: 3 });
assert.deepEqual(model.getWordAtPosition(new Position(1, 2)), { word: 'ab', startColumn: 1, endColumn: 3 });
assert.deepEqual(model.getWordAtPosition(new Position(1, 3)), { word: 'ab', startColumn: 1, endColumn: 3 });
assert.deepEqual(model.getWordAtPosition(new Position(1, 4)), { word: 'xx', startColumn: 4, endColumn: 6 });
assert.deepEqual(model.getWordAtPosition(new Position(1, 5)), { word: 'xx', startColumn: 4, endColumn: 6 });
assert.deepEqual(model.getWordAtPosition(new Position(1, 6)), { word: 'xx', startColumn: 4, endColumn: 6 });
assert.deepEqual(model.getWordAtPosition(new Position(1, 7)), { word: 'ab', startColumn: 7, endColumn: 9 });
assert.deepStrictEqual(model.getWordAtPosition(new Position(1, 1)), { word: 'ab', startColumn: 1, endColumn: 3 });
assert.deepStrictEqual(model.getWordAtPosition(new Position(1, 2)), { word: 'ab', startColumn: 1, endColumn: 3 });
assert.deepStrictEqual(model.getWordAtPosition(new Position(1, 3)), { word: 'ab', startColumn: 1, endColumn: 3 });
assert.deepStrictEqual(model.getWordAtPosition(new Position(1, 4)), { word: 'xx', startColumn: 4, endColumn: 6 });
assert.deepStrictEqual(model.getWordAtPosition(new Position(1, 5)), { word: 'xx', startColumn: 4, endColumn: 6 });
assert.deepStrictEqual(model.getWordAtPosition(new Position(1, 6)), { word: 'xx', startColumn: 4, endColumn: 6 });
assert.deepStrictEqual(model.getWordAtPosition(new Position(1, 7)), { word: 'ab', startColumn: 7, endColumn: 9 });
});
test('issue #61296: VS code freezes when editing CSS file with emoji', () => {
@@ -480,13 +480,13 @@ suite('Editor Model - Words', () => {
const thisModel = createTextModel('.🐷-a-b', undefined, MODE_ID);
disposables.push(thisModel);
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 1)), { word: '.', startColumn: 1, endColumn: 2 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 2)), { word: '.', startColumn: 1, endColumn: 2 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 3)), null);
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 4)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 5)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 6)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 7)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepEqual(thisModel.getWordAtPosition(new Position(1, 8)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 1)), { word: '.', startColumn: 1, endColumn: 2 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 2)), { word: '.', startColumn: 1, endColumn: 2 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 3)), null);
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 4)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 5)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 6)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 7)), { word: '-a-b', startColumn: 4, endColumn: 8 });
assert.deepStrictEqual(thisModel.getWordAtPosition(new Position(1, 8)), { word: '-a-b', startColumn: 4, endColumn: 8 });
});
});

68
src/vs/editor/test/common/model/modelDecorations.test.ts
View File

@@ -28,7 +28,7 @@ function modelHasDecorations(model: TextModel, decorations: ILightWeightDecorati
});
}
modelDecorations.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
assert.deepEqual(modelDecorations, decorations);
assert.deepStrictEqual(modelDecorations, decorations);
}
function modelHasDecoration(model: TextModel, startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, className: string) {
@@ -39,7 +39,7 @@ function modelHasDecoration(model: TextModel, startLineNumber: number, startColu
}
function modelHasNoDecorations(model: TextModel) {
assert.equal(model.getAllDecorations().length, 0, 'Model has no decoration');
assert.strictEqual(model.getAllDecorations().length, 0, 'Model has no decoration');
}
function addDecoration(model: TextModel, startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, className: string): string {
@@ -60,7 +60,7 @@ function lineHasDecorations(model: TextModel, lineNumber: number, decorations: {
className: decs[i].options.className
});
}
assert.deepEqual(lineDecorations, decorations, 'Line decorations');
assert.deepStrictEqual(lineDecorations, decorations, 'Line decorations');
}
function lineHasNoDecorations(model: TextModel, lineNumber: number) {
@@ -122,12 +122,12 @@ suite('Editor Model - Model Decorations', () => {
addDecoration(thisModel, 1, 1, 2, 1, 'myType');
let line1Decorations = thisModel.getLineDecorations(1);
assert.equal(line1Decorations.length, 1);
assert.equal(line1Decorations[0].options.className, 'myType');
assert.strictEqual(line1Decorations.length, 1);
assert.strictEqual(line1Decorations[0].options.className, 'myType');
let line2Decorations = thisModel.getLineDecorations(1);
assert.equal(line2Decorations.length, 1);
assert.equal(line2Decorations[0].options.className, 'myType');
assert.strictEqual(line2Decorations.length, 1);
assert.strictEqual(line2Decorations[0].options.className, 'myType');
lineHasNoDecorations(thisModel, 3);
lineHasNoDecorations(thisModel, 4);
@@ -138,16 +138,16 @@ suite('Editor Model - Model Decorations', () => {
addDecoration(thisModel, 1, 2, 3, 2, 'myType');
let line1Decorations = thisModel.getLineDecorations(1);
assert.equal(line1Decorations.length, 1);
assert.equal(line1Decorations[0].options.className, 'myType');
assert.strictEqual(line1Decorations.length, 1);
assert.strictEqual(line1Decorations[0].options.className, 'myType');
let line2Decorations = thisModel.getLineDecorations(1);
assert.equal(line2Decorations.length, 1);
assert.equal(line2Decorations[0].options.className, 'myType');
assert.strictEqual(line2Decorations.length, 1);
assert.strictEqual(line2Decorations[0].options.className, 'myType');
let line3Decorations = thisModel.getLineDecorations(1);
assert.equal(line3Decorations.length, 1);
assert.equal(line3Decorations[0].options.className, 'myType');
assert.strictEqual(line3Decorations.length, 1);
assert.strictEqual(line3Decorations[0].options.className, 'myType');
lineHasNoDecorations(thisModel, 4);
lineHasNoDecorations(thisModel, 5);
@@ -209,7 +209,7 @@ suite('Editor Model - Model Decorations', () => {
listenerCalled++;
});
addDecoration(thisModel, 1, 2, 3, 2, 'myType');
assert.equal(listenerCalled, 1, 'listener called');
assert.strictEqual(listenerCalled, 1, 'listener called');
});
test('decorations emit event on change', () => {
@@ -221,7 +221,7 @@ suite('Editor Model - Model Decorations', () => {
thisModel.changeDecorations((changeAccessor) => {
changeAccessor.changeDecoration(decId, new Range(1, 1, 1, 2));
});
assert.equal(listenerCalled, 1, 'listener called');
assert.strictEqual(listenerCalled, 1, 'listener called');
});
test('decorations emit event on remove', () => {
@@ -233,7 +233,7 @@ suite('Editor Model - Model Decorations', () => {
thisModel.changeDecorations((changeAccessor) => {
changeAccessor.removeDecoration(decId);
});
assert.equal(listenerCalled, 1, 'listener called');
assert.strictEqual(listenerCalled, 1, 'listener called');
});
test('decorations emit event when inserting one line text before it', () => {
@@ -245,7 +245,7 @@ suite('Editor Model - Model Decorations', () => {
});
thisModel.applyEdits([EditOperation.insert(new Position(1, 1), 'Hallo ')]);
assert.equal(listenerCalled, 1, 'listener called');
assert.strictEqual(listenerCalled, 1, 'listener called');
});
test('decorations do not emit event on no-op deltaDecorations', () => {
@@ -260,7 +260,7 @@ suite('Editor Model - Model Decorations', () => {
accessor.deltaDecorations([], []);
});
assert.equal(listenerCalled, 0, 'listener not called');
assert.strictEqual(listenerCalled, 0, 'listener not called');
});
// --------- editing text & effects on decorations
@@ -429,7 +429,7 @@ suite('Decorations and editing', () => {
forceMoveMarkers: editForceMoveMarkers
}]);
const actual = model.getDecorationRange(id);
assert.deepEqual(actual, expectedDecRange, msg);
assert.deepStrictEqual(actual, expectedDecRange, msg);
model.dispose();
}
@@ -1155,20 +1155,20 @@ suite('deltaDecorations', () => {
let initialIds = model.deltaDecorations([], decorations.map(toModelDeltaDecoration));
let actualDecorations = readModelDecorations(model, initialIds);
assert.equal(initialIds.length, decorations.length, 'returns expected cnt of ids');
assert.equal(initialIds.length, model.getAllDecorations().length, 'does not leak decorations');
assert.strictEqual(initialIds.length, decorations.length, 'returns expected cnt of ids');
assert.strictEqual(initialIds.length, model.getAllDecorations().length, 'does not leak decorations');
actualDecorations.sort((a, b) => strcmp(a.id, b.id));
decorations.sort((a, b) => strcmp(a.id, b.id));
assert.deepEqual(actualDecorations, decorations);
assert.deepStrictEqual(actualDecorations, decorations);
let newIds = model.deltaDecorations(initialIds, newDecorations.map(toModelDeltaDecoration));
let actualNewDecorations = readModelDecorations(model, newIds);
assert.equal(newIds.length, newDecorations.length, 'returns expected cnt of ids');
assert.equal(newIds.length, model.getAllDecorations().length, 'does not leak decorations');
assert.strictEqual(newIds.length, newDecorations.length, 'returns expected cnt of ids');
assert.strictEqual(newIds.length, model.getAllDecorations().length, 'does not leak decorations');
actualNewDecorations.sort((a, b) => strcmp(a.id, b.id));
newDecorations.sort((a, b) => strcmp(a.id, b.id));
assert.deepEqual(actualDecorations, decorations);
assert.deepStrictEqual(actualDecorations, decorations);
model.dispose();
}
@@ -1188,8 +1188,8 @@ suite('deltaDecorations', () => {
toModelDeltaDecoration(decoration('b', 2, 1, 2, 13))
]);
assert.deepEqual(model.getDecorationRange(ids[0]), range(1, 1, 1, 12));
assert.deepEqual(model.getDecorationRange(ids[1]), range(2, 1, 2, 13));
assert.deepStrictEqual(model.getDecorationRange(ids[0]), range(1, 1, 1, 12));
assert.deepStrictEqual(model.getDecorationRange(ids[1]), range(2, 1, 2, 13));
model.dispose();
});
@@ -1294,7 +1294,7 @@ suite('deltaDecorations', () => {
let actualDecoration = model.getDecorationOptions(ids[0]);
assert.deepEqual(actualDecoration!.hoverMessage, { value: 'hello2' });
assert.deepStrictEqual(actualDecoration!.hoverMessage, { value: 'hello2' });
model.dispose();
});
@@ -1326,16 +1326,16 @@ suite('deltaDecorations', () => {
toModelDeltaDecoration(decoration('b', 2, 1, 2, 13))
]);
assert.deepEqual(model.getDecorationRange(ids[0]), range(1, 1, 1, 12));
assert.deepEqual(model.getDecorationRange(ids[1]), range(2, 1, 2, 13));
assert.deepStrictEqual(model.getDecorationRange(ids[0]), range(1, 1, 1, 12));
assert.deepStrictEqual(model.getDecorationRange(ids[1]), range(2, 1, 2, 13));
ids = model.deltaDecorations(ids, [
toModelDeltaDecoration(decoration('a', 1, 1, 1, 12)),
toModelDeltaDecoration(decoration('b', 2, 1, 2, 13))
]);
assert.deepEqual(model.getDecorationRange(ids[0]), range(1, 1, 1, 12));
assert.deepEqual(model.getDecorationRange(ids[1]), range(2, 1, 2, 13));
assert.deepStrictEqual(model.getDecorationRange(ids[0]), range(1, 1, 1, 12));
assert.deepStrictEqual(model.getDecorationRange(ids[1]), range(2, 1, 2, 13));
model.dispose();
});
@@ -1365,7 +1365,7 @@ suite('deltaDecorations', () => {
let inRangeClassNames = inRange.map(d => d.options.className);
inRangeClassNames.sort();
assert.deepEqual(inRangeClassNames, ['x1', 'x2', 'x3', 'x4']);
assert.deepStrictEqual(inRangeClassNames, ['x1', 'x2', 'x3', 'x4']);
model.dispose();
});
@@ -1383,7 +1383,7 @@ suite('deltaDecorations', () => {
forceMoveMarkers: false
}]);
const actual = model.getDecorationRange(id);
assert.deepEqual(actual, new Range(1, 1, 1, 1));
assert.deepStrictEqual(actual, new Range(1, 1, 1, 1));
model.dispose();
});

18
src/vs/editor/test/common/model/modelEditOperation.test.ts
View File

@@ -52,19 +52,19 @@ suite('Editor Model - Model Edit Operation', () => {
let inverseEditOp = model.applyEdits(editOp, true);
assert.equal(model.getLineCount(), editedLines.length);
assert.strictEqual(model.getLineCount(), editedLines.length);
for (let i = 0; i < editedLines.length; i++) {
assert.equal(model.getLineContent(i + 1), editedLines[i]);
assert.strictEqual(model.getLineContent(i + 1), editedLines[i]);
}
let originalOp = model.applyEdits(inverseEditOp, true);
assert.equal(model.getLineCount(), 5);
assert.equal(model.getLineContent(1), LINE1);
assert.equal(model.getLineContent(2), LINE2);
assert.equal(model.getLineContent(3), LINE3);
assert.equal(model.getLineContent(4), LINE4);
assert.equal(model.getLineContent(5), LINE5);
assert.strictEqual(model.getLineCount(), 5);
assert.strictEqual(model.getLineContent(1), LINE1);
assert.strictEqual(model.getLineContent(2), LINE2);
assert.strictEqual(model.getLineContent(3), LINE3);
assert.strictEqual(model.getLineContent(4), LINE4);
assert.strictEqual(model.getLineContent(5), LINE5);
const simplifyEdit = (edit: IIdentifiedSingleEditOperation) => {
return {
@@ -75,7 +75,7 @@ suite('Editor Model - Model Edit Operation', () => {
isAutoWhitespaceEdit: edit.isAutoWhitespaceEdit || false
};
};
assert.deepEqual(originalOp.map(simplifyEdit), editOp.map(simplifyEdit));
assert.deepStrictEqual(originalOp.map(simplifyEdit), editOp.map(simplifyEdit));
}
test('Insert inline', () => {

358
src/vs/editor/test/common/model/pieceTreeTextBuffer/pieceTreeTextBuffer.test.ts
View File

@@ -77,11 +77,11 @@ function trimLineFeed(text: string): string {
function testLinesContent(str: string, pieceTable: PieceTreeBase) {
let lines = splitLines(str);
assert.equal(pieceTable.getLineCount(), lines.length);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLineCount(), lines.length);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
for (let i = 0; i < lines.length; i++) {
assert.equal(pieceTable.getLineContent(i + 1), lines[i]);
assert.equal(
assert.strictEqual(pieceTable.getLineContent(i + 1), lines[i]);
assert.strictEqual(
trimLineFeed(
pieceTable.getValueInRange(
new Range(
@@ -136,16 +136,16 @@ function testLineStarts(str: string, pieceTable: PieceTreeBase) {
} while (m);
for (let i = 0; i < lineStarts.length; i++) {
assert.deepEqual(
assert.deepStrictEqual(
pieceTable.getPositionAt(lineStarts[i]),
new Position(i + 1, 1)
);
assert.equal(pieceTable.getOffsetAt(i + 1, 1), lineStarts[i]);
assert.strictEqual(pieceTable.getOffsetAt(i + 1, 1), lineStarts[i]);
}
for (let i = 1; i < lineStarts.length; i++) {
let pos = pieceTable.getPositionAt(lineStarts[i] - 1);
assert.equal(
assert.strictEqual(
pieceTable.getOffsetAt(pos.lineNumber, pos.column),
lineStarts[i] - 1
);
@@ -158,7 +158,7 @@ function createTextBuffer(val: string[], normalizeEOL: boolean = true): PieceTre
bufferBuilder.acceptChunk(chunk);
}
let factory = bufferBuilder.finish(normalizeEOL);
return (<PieceTreeTextBuffer>factory.create(DefaultEndOfLine.LF)).getPieceTree();
return (<PieceTreeTextBuffer>factory.create(DefaultEndOfLine.LF).textBuffer).getPieceTree();
}
function assertTreeInvariants(T: PieceTreeBase): void {
@@ -219,12 +219,12 @@ suite('inserts and deletes', () => {
]);
pieceTable.insert(34, 'This is some more text to insert at offset 34.');
assert.equal(
assert.strictEqual(
pieceTable.getLinesRawContent(),
'This is a document with some text.This is some more text to insert at offset 34.'
);
pieceTable.delete(42, 5);
assert.equal(
assert.strictEqual(
pieceTable.getLinesRawContent(),
'This is a document with some text.This is more text to insert at offset 34.'
);
@@ -235,28 +235,28 @@ suite('inserts and deletes', () => {
let pt = createTextBuffer(['']);
pt.insert(0, 'AAA');
assert.equal(pt.getLinesRawContent(), 'AAA');
assert.strictEqual(pt.getLinesRawContent(), 'AAA');
pt.insert(0, 'BBB');
assert.equal(pt.getLinesRawContent(), 'BBBAAA');
assert.strictEqual(pt.getLinesRawContent(), 'BBBAAA');
pt.insert(6, 'CCC');
assert.equal(pt.getLinesRawContent(), 'BBBAAACCC');
assert.strictEqual(pt.getLinesRawContent(), 'BBBAAACCC');
pt.insert(5, 'DDD');
assert.equal(pt.getLinesRawContent(), 'BBBAADDDACCC');
assert.strictEqual(pt.getLinesRawContent(), 'BBBAADDDACCC');
assertTreeInvariants(pt);
});
test('more deletes', () => {
let pt = createTextBuffer(['012345678']);
pt.delete(8, 1);
assert.equal(pt.getLinesRawContent(), '01234567');
assert.strictEqual(pt.getLinesRawContent(), '01234567');
pt.delete(0, 1);
assert.equal(pt.getLinesRawContent(), '1234567');
assert.strictEqual(pt.getLinesRawContent(), '1234567');
pt.delete(5, 1);
assert.equal(pt.getLinesRawContent(), '123457');
assert.strictEqual(pt.getLinesRawContent(), '123457');
pt.delete(5, 1);
assert.equal(pt.getLinesRawContent(), '12345');
assert.strictEqual(pt.getLinesRawContent(), '12345');
pt.delete(0, 5);
assert.equal(pt.getLinesRawContent(), '');
assert.strictEqual(pt.getLinesRawContent(), '');
assertTreeInvariants(pt);
});
@@ -265,17 +265,17 @@ suite('inserts and deletes', () => {
let pieceTable = createTextBuffer(['']);
pieceTable.insert(0, 'ceLPHmFzvCtFeHkCBej ');
str = str.substring(0, 0) + 'ceLPHmFzvCtFeHkCBej ' + str.substring(0);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.insert(8, 'gDCEfNYiBUNkSwtvB K ');
str = str.substring(0, 8) + 'gDCEfNYiBUNkSwtvB K ' + str.substring(8);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.insert(38, 'cyNcHxjNPPoehBJldLS ');
str = str.substring(0, 38) + 'cyNcHxjNPPoehBJldLS ' + str.substring(38);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.insert(59, 'ejMx\nOTgWlbpeDExjOk ');
str = str.substring(0, 59) + 'ejMx\nOTgWlbpeDExjOk ' + str.substring(59);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -293,7 +293,7 @@ suite('inserts and deletes', () => {
pieceTable.insert(10, 'Gbtp ');
str = str.substring(0, 10) + 'Gbtp ' + str.substring(10);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -310,7 +310,7 @@ suite('inserts and deletes', () => {
str = str.substring(0, 2) + 'GGZB' + str.substring(2);
pieceTable.insert(12, 'wXpq');
str = str.substring(0, 12) + 'wXpq' + str.substring(12);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
});
test('random delete 1', () => {
@@ -319,30 +319,30 @@ suite('inserts and deletes', () => {
pieceTable.insert(0, 'vfb');
str = str.substring(0, 0) + 'vfb' + str.substring(0);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.insert(0, 'zRq');
str = str.substring(0, 0) + 'zRq' + str.substring(0);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.delete(5, 1);
str = str.substring(0, 5) + str.substring(5 + 1);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.insert(1, 'UNw');
str = str.substring(0, 1) + 'UNw' + str.substring(1);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.delete(4, 3);
str = str.substring(0, 4) + str.substring(4 + 3);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.delete(1, 4);
str = str.substring(0, 1) + str.substring(1 + 4);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.delete(0, 1);
str = str.substring(0, 0) + str.substring(0 + 1);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -368,7 +368,7 @@ suite('inserts and deletes', () => {
str = str.substring(0, 6) + str.substring(6 + 7);
pieceTable.delete(3, 5);
str = str.substring(0, 3) + str.substring(3 + 5);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -401,7 +401,7 @@ suite('inserts and deletes', () => {
str = str.substring(0, 5) + str.substring(5 + 8);
pieceTable.delete(3, 4);
str = str.substring(0, 3) + str.substring(3 + 4);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -427,7 +427,7 @@ suite('inserts and deletes', () => {
pieceTable.insert(5, '\n\na\r');
str = str.substring(0, 5) + '\n\na\r' + str.substring(5);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -455,7 +455,7 @@ suite('inserts and deletes', () => {
pieceTable.insert(2, 'a\ra\n');
str = str.substring(0, 2) + 'a\ra\n' + str.substring(2);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -480,11 +480,11 @@ suite('inserts and deletes', () => {
str = str.substring(0, 5) + '\n\na\r' + str.substring(5);
pieceTable.insert(10, '\r\r\n\r');
str = str.substring(0, 10) + '\r\r\n\r' + str.substring(10);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
pieceTable.delete(21, 3);
str = str.substring(0, 21) + str.substring(21 + 3);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
@@ -512,7 +512,7 @@ suite('inserts and deletes', () => {
pieceTable.insert(3, 'a\naa');
str = str.substring(0, 3) + 'a\naa' + str.substring(3);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
test('random insert/delete \\r bug 5', () => {
@@ -539,7 +539,7 @@ suite('inserts and deletes', () => {
pieceTable.insert(15, '\n\r\r\r');
str = str.substring(0, 15) + '\n\r\r\r' + str.substring(15);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
assertTreeInvariants(pieceTable);
});
});
@@ -548,22 +548,22 @@ suite('prefix sum for line feed', () => {
test('basic', () => {
let pieceTable = createTextBuffer(['1\n2\n3\n4']);
assert.equal(pieceTable.getLineCount(), 4);
assert.deepEqual(pieceTable.getPositionAt(0), new Position(1, 1));
assert.deepEqual(pieceTable.getPositionAt(1), new Position(1, 2));
assert.deepEqual(pieceTable.getPositionAt(2), new Position(2, 1));
assert.deepEqual(pieceTable.getPositionAt(3), new Position(2, 2));
assert.deepEqual(pieceTable.getPositionAt(4), new Position(3, 1));
assert.deepEqual(pieceTable.getPositionAt(5), new Position(3, 2));
assert.deepEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.strictEqual(pieceTable.getLineCount(), 4);
assert.deepStrictEqual(pieceTable.getPositionAt(0), new Position(1, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(1), new Position(1, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(2), new Position(2, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(3), new Position(2, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(4), new Position(3, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(5), new Position(3, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.equal(pieceTable.getOffsetAt(1, 1), 0);
assert.equal(pieceTable.getOffsetAt(1, 2), 1);
assert.equal(pieceTable.getOffsetAt(2, 1), 2);
assert.equal(pieceTable.getOffsetAt(2, 2), 3);
assert.equal(pieceTable.getOffsetAt(3, 1), 4);
assert.equal(pieceTable.getOffsetAt(3, 2), 5);
assert.equal(pieceTable.getOffsetAt(4, 1), 6);
assert.strictEqual(pieceTable.getOffsetAt(1, 1), 0);
assert.strictEqual(pieceTable.getOffsetAt(1, 2), 1);
assert.strictEqual(pieceTable.getOffsetAt(2, 1), 2);
assert.strictEqual(pieceTable.getOffsetAt(2, 2), 3);
assert.strictEqual(pieceTable.getOffsetAt(3, 1), 4);
assert.strictEqual(pieceTable.getOffsetAt(3, 2), 5);
assert.strictEqual(pieceTable.getOffsetAt(4, 1), 6);
assertTreeInvariants(pieceTable);
});
@@ -571,9 +571,9 @@ suite('prefix sum for line feed', () => {
let pieceTable = createTextBuffer(['a\nb\nc\nde']);
pieceTable.insert(8, 'fh\ni\njk');
assert.equal(pieceTable.getLineCount(), 6);
assert.deepEqual(pieceTable.getPositionAt(9), new Position(4, 4));
assert.equal(pieceTable.getOffsetAt(1, 1), 0);
assert.strictEqual(pieceTable.getLineCount(), 6);
assert.deepStrictEqual(pieceTable.getPositionAt(9), new Position(4, 4));
assert.strictEqual(pieceTable.getOffsetAt(1, 1), 0);
assertTreeInvariants(pieceTable);
});
@@ -581,22 +581,22 @@ suite('prefix sum for line feed', () => {
let pieceTable = createTextBuffer(['a\nb\nc\nde']);
pieceTable.insert(7, 'fh\ni\njk');
assert.equal(pieceTable.getLineCount(), 6);
assert.deepEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.deepEqual(pieceTable.getPositionAt(7), new Position(4, 2));
assert.deepEqual(pieceTable.getPositionAt(8), new Position(4, 3));
assert.deepEqual(pieceTable.getPositionAt(9), new Position(4, 4));
assert.deepEqual(pieceTable.getPositionAt(12), new Position(6, 1));
assert.deepEqual(pieceTable.getPositionAt(13), new Position(6, 2));
assert.deepEqual(pieceTable.getPositionAt(14), new Position(6, 3));
assert.strictEqual(pieceTable.getLineCount(), 6);
assert.deepStrictEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(7), new Position(4, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(8), new Position(4, 3));
assert.deepStrictEqual(pieceTable.getPositionAt(9), new Position(4, 4));
assert.deepStrictEqual(pieceTable.getPositionAt(12), new Position(6, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(13), new Position(6, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(14), new Position(6, 3));
assert.equal(pieceTable.getOffsetAt(4, 1), 6);
assert.equal(pieceTable.getOffsetAt(4, 2), 7);
assert.equal(pieceTable.getOffsetAt(4, 3), 8);
assert.equal(pieceTable.getOffsetAt(4, 4), 9);
assert.equal(pieceTable.getOffsetAt(6, 1), 12);
assert.equal(pieceTable.getOffsetAt(6, 2), 13);
assert.equal(pieceTable.getOffsetAt(6, 3), 14);
assert.strictEqual(pieceTable.getOffsetAt(4, 1), 6);
assert.strictEqual(pieceTable.getOffsetAt(4, 2), 7);
assert.strictEqual(pieceTable.getOffsetAt(4, 3), 8);
assert.strictEqual(pieceTable.getOffsetAt(4, 4), 9);
assert.strictEqual(pieceTable.getOffsetAt(6, 1), 12);
assert.strictEqual(pieceTable.getOffsetAt(6, 2), 13);
assert.strictEqual(pieceTable.getOffsetAt(6, 3), 14);
assertTreeInvariants(pieceTable);
});
@@ -604,23 +604,23 @@ suite('prefix sum for line feed', () => {
let pieceTable = createTextBuffer(['a\nb\nc\ndefh\ni\njk']);
pieceTable.delete(7, 2);
assert.equal(pieceTable.getLinesRawContent(), 'a\nb\nc\ndh\ni\njk');
assert.equal(pieceTable.getLineCount(), 6);
assert.deepEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.deepEqual(pieceTable.getPositionAt(7), new Position(4, 2));
assert.deepEqual(pieceTable.getPositionAt(8), new Position(4, 3));
assert.deepEqual(pieceTable.getPositionAt(9), new Position(5, 1));
assert.deepEqual(pieceTable.getPositionAt(11), new Position(6, 1));
assert.deepEqual(pieceTable.getPositionAt(12), new Position(6, 2));
assert.deepEqual(pieceTable.getPositionAt(13), new Position(6, 3));
assert.strictEqual(pieceTable.getLinesRawContent(), 'a\nb\nc\ndh\ni\njk');
assert.strictEqual(pieceTable.getLineCount(), 6);
assert.deepStrictEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(7), new Position(4, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(8), new Position(4, 3));
assert.deepStrictEqual(pieceTable.getPositionAt(9), new Position(5, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(11), new Position(6, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(12), new Position(6, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(13), new Position(6, 3));
assert.equal(pieceTable.getOffsetAt(4, 1), 6);
assert.equal(pieceTable.getOffsetAt(4, 2), 7);
assert.equal(pieceTable.getOffsetAt(4, 3), 8);
assert.equal(pieceTable.getOffsetAt(5, 1), 9);
assert.equal(pieceTable.getOffsetAt(6, 1), 11);
assert.equal(pieceTable.getOffsetAt(6, 2), 12);
assert.equal(pieceTable.getOffsetAt(6, 3), 13);
assert.strictEqual(pieceTable.getOffsetAt(4, 1), 6);
assert.strictEqual(pieceTable.getOffsetAt(4, 2), 7);
assert.strictEqual(pieceTable.getOffsetAt(4, 3), 8);
assert.strictEqual(pieceTable.getOffsetAt(5, 1), 9);
assert.strictEqual(pieceTable.getOffsetAt(6, 1), 11);
assert.strictEqual(pieceTable.getOffsetAt(6, 2), 12);
assert.strictEqual(pieceTable.getOffsetAt(6, 3), 13);
assertTreeInvariants(pieceTable);
});
@@ -629,23 +629,23 @@ suite('prefix sum for line feed', () => {
pieceTable.insert(8, 'fh\ni\njk');
pieceTable.delete(7, 2);
assert.equal(pieceTable.getLinesRawContent(), 'a\nb\nc\ndh\ni\njk');
assert.equal(pieceTable.getLineCount(), 6);
assert.deepEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.deepEqual(pieceTable.getPositionAt(7), new Position(4, 2));
assert.deepEqual(pieceTable.getPositionAt(8), new Position(4, 3));
assert.deepEqual(pieceTable.getPositionAt(9), new Position(5, 1));
assert.deepEqual(pieceTable.getPositionAt(11), new Position(6, 1));
assert.deepEqual(pieceTable.getPositionAt(12), new Position(6, 2));
assert.deepEqual(pieceTable.getPositionAt(13), new Position(6, 3));
assert.strictEqual(pieceTable.getLinesRawContent(), 'a\nb\nc\ndh\ni\njk');
assert.strictEqual(pieceTable.getLineCount(), 6);
assert.deepStrictEqual(pieceTable.getPositionAt(6), new Position(4, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(7), new Position(4, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(8), new Position(4, 3));
assert.deepStrictEqual(pieceTable.getPositionAt(9), new Position(5, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(11), new Position(6, 1));
assert.deepStrictEqual(pieceTable.getPositionAt(12), new Position(6, 2));
assert.deepStrictEqual(pieceTable.getPositionAt(13), new Position(6, 3));
assert.equal(pieceTable.getOffsetAt(4, 1), 6);
assert.equal(pieceTable.getOffsetAt(4, 2), 7);
assert.equal(pieceTable.getOffsetAt(4, 3), 8);
assert.equal(pieceTable.getOffsetAt(5, 1), 9);
assert.equal(pieceTable.getOffsetAt(6, 1), 11);
assert.equal(pieceTable.getOffsetAt(6, 2), 12);
assert.equal(pieceTable.getOffsetAt(6, 3), 13);
assert.strictEqual(pieceTable.getOffsetAt(4, 1), 6);
assert.strictEqual(pieceTable.getOffsetAt(4, 2), 7);
assert.strictEqual(pieceTable.getOffsetAt(4, 3), 8);
assert.strictEqual(pieceTable.getOffsetAt(5, 1), 9);
assert.strictEqual(pieceTable.getOffsetAt(6, 1), 11);
assert.strictEqual(pieceTable.getOffsetAt(6, 2), 12);
assert.strictEqual(pieceTable.getOffsetAt(6, 3), 13);
assertTreeInvariants(pieceTable);
});
@@ -661,7 +661,7 @@ suite('prefix sum for line feed', () => {
str =
str.substring(0, 14) + 'X ZZ\nYZZYZXXY Y XY\n ' + str.substring(14);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
assertTreeInvariants(pieceTable);
});
@@ -675,7 +675,7 @@ suite('prefix sum for line feed', () => {
pieceTable.insert(3, 'XXY \n\nY Y YYY ZYXY ');
str = str.substring(0, 3) + 'XXY \n\nY Y YYY ZYXY ' + str.substring(3);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
assertTreeInvariants(pieceTable);
});
@@ -803,12 +803,12 @@ suite('get text in range', () => {
pieceTable.delete(7, 2);
// 'a\nb\nc\ndh\ni\njk'
assert.equal(pieceTable.getValueInRange(new Range(1, 1, 1, 3)), 'a\n');
assert.equal(pieceTable.getValueInRange(new Range(2, 1, 2, 3)), 'b\n');
assert.equal(pieceTable.getValueInRange(new Range(3, 1, 3, 3)), 'c\n');
assert.equal(pieceTable.getValueInRange(new Range(4, 1, 4, 4)), 'dh\n');
assert.equal(pieceTable.getValueInRange(new Range(5, 1, 5, 3)), 'i\n');
assert.equal(pieceTable.getValueInRange(new Range(6, 1, 6, 3)), 'jk');
assert.strictEqual(pieceTable.getValueInRange(new Range(1, 1, 1, 3)), 'a\n');
assert.strictEqual(pieceTable.getValueInRange(new Range(2, 1, 2, 3)), 'b\n');
assert.strictEqual(pieceTable.getValueInRange(new Range(3, 1, 3, 3)), 'c\n');
assert.strictEqual(pieceTable.getValueInRange(new Range(4, 1, 4, 4)), 'dh\n');
assert.strictEqual(pieceTable.getValueInRange(new Range(5, 1, 5, 3)), 'i\n');
assert.strictEqual(pieceTable.getValueInRange(new Range(6, 1, 6, 3)), 'jk');
assertTreeInvariants(pieceTable);
});
@@ -902,18 +902,18 @@ suite('get text in range', () => {
test('get line content', () => {
let pieceTable = createTextBuffer(['1']);
assert.equal(pieceTable.getLineRawContent(1), '1');
assert.strictEqual(pieceTable.getLineRawContent(1), '1');
pieceTable.insert(1, '2');
assert.equal(pieceTable.getLineRawContent(1), '12');
assert.strictEqual(pieceTable.getLineRawContent(1), '12');
assertTreeInvariants(pieceTable);
});
test('get line content basic', () => {
let pieceTable = createTextBuffer(['1\n2\n3\n4']);
assert.equal(pieceTable.getLineRawContent(1), '1\n');
assert.equal(pieceTable.getLineRawContent(2), '2\n');
assert.equal(pieceTable.getLineRawContent(3), '3\n');
assert.equal(pieceTable.getLineRawContent(4), '4');
assert.strictEqual(pieceTable.getLineRawContent(1), '1\n');
assert.strictEqual(pieceTable.getLineRawContent(2), '2\n');
assert.strictEqual(pieceTable.getLineRawContent(3), '3\n');
assert.strictEqual(pieceTable.getLineRawContent(4), '4');
assertTreeInvariants(pieceTable);
});
@@ -923,12 +923,12 @@ suite('get text in range', () => {
pieceTable.delete(7, 2);
// 'a\nb\nc\ndh\ni\njk'
assert.equal(pieceTable.getLineRawContent(1), 'a\n');
assert.equal(pieceTable.getLineRawContent(2), 'b\n');
assert.equal(pieceTable.getLineRawContent(3), 'c\n');
assert.equal(pieceTable.getLineRawContent(4), 'dh\n');
assert.equal(pieceTable.getLineRawContent(5), 'i\n');
assert.equal(pieceTable.getLineRawContent(6), 'jk');
assert.strictEqual(pieceTable.getLineRawContent(1), 'a\n');
assert.strictEqual(pieceTable.getLineRawContent(2), 'b\n');
assert.strictEqual(pieceTable.getLineRawContent(3), 'c\n');
assert.strictEqual(pieceTable.getLineRawContent(4), 'dh\n');
assert.strictEqual(pieceTable.getLineRawContent(5), 'i\n');
assert.strictEqual(pieceTable.getLineRawContent(6), 'jk');
assertTreeInvariants(pieceTable);
});
@@ -973,7 +973,7 @@ suite('CRLF', () => {
pieceTable.insert(0, 'a\r\nb');
pieceTable.delete(0, 2);
assert.equal(pieceTable.getLineCount(), 2);
assert.strictEqual(pieceTable.getLineCount(), 2);
assertTreeInvariants(pieceTable);
});
@@ -982,7 +982,7 @@ suite('CRLF', () => {
pieceTable.insert(0, 'a\r\nb');
pieceTable.delete(2, 2);
assert.equal(pieceTable.getLineCount(), 2);
assert.strictEqual(pieceTable.getLineCount(), 2);
assertTreeInvariants(pieceTable);
});
@@ -999,7 +999,7 @@ suite('CRLF', () => {
str = str.substring(0, 2) + str.substring(2 + 3);
let lines = splitLines(str);
assert.equal(pieceTable.getLineCount(), lines.length);
assert.strictEqual(pieceTable.getLineCount(), lines.length);
assertTreeInvariants(pieceTable);
});
test('random bug 2', () => {
@@ -1014,7 +1014,7 @@ suite('CRLF', () => {
str = str.substring(0, 4) + str.substring(4 + 1);
let lines = splitLines(str);
assert.equal(pieceTable.getLineCount(), lines.length);
assert.strictEqual(pieceTable.getLineCount(), lines.length);
assertTreeInvariants(pieceTable);
});
test('random bug 3', () => {
@@ -1035,7 +1035,7 @@ suite('CRLF', () => {
str = str.substring(0, 3) + '\r\r\r\n' + str.substring(3);
let lines = splitLines(str);
assert.equal(pieceTable.getLineCount(), lines.length);
assert.strictEqual(pieceTable.getLineCount(), lines.length);
assertTreeInvariants(pieceTable);
});
test('random bug 4', () => {
@@ -1185,14 +1185,14 @@ suite('centralized lineStarts with CRLF', () => {
test('delete CR in CRLF 1', () => {
let pieceTable = createTextBuffer(['a\r\nb'], false);
pieceTable.delete(2, 2);
assert.equal(pieceTable.getLineCount(), 2);
assert.strictEqual(pieceTable.getLineCount(), 2);
assertTreeInvariants(pieceTable);
});
test('delete CR in CRLF 2', () => {
let pieceTable = createTextBuffer(['a\r\nb']);
pieceTable.delete(0, 2);
assert.equal(pieceTable.getLineCount(), 2);
assert.strictEqual(pieceTable.getLineCount(), 2);
assertTreeInvariants(pieceTable);
});
@@ -1207,7 +1207,7 @@ suite('centralized lineStarts with CRLF', () => {
str = str.substring(0, 2) + str.substring(2 + 3);
let lines = splitLines(str);
assert.equal(pieceTable.getLineCount(), lines.length);
assert.strictEqual(pieceTable.getLineCount(), lines.length);
assertTreeInvariants(pieceTable);
});
test('random bug 2', () => {
@@ -1220,7 +1220,7 @@ suite('centralized lineStarts with CRLF', () => {
str = str.substring(0, 4) + str.substring(4 + 1);
let lines = splitLines(str);
assert.equal(pieceTable.getLineCount(), lines.length);
assert.strictEqual(pieceTable.getLineCount(), lines.length);
assertTreeInvariants(pieceTable);
});
@@ -1240,7 +1240,7 @@ suite('centralized lineStarts with CRLF', () => {
str = str.substring(0, 3) + '\r\r\r\n' + str.substring(3);
let lines = splitLines(str);
assert.equal(pieceTable.getLineCount(), lines.length);
assert.strictEqual(pieceTable.getLineCount(), lines.length);
assertTreeInvariants(pieceTable);
});
@@ -1386,7 +1386,7 @@ suite('centralized lineStarts with CRLF', () => {
pieceTable.insert(7, '\r\r\r\r');
str = str.substring(0, 7) + '\r\r\r\r' + str.substring(7);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
assertTreeInvariants(pieceTable);
});
@@ -1407,7 +1407,7 @@ suite('centralized lineStarts with CRLF', () => {
pieceTable.delete(11, 2);
str = str.substring(0, 11) + str.substring(11 + 2);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
assertTreeInvariants(pieceTable);
});
@@ -1424,7 +1424,7 @@ suite('centralized lineStarts with CRLF', () => {
pieceTable.delete(1, 2);
str = str.substring(0, 1) + str.substring(1 + 2);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
assertTreeInvariants(pieceTable);
});
@@ -1437,7 +1437,7 @@ suite('centralized lineStarts with CRLF', () => {
pieceTable.insert(3, '\r\n\n\n');
str = str.substring(0, 3) + '\r\n\n\n' + str.substring(3);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
assertTreeInvariants(pieceTable);
});
@@ -1469,7 +1469,7 @@ suite('random is unsupervised', () => {
pieceTable.insert(0, 'VZXXZYZX\r');
str = str.substring(0, 0) + 'VZXXZYZX\r' + str.substring(0);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
testLinesContent(str, pieceTable);
@@ -1507,7 +1507,7 @@ suite('random is unsupervised', () => {
}
// console.log(output);
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
testLinesContent(str, pieceTable);
@@ -1543,7 +1543,7 @@ suite('random is unsupervised', () => {
}
}
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
testLinesContent(str, pieceTable);
assertTreeInvariants(pieceTable);
@@ -1577,7 +1577,7 @@ suite('random is unsupervised', () => {
testLinesContent(str, pieceTable);
}
assert.equal(pieceTable.getLinesRawContent(), str);
assert.strictEqual(pieceTable.getLinesRawContent(), str);
testLineStarts(str, pieceTable);
testLinesContent(str, pieceTable);
assertTreeInvariants(pieceTable);
@@ -1612,33 +1612,33 @@ suite('buffer api', () => {
test('getLineCharCode - issue #45735', () => {
let pieceTable = createTextBuffer(['LINE1\nline2']);
assert.equal(pieceTable.getLineCharCode(1, 0), 'L'.charCodeAt(0), 'L');
assert.equal(pieceTable.getLineCharCode(1, 1), 'I'.charCodeAt(0), 'I');
assert.equal(pieceTable.getLineCharCode(1, 2), 'N'.charCodeAt(0), 'N');
assert.equal(pieceTable.getLineCharCode(1, 3), 'E'.charCodeAt(0), 'E');
assert.equal(pieceTable.getLineCharCode(1, 4), '1'.charCodeAt(0), '1');
assert.equal(pieceTable.getLineCharCode(1, 5), '\n'.charCodeAt(0), '\\n');
assert.equal(pieceTable.getLineCharCode(2, 0), 'l'.charCodeAt(0), 'l');
assert.equal(pieceTable.getLineCharCode(2, 1), 'i'.charCodeAt(0), 'i');
assert.equal(pieceTable.getLineCharCode(2, 2), 'n'.charCodeAt(0), 'n');
assert.equal(pieceTable.getLineCharCode(2, 3), 'e'.charCodeAt(0), 'e');
assert.equal(pieceTable.getLineCharCode(2, 4), '2'.charCodeAt(0), '2');
assert.strictEqual(pieceTable.getLineCharCode(1, 0), 'L'.charCodeAt(0), 'L');
assert.strictEqual(pieceTable.getLineCharCode(1, 1), 'I'.charCodeAt(0), 'I');
assert.strictEqual(pieceTable.getLineCharCode(1, 2), 'N'.charCodeAt(0), 'N');
assert.strictEqual(pieceTable.getLineCharCode(1, 3), 'E'.charCodeAt(0), 'E');
assert.strictEqual(pieceTable.getLineCharCode(1, 4), '1'.charCodeAt(0), '1');
assert.strictEqual(pieceTable.getLineCharCode(1, 5), '\n'.charCodeAt(0), '\\n');
assert.strictEqual(pieceTable.getLineCharCode(2, 0), 'l'.charCodeAt(0), 'l');
assert.strictEqual(pieceTable.getLineCharCode(2, 1), 'i'.charCodeAt(0), 'i');
assert.strictEqual(pieceTable.getLineCharCode(2, 2), 'n'.charCodeAt(0), 'n');
assert.strictEqual(pieceTable.getLineCharCode(2, 3), 'e'.charCodeAt(0), 'e');
assert.strictEqual(pieceTable.getLineCharCode(2, 4), '2'.charCodeAt(0), '2');
});
test('getLineCharCode - issue #47733', () => {
let pieceTable = createTextBuffer(['', 'LINE1\n', 'line2']);
assert.equal(pieceTable.getLineCharCode(1, 0), 'L'.charCodeAt(0), 'L');
assert.equal(pieceTable.getLineCharCode(1, 1), 'I'.charCodeAt(0), 'I');
assert.equal(pieceTable.getLineCharCode(1, 2), 'N'.charCodeAt(0), 'N');
assert.equal(pieceTable.getLineCharCode(1, 3), 'E'.charCodeAt(0), 'E');
assert.equal(pieceTable.getLineCharCode(1, 4), '1'.charCodeAt(0), '1');
assert.equal(pieceTable.getLineCharCode(1, 5), '\n'.charCodeAt(0), '\\n');
assert.equal(pieceTable.getLineCharCode(2, 0), 'l'.charCodeAt(0), 'l');
assert.equal(pieceTable.getLineCharCode(2, 1), 'i'.charCodeAt(0), 'i');
assert.equal(pieceTable.getLineCharCode(2, 2), 'n'.charCodeAt(0), 'n');
assert.equal(pieceTable.getLineCharCode(2, 3), 'e'.charCodeAt(0), 'e');
assert.equal(pieceTable.getLineCharCode(2, 4), '2'.charCodeAt(0), '2');
assert.strictEqual(pieceTable.getLineCharCode(1, 0), 'L'.charCodeAt(0), 'L');
assert.strictEqual(pieceTable.getLineCharCode(1, 1), 'I'.charCodeAt(0), 'I');
assert.strictEqual(pieceTable.getLineCharCode(1, 2), 'N'.charCodeAt(0), 'N');
assert.strictEqual(pieceTable.getLineCharCode(1, 3), 'E'.charCodeAt(0), 'E');
assert.strictEqual(pieceTable.getLineCharCode(1, 4), '1'.charCodeAt(0), '1');
assert.strictEqual(pieceTable.getLineCharCode(1, 5), '\n'.charCodeAt(0), '\\n');
assert.strictEqual(pieceTable.getLineCharCode(2, 0), 'l'.charCodeAt(0), 'l');
assert.strictEqual(pieceTable.getLineCharCode(2, 1), 'i'.charCodeAt(0), 'i');
assert.strictEqual(pieceTable.getLineCharCode(2, 2), 'n'.charCodeAt(0), 'n');
assert.strictEqual(pieceTable.getLineCharCode(2, 3), 'e'.charCodeAt(0), 'e');
assert.strictEqual(pieceTable.getLineCharCode(2, 4), '2'.charCodeAt(0), '2');
});
});
@@ -1771,7 +1771,7 @@ suite('snapshot', () => {
]);
const snapshot = model.createSnapshot();
const snapshot1 = model.createSnapshot();
assert.equal(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
assert.strictEqual(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
model.applyEdits([
{
@@ -1786,7 +1786,7 @@ suite('snapshot', () => {
}
]);
assert.equal(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot1));
assert.strictEqual(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot1));
});
test('immutable snapshot 1', () => {
@@ -1806,7 +1806,7 @@ suite('snapshot', () => {
}
]);
assert.equal(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
assert.strictEqual(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
});
test('immutable snapshot 2', () => {
@@ -1826,7 +1826,7 @@ suite('snapshot', () => {
}
]);
assert.equal(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
assert.strictEqual(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
});
test('immutable snapshot 3', () => {
@@ -1845,7 +1845,7 @@ suite('snapshot', () => {
}
]);
assert.notEqual(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
assert.notStrictEqual(model.getLinesContent().join('\n'), getValueInSnapshot(snapshot));
});
});
@@ -1854,7 +1854,7 @@ suite('chunk based search', () => {
let pieceTree = createTextBuffer(['']);
pieceTree.delete(0, 1);
let ret = pieceTree.findMatchesLineByLine(new Range(1, 1, 1, 1), new SearchData(/abc/, new WordCharacterClassifier(',./'), 'abc'), true, 1000);
assert.equal(ret.length, 0);
assert.strictEqual(ret.length, 0);
});
test('#45770. FindInNode should not cross node boundary.', () => {
@@ -1873,11 +1873,11 @@ suite('chunk based search', () => {
pieceTree.insert(16, ' ');
let ret = pieceTree.findMatchesLineByLine(new Range(1, 1, 4, 13), new SearchData(/\[/gi, new WordCharacterClassifier(',./'), '['), true, 1000);
assert.equal(ret.length, 3);
assert.strictEqual(ret.length, 3);
assert.deepEqual(ret[0].range, new Range(2, 3, 2, 4));
assert.deepEqual(ret[1].range, new Range(3, 3, 3, 4));
assert.deepEqual(ret[2].range, new Range(4, 3, 4, 4));
assert.deepStrictEqual(ret[0].range, new Range(2, 3, 2, 4));
assert.deepStrictEqual(ret[1].range, new Range(3, 3, 3, 4));
assert.deepStrictEqual(ret[2].range, new Range(4, 3, 4, 4));
});
test('search searching from the middle', () => {
@@ -1889,12 +1889,12 @@ suite('chunk based search', () => {
]);
pieceTree.delete(4, 1);
let ret = pieceTree.findMatchesLineByLine(new Range(2, 3, 2, 6), new SearchData(/a/gi, null, 'a'), true, 1000);
assert.equal(ret.length, 1);
assert.deepEqual(ret[0].range, new Range(2, 3, 2, 4));
assert.strictEqual(ret.length, 1);
assert.deepStrictEqual(ret[0].range, new Range(2, 3, 2, 4));
pieceTree.delete(4, 1);
ret = pieceTree.findMatchesLineByLine(new Range(2, 2, 2, 5), new SearchData(/a/gi, null, 'a'), true, 1000);
assert.equal(ret.length, 1);
assert.deepEqual(ret[0].range, new Range(2, 2, 2, 3));
assert.strictEqual(ret.length, 1);
assert.deepStrictEqual(ret[0].range, new Range(2, 2, 2, 3));
});
});

4
src/vs/editor/test/common/model/textChange.test.ts
View File

@@ -75,7 +75,7 @@ suite('TextChangeCompressor', () => {
};
});
let actualDoResult = getResultingContent(initialText, compressedDoTextEdits);
assert.equal(actualDoResult, finalText);
assert.strictEqual(actualDoResult, finalText);
let compressedUndoTextEdits: IGeneratedEdit[] = compressedTextChanges.map((change) => {
return {
@@ -85,7 +85,7 @@ suite('TextChangeCompressor', () => {
};
});
let actualUndoResult = getResultingContent(finalText, compressedUndoTextEdits);
assert.equal(actualUndoResult, initialText);
assert.strictEqual(actualUndoResult, initialText);
}
test('simple 1', () => {

440
src/vs/editor/test/common/model/textModel.test.ts
View File

@@ -22,8 +22,8 @@ function testGuessIndentation(defaultInsertSpaces: boolean, defaultTabSize: numb
let r = m.getOptions();
m.dispose();
assert.equal(r.insertSpaces, expectedInsertSpaces, msg);
assert.equal(r.tabSize, expectedTabSize, msg);
assert.strictEqual(r.insertSpaces, expectedInsertSpaces, msg);
assert.strictEqual(r.tabSize, expectedTabSize, msg);
}
function assertGuess(expectedInsertSpaces: boolean | undefined, expectedTabSize: number | undefined | [number], text: string[], msg?: string): void {
@@ -75,14 +75,14 @@ suite('TextModelData.fromString', () => {
}
function testTextModelDataFromString(text: string, expected: ITextBufferData): void {
const textBuffer = createTextBuffer(text, TextModel.DEFAULT_CREATION_OPTIONS.defaultEOL);
const textBuffer = createTextBuffer(text, TextModel.DEFAULT_CREATION_OPTIONS.defaultEOL).textBuffer;
let actual: ITextBufferData = {
EOL: textBuffer.getEOL(),
lines: textBuffer.getLinesContent(),
containsRTL: textBuffer.mightContainRTL(),
isBasicASCII: !textBuffer.mightContainNonBasicASCII()
};
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
test('one line text', () => {
@@ -164,30 +164,30 @@ suite('Editor Model - TextModel', () => {
test('getValueLengthInRange', () => {
let m = createTextModel('My First Line\r\nMy Second Line\r\nMy Third Line');
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1, 1)), ''.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1, 2)), 'M'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 1, 3)), 'y'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1, 14)), 'My First Line'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 2, 1)), 'My First Line\r\n'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 2, 1)), 'y First Line\r\n'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 2, 2)), 'y First Line\r\nM'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 2, 1000)), 'y First Line\r\nMy Second Line'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 3, 1)), 'y First Line\r\nMy Second Line\r\n'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 3, 1000)), 'y First Line\r\nMy Second Line\r\nMy Third Line'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1000, 1000)), 'My First Line\r\nMy Second Line\r\nMy Third Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1, 1)), ''.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1, 2)), 'M'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 1, 3)), 'y'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1, 14)), 'My First Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 2, 1)), 'My First Line\r\n'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 2, 1)), 'y First Line\r\n'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 2, 2)), 'y First Line\r\nM'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 2, 1000)), 'y First Line\r\nMy Second Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 3, 1)), 'y First Line\r\nMy Second Line\r\n'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 3, 1000)), 'y First Line\r\nMy Second Line\r\nMy Third Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1000, 1000)), 'My First Line\r\nMy Second Line\r\nMy Third Line'.length);
m = createTextModel('My First Line\nMy Second Line\nMy Third Line');
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1, 1)), ''.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1, 2)), 'M'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 1, 3)), 'y'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1, 14)), 'My First Line'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 2, 1)), 'My First Line\n'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 2, 1)), 'y First Line\n'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 2, 2)), 'y First Line\nM'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 2, 1000)), 'y First Line\nMy Second Line'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 3, 1)), 'y First Line\nMy Second Line\n'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 2, 3, 1000)), 'y First Line\nMy Second Line\nMy Third Line'.length);
assert.equal(m.getValueLengthInRange(new Range(1, 1, 1000, 1000)), 'My First Line\nMy Second Line\nMy Third Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1, 1)), ''.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1, 2)), 'M'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 1, 3)), 'y'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1, 14)), 'My First Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 2, 1)), 'My First Line\n'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 2, 1)), 'y First Line\n'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 2, 2)), 'y First Line\nM'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 2, 1000)), 'y First Line\nMy Second Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 3, 1)), 'y First Line\nMy Second Line\n'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 2, 3, 1000)), 'y First Line\nMy Second Line\nMy Third Line'.length);
assert.strictEqual(m.getValueLengthInRange(new Range(1, 1, 1000, 1000)), 'My First Line\nMy Second Line\nMy Third Line'.length);
});
test('guess indentation 1', () => {
@@ -664,69 +664,69 @@ suite('Editor Model - TextModel', () => {
let m = createTextModel('line one\nline two');
assert.deepEqual(m.validatePosition(new Position(0, 0)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(0, 1)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(0, 0)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(0, 1)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(1, 1)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(1, 2)), new Position(1, 2));
assert.deepEqual(m.validatePosition(new Position(1, 30)), new Position(1, 9));
assert.deepStrictEqual(m.validatePosition(new Position(1, 1)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(1, 2)), new Position(1, 2));
assert.deepStrictEqual(m.validatePosition(new Position(1, 30)), new Position(1, 9));
assert.deepEqual(m.validatePosition(new Position(2, 0)), new Position(2, 1));
assert.deepEqual(m.validatePosition(new Position(2, 1)), new Position(2, 1));
assert.deepEqual(m.validatePosition(new Position(2, 2)), new Position(2, 2));
assert.deepEqual(m.validatePosition(new Position(2, 30)), new Position(2, 9));
assert.deepStrictEqual(m.validatePosition(new Position(2, 0)), new Position(2, 1));
assert.deepStrictEqual(m.validatePosition(new Position(2, 1)), new Position(2, 1));
assert.deepStrictEqual(m.validatePosition(new Position(2, 2)), new Position(2, 2));
assert.deepStrictEqual(m.validatePosition(new Position(2, 30)), new Position(2, 9));
assert.deepEqual(m.validatePosition(new Position(3, 0)), new Position(2, 9));
assert.deepEqual(m.validatePosition(new Position(3, 1)), new Position(2, 9));
assert.deepEqual(m.validatePosition(new Position(3, 30)), new Position(2, 9));
assert.deepStrictEqual(m.validatePosition(new Position(3, 0)), new Position(2, 9));
assert.deepStrictEqual(m.validatePosition(new Position(3, 1)), new Position(2, 9));
assert.deepStrictEqual(m.validatePosition(new Position(3, 30)), new Position(2, 9));
assert.deepEqual(m.validatePosition(new Position(30, 30)), new Position(2, 9));
assert.deepStrictEqual(m.validatePosition(new Position(30, 30)), new Position(2, 9));
assert.deepEqual(m.validatePosition(new Position(-123.123, -0.5)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(Number.MIN_VALUE, Number.MIN_VALUE)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(-123.123, -0.5)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(Number.MIN_VALUE, Number.MIN_VALUE)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(Number.MAX_VALUE, Number.MAX_VALUE)), new Position(2, 9));
assert.deepEqual(m.validatePosition(new Position(123.23, 47.5)), new Position(2, 9));
assert.deepStrictEqual(m.validatePosition(new Position(Number.MAX_VALUE, Number.MAX_VALUE)), new Position(2, 9));
assert.deepStrictEqual(m.validatePosition(new Position(123.23, 47.5)), new Position(2, 9));
});
test('validatePosition around high-low surrogate pairs 1', () => {
let m = createTextModel('a📚b');
assert.deepEqual(m.validatePosition(new Position(0, 0)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(0, 1)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(0, 7)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(0, 0)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(0, 1)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(0, 7)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(1, 1)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(1, 2)), new Position(1, 2));
assert.deepEqual(m.validatePosition(new Position(1, 3)), new Position(1, 2));
assert.deepEqual(m.validatePosition(new Position(1, 4)), new Position(1, 4));
assert.deepEqual(m.validatePosition(new Position(1, 5)), new Position(1, 5));
assert.deepEqual(m.validatePosition(new Position(1, 30)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(1, 1)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(1, 2)), new Position(1, 2));
assert.deepStrictEqual(m.validatePosition(new Position(1, 3)), new Position(1, 2));
assert.deepStrictEqual(m.validatePosition(new Position(1, 4)), new Position(1, 4));
assert.deepStrictEqual(m.validatePosition(new Position(1, 5)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(1, 30)), new Position(1, 5));
assert.deepEqual(m.validatePosition(new Position(2, 0)), new Position(1, 5));
assert.deepEqual(m.validatePosition(new Position(2, 1)), new Position(1, 5));
assert.deepEqual(m.validatePosition(new Position(2, 2)), new Position(1, 5));
assert.deepEqual(m.validatePosition(new Position(2, 30)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(2, 0)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(2, 1)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(2, 2)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(2, 30)), new Position(1, 5));
assert.deepEqual(m.validatePosition(new Position(-123.123, -0.5)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(Number.MIN_VALUE, Number.MIN_VALUE)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(-123.123, -0.5)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(Number.MIN_VALUE, Number.MIN_VALUE)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(Number.MAX_VALUE, Number.MAX_VALUE)), new Position(1, 5));
assert.deepEqual(m.validatePosition(new Position(123.23, 47.5)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(Number.MAX_VALUE, Number.MAX_VALUE)), new Position(1, 5));
assert.deepStrictEqual(m.validatePosition(new Position(123.23, 47.5)), new Position(1, 5));
});
test('validatePosition around high-low surrogate pairs 2', () => {
let m = createTextModel('a📚📚b');
assert.deepEqual(m.validatePosition(new Position(1, 1)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(1, 2)), new Position(1, 2));
assert.deepEqual(m.validatePosition(new Position(1, 3)), new Position(1, 2));
assert.deepEqual(m.validatePosition(new Position(1, 4)), new Position(1, 4));
assert.deepEqual(m.validatePosition(new Position(1, 5)), new Position(1, 4));
assert.deepEqual(m.validatePosition(new Position(1, 6)), new Position(1, 6));
assert.deepEqual(m.validatePosition(new Position(1, 7)), new Position(1, 7));
assert.deepStrictEqual(m.validatePosition(new Position(1, 1)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(1, 2)), new Position(1, 2));
assert.deepStrictEqual(m.validatePosition(new Position(1, 3)), new Position(1, 2));
assert.deepStrictEqual(m.validatePosition(new Position(1, 4)), new Position(1, 4));
assert.deepStrictEqual(m.validatePosition(new Position(1, 5)), new Position(1, 4));
assert.deepStrictEqual(m.validatePosition(new Position(1, 6)), new Position(1, 6));
assert.deepStrictEqual(m.validatePosition(new Position(1, 7)), new Position(1, 7));
});
@@ -734,133 +734,133 @@ suite('Editor Model - TextModel', () => {
let m = createTextModel('line one\nline two');
assert.deepEqual(m.validatePosition(new Position(NaN, 1)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(1, NaN)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(NaN, 1)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(1, NaN)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(NaN, NaN)), new Position(1, 1));
assert.deepEqual(m.validatePosition(new Position(2, NaN)), new Position(2, 1));
assert.deepEqual(m.validatePosition(new Position(NaN, 3)), new Position(1, 3));
assert.deepStrictEqual(m.validatePosition(new Position(NaN, NaN)), new Position(1, 1));
assert.deepStrictEqual(m.validatePosition(new Position(2, NaN)), new Position(2, 1));
assert.deepStrictEqual(m.validatePosition(new Position(NaN, 3)), new Position(1, 3));
});
test('issue #71480: validatePosition handle floats', () => {
let m = createTextModel('line one\nline two');
assert.deepEqual(m.validatePosition(new Position(0.2, 1)), new Position(1, 1), 'a');
assert.deepEqual(m.validatePosition(new Position(1.2, 1)), new Position(1, 1), 'b');
assert.deepEqual(m.validatePosition(new Position(1.5, 2)), new Position(1, 2), 'c');
assert.deepEqual(m.validatePosition(new Position(1.8, 3)), new Position(1, 3), 'd');
assert.deepEqual(m.validatePosition(new Position(1, 0.3)), new Position(1, 1), 'e');
assert.deepEqual(m.validatePosition(new Position(2, 0.8)), new Position(2, 1), 'f');
assert.deepEqual(m.validatePosition(new Position(1, 1.2)), new Position(1, 1), 'g');
assert.deepEqual(m.validatePosition(new Position(2, 1.5)), new Position(2, 1), 'h');
assert.deepStrictEqual(m.validatePosition(new Position(0.2, 1)), new Position(1, 1), 'a');
assert.deepStrictEqual(m.validatePosition(new Position(1.2, 1)), new Position(1, 1), 'b');
assert.deepStrictEqual(m.validatePosition(new Position(1.5, 2)), new Position(1, 2), 'c');
assert.deepStrictEqual(m.validatePosition(new Position(1.8, 3)), new Position(1, 3), 'd');
assert.deepStrictEqual(m.validatePosition(new Position(1, 0.3)), new Position(1, 1), 'e');
assert.deepStrictEqual(m.validatePosition(new Position(2, 0.8)), new Position(2, 1), 'f');
assert.deepStrictEqual(m.validatePosition(new Position(1, 1.2)), new Position(1, 1), 'g');
assert.deepStrictEqual(m.validatePosition(new Position(2, 1.5)), new Position(2, 1), 'h');
});
test('issue #71480: validateRange handle floats', () => {
let m = createTextModel('line one\nline two');
assert.deepEqual(m.validateRange(new Range(0.2, 1.5, 0.8, 2.5)), new Range(1, 1, 1, 1));
assert.deepEqual(m.validateRange(new Range(1.2, 1.7, 1.8, 2.2)), new Range(1, 1, 1, 2));
assert.deepStrictEqual(m.validateRange(new Range(0.2, 1.5, 0.8, 2.5)), new Range(1, 1, 1, 1));
assert.deepStrictEqual(m.validateRange(new Range(1.2, 1.7, 1.8, 2.2)), new Range(1, 1, 1, 2));
});
test('validateRange around high-low surrogate pairs 1', () => {
let m = createTextModel('a📚b');
assert.deepEqual(m.validateRange(new Range(0, 0, 0, 1)), new Range(1, 1, 1, 1));
assert.deepEqual(m.validateRange(new Range(0, 0, 0, 7)), new Range(1, 1, 1, 1));
assert.deepStrictEqual(m.validateRange(new Range(0, 0, 0, 1)), new Range(1, 1, 1, 1));
assert.deepStrictEqual(m.validateRange(new Range(0, 0, 0, 7)), new Range(1, 1, 1, 1));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 1)), new Range(1, 1, 1, 1));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 2)), new Range(1, 1, 1, 2));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 3)), new Range(1, 1, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 4)), new Range(1, 1, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 5)), new Range(1, 1, 1, 5));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 1)), new Range(1, 1, 1, 1));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 2)), new Range(1, 1, 1, 2));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 3)), new Range(1, 1, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 4)), new Range(1, 1, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 5)), new Range(1, 1, 1, 5));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 2)), new Range(1, 2, 1, 2));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 3)), new Range(1, 2, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 4)), new Range(1, 2, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 5)), new Range(1, 2, 1, 5));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 2)), new Range(1, 2, 1, 2));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 3)), new Range(1, 2, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 4)), new Range(1, 2, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 5)), new Range(1, 2, 1, 5));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 3)), new Range(1, 2, 1, 2));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 4)), new Range(1, 2, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 5)), new Range(1, 2, 1, 5));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 3)), new Range(1, 2, 1, 2));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 4)), new Range(1, 2, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 5)), new Range(1, 2, 1, 5));
assert.deepEqual(m.validateRange(new Range(1, 4, 1, 4)), new Range(1, 4, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 4, 1, 5)), new Range(1, 4, 1, 5));
assert.deepStrictEqual(m.validateRange(new Range(1, 4, 1, 4)), new Range(1, 4, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 4, 1, 5)), new Range(1, 4, 1, 5));
assert.deepEqual(m.validateRange(new Range(1, 5, 1, 5)), new Range(1, 5, 1, 5));
assert.deepStrictEqual(m.validateRange(new Range(1, 5, 1, 5)), new Range(1, 5, 1, 5));
});
test('validateRange around high-low surrogate pairs 2', () => {
let m = createTextModel('a📚📚b');
assert.deepEqual(m.validateRange(new Range(0, 0, 0, 1)), new Range(1, 1, 1, 1));
assert.deepEqual(m.validateRange(new Range(0, 0, 0, 7)), new Range(1, 1, 1, 1));
assert.deepStrictEqual(m.validateRange(new Range(0, 0, 0, 1)), new Range(1, 1, 1, 1));
assert.deepStrictEqual(m.validateRange(new Range(0, 0, 0, 7)), new Range(1, 1, 1, 1));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 1)), new Range(1, 1, 1, 1));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 2)), new Range(1, 1, 1, 2));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 3)), new Range(1, 1, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 4)), new Range(1, 1, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 5)), new Range(1, 1, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 6)), new Range(1, 1, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 1, 1, 7)), new Range(1, 1, 1, 7));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 1)), new Range(1, 1, 1, 1));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 2)), new Range(1, 1, 1, 2));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 3)), new Range(1, 1, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 4)), new Range(1, 1, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 5)), new Range(1, 1, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 6)), new Range(1, 1, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 1, 1, 7)), new Range(1, 1, 1, 7));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 2)), new Range(1, 2, 1, 2));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 3)), new Range(1, 2, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 4)), new Range(1, 2, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 5)), new Range(1, 2, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 6)), new Range(1, 2, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 2, 1, 7)), new Range(1, 2, 1, 7));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 2)), new Range(1, 2, 1, 2));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 3)), new Range(1, 2, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 4)), new Range(1, 2, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 5)), new Range(1, 2, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 6)), new Range(1, 2, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 2, 1, 7)), new Range(1, 2, 1, 7));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 3)), new Range(1, 2, 1, 2));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 4)), new Range(1, 2, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 5)), new Range(1, 2, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 6)), new Range(1, 2, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 3, 1, 7)), new Range(1, 2, 1, 7));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 3)), new Range(1, 2, 1, 2));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 4)), new Range(1, 2, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 5)), new Range(1, 2, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 6)), new Range(1, 2, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 3, 1, 7)), new Range(1, 2, 1, 7));
assert.deepEqual(m.validateRange(new Range(1, 4, 1, 4)), new Range(1, 4, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 4, 1, 5)), new Range(1, 4, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 4, 1, 6)), new Range(1, 4, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 4, 1, 7)), new Range(1, 4, 1, 7));
assert.deepStrictEqual(m.validateRange(new Range(1, 4, 1, 4)), new Range(1, 4, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 4, 1, 5)), new Range(1, 4, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 4, 1, 6)), new Range(1, 4, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 4, 1, 7)), new Range(1, 4, 1, 7));
assert.deepEqual(m.validateRange(new Range(1, 5, 1, 5)), new Range(1, 4, 1, 4));
assert.deepEqual(m.validateRange(new Range(1, 5, 1, 6)), new Range(1, 4, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 5, 1, 7)), new Range(1, 4, 1, 7));
assert.deepStrictEqual(m.validateRange(new Range(1, 5, 1, 5)), new Range(1, 4, 1, 4));
assert.deepStrictEqual(m.validateRange(new Range(1, 5, 1, 6)), new Range(1, 4, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 5, 1, 7)), new Range(1, 4, 1, 7));
assert.deepEqual(m.validateRange(new Range(1, 6, 1, 6)), new Range(1, 6, 1, 6));
assert.deepEqual(m.validateRange(new Range(1, 6, 1, 7)), new Range(1, 6, 1, 7));
assert.deepStrictEqual(m.validateRange(new Range(1, 6, 1, 6)), new Range(1, 6, 1, 6));
assert.deepStrictEqual(m.validateRange(new Range(1, 6, 1, 7)), new Range(1, 6, 1, 7));
assert.deepEqual(m.validateRange(new Range(1, 7, 1, 7)), new Range(1, 7, 1, 7));
assert.deepStrictEqual(m.validateRange(new Range(1, 7, 1, 7)), new Range(1, 7, 1, 7));
});
test('modifyPosition', () => {
let m = createTextModel('line one\nline two');
assert.deepEqual(m.modifyPosition(new Position(1, 1), 0), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(0, 0), 0), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(30, 1), 0), new Position(2, 9));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 1), 0), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(0, 0), 0), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(30, 1), 0), new Position(2, 9));
assert.deepEqual(m.modifyPosition(new Position(1, 1), 17), new Position(2, 9));
assert.deepEqual(m.modifyPosition(new Position(1, 1), 1), new Position(1, 2));
assert.deepEqual(m.modifyPosition(new Position(1, 1), 3), new Position(1, 4));
assert.deepEqual(m.modifyPosition(new Position(1, 2), 10), new Position(2, 3));
assert.deepEqual(m.modifyPosition(new Position(1, 5), 13), new Position(2, 9));
assert.deepEqual(m.modifyPosition(new Position(1, 2), 16), new Position(2, 9));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 1), 17), new Position(2, 9));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 1), 1), new Position(1, 2));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 1), 3), new Position(1, 4));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 2), 10), new Position(2, 3));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 5), 13), new Position(2, 9));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 2), 16), new Position(2, 9));
assert.deepEqual(m.modifyPosition(new Position(2, 9), -17), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(1, 2), -1), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(1, 4), -3), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(2, 3), -10), new Position(1, 2));
assert.deepEqual(m.modifyPosition(new Position(2, 9), -13), new Position(1, 5));
assert.deepEqual(m.modifyPosition(new Position(2, 9), -16), new Position(1, 2));
assert.deepStrictEqual(m.modifyPosition(new Position(2, 9), -17), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 2), -1), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 4), -3), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(2, 3), -10), new Position(1, 2));
assert.deepStrictEqual(m.modifyPosition(new Position(2, 9), -13), new Position(1, 5));
assert.deepStrictEqual(m.modifyPosition(new Position(2, 9), -16), new Position(1, 2));
assert.deepEqual(m.modifyPosition(new Position(1, 2), 17), new Position(2, 9));
assert.deepEqual(m.modifyPosition(new Position(1, 2), 100), new Position(2, 9));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 2), 17), new Position(2, 9));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 2), 100), new Position(2, 9));
assert.deepEqual(m.modifyPosition(new Position(1, 2), -2), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(1, 2), -100), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(2, 2), -100), new Position(1, 1));
assert.deepEqual(m.modifyPosition(new Position(2, 9), -18), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 2), -2), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(1, 2), -100), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(2, 2), -100), new Position(1, 1));
assert.deepStrictEqual(m.modifyPosition(new Position(2, 9), -18), new Position(1, 1));
});
test('normalizeIndentation 1', () => {
@@ -870,27 +870,27 @@ suite('Editor Model - TextModel', () => {
}
);
assert.equal(model.normalizeIndentation('\t'), '\t');
assert.equal(model.normalizeIndentation(' '), '\t');
assert.equal(model.normalizeIndentation(' '), ' ');
assert.equal(model.normalizeIndentation(' '), ' ');
assert.equal(model.normalizeIndentation(' '), ' ');
assert.equal(model.normalizeIndentation(''), '');
assert.equal(model.normalizeIndentation(' \t '), '\t\t');
assert.equal(model.normalizeIndentation(' \t '), '\t ');
assert.equal(model.normalizeIndentation(' \t '), '\t ');
assert.equal(model.normalizeIndentation(' \t'), '\t ');
assert.strictEqual(model.normalizeIndentation('\t'), '\t');
assert.strictEqual(model.normalizeIndentation(' '), '\t');
assert.strictEqual(model.normalizeIndentation(' '), ' ');
assert.strictEqual(model.normalizeIndentation(' '), ' ');
assert.strictEqual(model.normalizeIndentation(' '), ' ');
assert.strictEqual(model.normalizeIndentation(''), '');
assert.strictEqual(model.normalizeIndentation(' \t '), '\t\t');
assert.strictEqual(model.normalizeIndentation(' \t '), '\t ');
assert.strictEqual(model.normalizeIndentation(' \t '), '\t ');
assert.strictEqual(model.normalizeIndentation(' \t'), '\t ');
assert.equal(model.normalizeIndentation('\ta'), '\ta');
assert.equal(model.normalizeIndentation(' a'), '\ta');
assert.equal(model.normalizeIndentation(' a'), ' a');
assert.equal(model.normalizeIndentation(' a'), ' a');
assert.equal(model.normalizeIndentation(' a'), ' a');
assert.equal(model.normalizeIndentation('a'), 'a');
assert.equal(model.normalizeIndentation(' \t a'), '\t\ta');
assert.equal(model.normalizeIndentation(' \t a'), '\t a');
assert.equal(model.normalizeIndentation(' \t a'), '\t a');
assert.equal(model.normalizeIndentation(' \ta'), '\t a');
assert.strictEqual(model.normalizeIndentation('\ta'), '\ta');
assert.strictEqual(model.normalizeIndentation(' a'), '\ta');
assert.strictEqual(model.normalizeIndentation(' a'), ' a');
assert.strictEqual(model.normalizeIndentation(' a'), ' a');
assert.strictEqual(model.normalizeIndentation(' a'), ' a');
assert.strictEqual(model.normalizeIndentation('a'), 'a');
assert.strictEqual(model.normalizeIndentation(' \t a'), '\t\ta');
assert.strictEqual(model.normalizeIndentation(' \t a'), '\t a');
assert.strictEqual(model.normalizeIndentation(' \t a'), '\t a');
assert.strictEqual(model.normalizeIndentation(' \ta'), '\t a');
model.dispose();
});
@@ -898,16 +898,16 @@ suite('Editor Model - TextModel', () => {
test('normalizeIndentation 2', () => {
let model = createTextModel('');
assert.equal(model.normalizeIndentation('\ta'), ' a');
assert.equal(model.normalizeIndentation(' a'), ' a');
assert.equal(model.normalizeIndentation(' a'), ' a');
assert.equal(model.normalizeIndentation(' a'), ' a');
assert.equal(model.normalizeIndentation(' a'), ' a');
assert.equal(model.normalizeIndentation('a'), 'a');
assert.equal(model.normalizeIndentation(' \t a'), ' a');
assert.equal(model.normalizeIndentation(' \t a'), ' a');
assert.equal(model.normalizeIndentation(' \t a'), ' a');
assert.equal(model.normalizeIndentation(' \ta'), ' a');
assert.strictEqual(model.normalizeIndentation('\ta'), ' a');
assert.strictEqual(model.normalizeIndentation(' a'), ' a');
assert.strictEqual(model.normalizeIndentation(' a'), ' a');
assert.strictEqual(model.normalizeIndentation(' a'), ' a');
assert.strictEqual(model.normalizeIndentation(' a'), ' a');
assert.strictEqual(model.normalizeIndentation('a'), 'a');
assert.strictEqual(model.normalizeIndentation(' \t a'), ' a');
assert.strictEqual(model.normalizeIndentation(' \t a'), ' a');
assert.strictEqual(model.normalizeIndentation(' \t a'), ' a');
assert.strictEqual(model.normalizeIndentation(' \ta'), ' a');
model.dispose();
});
@@ -928,18 +928,18 @@ suite('Editor Model - TextModel', () => {
''
].join('\n'));
assert.equal(model.getLineFirstNonWhitespaceColumn(1), 1, '1');
assert.equal(model.getLineFirstNonWhitespaceColumn(2), 2, '2');
assert.equal(model.getLineFirstNonWhitespaceColumn(3), 2, '3');
assert.equal(model.getLineFirstNonWhitespaceColumn(4), 3, '4');
assert.equal(model.getLineFirstNonWhitespaceColumn(5), 3, '5');
assert.equal(model.getLineFirstNonWhitespaceColumn(6), 0, '6');
assert.equal(model.getLineFirstNonWhitespaceColumn(7), 0, '7');
assert.equal(model.getLineFirstNonWhitespaceColumn(8), 0, '8');
assert.equal(model.getLineFirstNonWhitespaceColumn(9), 0, '9');
assert.equal(model.getLineFirstNonWhitespaceColumn(10), 4, '10');
assert.equal(model.getLineFirstNonWhitespaceColumn(11), 0, '11');
assert.equal(model.getLineFirstNonWhitespaceColumn(12), 0, '12');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(1), 1, '1');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(2), 2, '2');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(3), 2, '3');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(4), 3, '4');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(5), 3, '5');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(6), 0, '6');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(7), 0, '7');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(8), 0, '8');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(9), 0, '9');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(10), 4, '10');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(11), 0, '11');
assert.strictEqual(model.getLineFirstNonWhitespaceColumn(12), 0, '12');
});
test('getLineLastNonWhitespaceColumn', () => {
@@ -958,24 +958,24 @@ suite('Editor Model - TextModel', () => {
''
].join('\n'));
assert.equal(model.getLineLastNonWhitespaceColumn(1), 4, '1');
assert.equal(model.getLineLastNonWhitespaceColumn(2), 4, '2');
assert.equal(model.getLineLastNonWhitespaceColumn(3), 4, '3');
assert.equal(model.getLineLastNonWhitespaceColumn(4), 4, '4');
assert.equal(model.getLineLastNonWhitespaceColumn(5), 4, '5');
assert.equal(model.getLineLastNonWhitespaceColumn(6), 0, '6');
assert.equal(model.getLineLastNonWhitespaceColumn(7), 0, '7');
assert.equal(model.getLineLastNonWhitespaceColumn(8), 0, '8');
assert.equal(model.getLineLastNonWhitespaceColumn(9), 0, '9');
assert.equal(model.getLineLastNonWhitespaceColumn(10), 4, '10');
assert.equal(model.getLineLastNonWhitespaceColumn(11), 0, '11');
assert.equal(model.getLineLastNonWhitespaceColumn(12), 0, '12');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(1), 4, '1');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(2), 4, '2');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(3), 4, '3');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(4), 4, '4');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(5), 4, '5');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(6), 0, '6');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(7), 0, '7');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(8), 0, '8');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(9), 0, '9');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(10), 4, '10');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(11), 0, '11');
assert.strictEqual(model.getLineLastNonWhitespaceColumn(12), 0, '12');
});
test('#50471. getValueInRange with invalid range', () => {
let m = createTextModel('My First Line\r\nMy Second Line\r\nMy Third Line');
assert.equal(m.getValueInRange(new Range(1, NaN, 1, 3)), 'My');
assert.equal(m.getValueInRange(new Range(NaN, NaN, NaN, NaN)), '');
assert.strictEqual(m.getValueInRange(new Range(1, NaN, 1, 3)), 'My');
assert.strictEqual(m.getValueInRange(new Range(NaN, NaN, NaN, NaN)), '');
});
});
@@ -983,26 +983,26 @@ suite('TextModel.mightContainRTL', () => {
test('nope', () => {
let model = createTextModel('hello world!');
assert.equal(model.mightContainRTL(), false);
assert.strictEqual(model.mightContainRTL(), false);
});
test('yes', () => {
let model = createTextModel('Hello,\nזוהי עובדה מבוססת שדעתו');
assert.equal(model.mightContainRTL(), true);
assert.strictEqual(model.mightContainRTL(), true);
});
test('setValue resets 1', () => {
let model = createTextModel('hello world!');
assert.equal(model.mightContainRTL(), false);
assert.strictEqual(model.mightContainRTL(), false);
model.setValue('Hello,\nזוהי עובדה מבוססת שדעתו');
assert.equal(model.mightContainRTL(), true);
assert.strictEqual(model.mightContainRTL(), true);
});
test('setValue resets 2', () => {
let model = createTextModel('Hello,\nهناك حقيقة مثبتة منذ زمن طويل');
assert.equal(model.mightContainRTL(), true);
assert.strictEqual(model.mightContainRTL(), true);
model.setValue('hello world!');
assert.equal(model.mightContainRTL(), false);
assert.strictEqual(model.mightContainRTL(), false);
});
});
@@ -1012,24 +1012,24 @@ suite('TextModel.createSnapshot', () => {
test('empty file', () => {
let model = createTextModel('');
let snapshot = model.createSnapshot();
assert.equal(snapshot.read(), null);
assert.strictEqual(snapshot.read(), null);
model.dispose();
});
test('file with BOM', () => {
let model = createTextModel(UTF8_BOM_CHARACTER + 'Hello');
assert.equal(model.getLineContent(1), 'Hello');
assert.strictEqual(model.getLineContent(1), 'Hello');
let snapshot = model.createSnapshot(true);
assert.equal(snapshot.read(), UTF8_BOM_CHARACTER + 'Hello');
assert.equal(snapshot.read(), null);
assert.strictEqual(snapshot.read(), UTF8_BOM_CHARACTER + 'Hello');
assert.strictEqual(snapshot.read(), null);
model.dispose();
});
test('regular file', () => {
let model = createTextModel('My First Line\n\t\tMy Second Line\n Third Line\n\n1');
let snapshot = model.createSnapshot();
assert.equal(snapshot.read(), 'My First Line\n\t\tMy Second Line\n Third Line\n\n1');
assert.equal(snapshot.read(), null);
assert.strictEqual(snapshot.read(), 'My First Line\n\t\tMy Second Line\n Third Line\n\n1');
assert.strictEqual(snapshot.read(), null);
model.dispose();
});
@@ -1054,10 +1054,10 @@ suite('TextModel.createSnapshot', () => {
// all good
} else {
actual += tmp2;
assert.equal(snapshot.read(), null);
assert.strictEqual(snapshot.read(), null);
}
assert.equal(actual, text);
assert.strictEqual(actual, text);
model.dispose();
});

30
src/vs/editor/test/common/model/textModelSearch.test.ts
View File

@@ -19,31 +19,31 @@ suite('TextModelSearch', () => {
const usualWordSeparators = getMapForWordSeparators(USUAL_WORD_SEPARATORS);
function assertFindMatch(actual: FindMatch | null, expectedRange: Range, expectedMatches: string[] | null = null): void {
assert.deepEqual(actual, new FindMatch(expectedRange, expectedMatches));
assert.deepStrictEqual(actual, new FindMatch(expectedRange, expectedMatches));
}
function _assertFindMatches(model: TextModel, searchParams: SearchParams, expectedMatches: FindMatch[]): void {
let actual = TextModelSearch.findMatches(model, searchParams, model.getFullModelRange(), false, 1000);
assert.deepEqual(actual, expectedMatches, 'findMatches OK');
assert.deepStrictEqual(actual, expectedMatches, 'findMatches OK');
// test `findNextMatch`
let startPos = new Position(1, 1);
let match = TextModelSearch.findNextMatch(model, searchParams, startPos, false);
assert.deepEqual(match, expectedMatches[0], `findNextMatch ${startPos}`);
assert.deepStrictEqual(match, expectedMatches[0], `findNextMatch ${startPos}`);
for (const expectedMatch of expectedMatches) {
startPos = expectedMatch.range.getStartPosition();
match = TextModelSearch.findNextMatch(model, searchParams, startPos, false);
assert.deepEqual(match, expectedMatch, `findNextMatch ${startPos}`);
assert.deepStrictEqual(match, expectedMatch, `findNextMatch ${startPos}`);
}
// test `findPrevMatch`
startPos = new Position(model.getLineCount(), model.getLineMaxColumn(model.getLineCount()));
match = TextModelSearch.findPreviousMatch(model, searchParams, startPos, false);
assert.deepEqual(match, expectedMatches[expectedMatches.length - 1], `findPrevMatch ${startPos}`);
assert.deepStrictEqual(match, expectedMatches[expectedMatches.length - 1], `findPrevMatch ${startPos}`);
for (const expectedMatch of expectedMatches) {
startPos = expectedMatch.range.getEndPosition();
match = TextModelSearch.findPreviousMatch(model, searchParams, startPos, false);
assert.deepEqual(match, expectedMatch, `findPrevMatch ${startPos}`);
assert.deepStrictEqual(match, expectedMatch, `findPrevMatch ${startPos}`);
}
}
@@ -486,7 +486,7 @@ suite('TextModelSearch', () => {
let searchParams = new SearchParams('(l(in)e)', true, false, null);
let actual = TextModelSearch.findMatches(model, searchParams, model.getFullModelRange(), true, 100);
assert.deepEqual(actual, [
assert.deepStrictEqual(actual, [
new FindMatch(new Range(1, 5, 1, 9), ['line', 'line', 'in']),
new FindMatch(new Range(1, 10, 1, 14), ['line', 'line', 'in']),
new FindMatch(new Range(2, 5, 2, 9), ['line', 'line', 'in']),
@@ -501,7 +501,7 @@ suite('TextModelSearch', () => {
let searchParams = new SearchParams('(l(in)e)\\n', true, false, null);
let actual = TextModelSearch.findMatches(model, searchParams, model.getFullModelRange(), true, 100);
assert.deepEqual(actual, [
assert.deepStrictEqual(actual, [
new FindMatch(new Range(1, 10, 2, 1), ['line\n', 'line', 'in']),
new FindMatch(new Range(2, 5, 3, 1), ['line\n', 'line', 'in']),
]);
@@ -556,7 +556,7 @@ suite('TextModelSearch', () => {
test('\\n matches \\r\\n', () => {
let model = createTextModel('a\r\nb\r\nc\r\nd\r\ne\r\nf\r\ng\r\nh\r\ni');
assert.equal(model.getEOL(), '\r\n');
assert.strictEqual(model.getEOL(), '\r\n');
let searchParams = new SearchParams('h\\n', true, false, null);
let actual = TextModelSearch.findNextMatch(model, searchParams, new Position(1, 1), true);
@@ -579,12 +579,12 @@ suite('TextModelSearch', () => {
test('\\r can never be found', () => {
let model = createTextModel('a\r\nb\r\nc\r\nd\r\ne\r\nf\r\ng\r\nh\r\ni');
assert.equal(model.getEOL(), '\r\n');
assert.strictEqual(model.getEOL(), '\r\n');
let searchParams = new SearchParams('\\r\\n', true, false, null);
let actual = TextModelSearch.findNextMatch(model, searchParams, new Position(1, 1), true);
assert.equal(actual, null);
assert.deepEqual(TextModelSearch.findMatches(model, searchParams, model.getFullModelRange(), true, 1000), []);
assert.strictEqual(actual, null);
assert.deepStrictEqual(TextModelSearch.findMatches(model, searchParams, model.getFullModelRange(), true, 1000), []);
model.dispose();
});
@@ -596,8 +596,8 @@ suite('TextModelSearch', () => {
if (expected === null) {
assert.ok(actual === null);
} else {
assert.deepEqual(actual!.regex, expected.regex);
assert.deepEqual(actual!.simpleSearch, expected.simpleSearch);
assert.deepStrictEqual(actual!.regex, expected.regex);
assert.deepStrictEqual(actual!.simpleSearch, expected.simpleSearch);
if (wordSeparators) {
assert.ok(actual!.wordSeparators !== null);
} else {
@@ -769,7 +769,7 @@ suite('TextModelSearch', () => {
let searchParams = new SearchParams('\\d*', true, false, null);
let actual = TextModelSearch.findMatches(model, searchParams, model.getFullModelRange(), true, 100);
assert.deepEqual(actual, [
assert.deepStrictEqual(actual, [
new FindMatch(new Range(1, 1, 1, 3), ['10']),
new FindMatch(new Range(1, 3, 1, 3), ['']),
new FindMatch(new Range(1, 4, 1, 7), ['243']),

30
src/vs/editor/test/common/model/textModelWithTokens.test.ts
View File

@@ -100,7 +100,7 @@ suite('TextModelWithTokens', () => {
column: column
});
assert.deepEqual(toRelaxedFoundBracket(actual), toRelaxedFoundBracket(currentExpectedBracket), 'findPrevBracket of ' + lineNumber + ', ' + column);
assert.deepStrictEqual(toRelaxedFoundBracket(actual), toRelaxedFoundBracket(currentExpectedBracket), 'findPrevBracket of ' + lineNumber + ', ' + column);
}
}
}
@@ -126,7 +126,7 @@ suite('TextModelWithTokens', () => {
column: column
});
assert.deepEqual(toRelaxedFoundBracket(actual), toRelaxedFoundBracket(currentExpectedBracket), 'findNextBracket of ' + lineNumber + ', ' + column);
assert.deepStrictEqual(toRelaxedFoundBracket(actual), toRelaxedFoundBracket(currentExpectedBracket), 'findNextBracket of ' + lineNumber + ', ' + column);
}
}
}
@@ -148,12 +148,12 @@ suite('TextModelWithTokens', () => {
function assertIsNotBracket(model: TextModel, lineNumber: number, column: number) {
const match = model.matchBracket(new Position(lineNumber, column));
assert.equal(match, null, 'is not matching brackets at ' + lineNumber + ', ' + column);
assert.strictEqual(match, null, 'is not matching brackets at ' + lineNumber + ', ' + column);
}
function assertIsBracket(model: TextModel, testPosition: Position, expected: [Range, Range]): void {
const actual = model.matchBracket(testPosition);
assert.deepEqual(actual, expected, 'matches brackets at ' + testPosition);
assert.deepStrictEqual(actual, expected, 'matches brackets at ' + testPosition);
}
suite('TextModelWithTokens - bracket matching', () => {
@@ -351,7 +351,7 @@ suite('TextModelWithTokens', () => {
const tokenizationSupport: ITokenizationSupport = {
getInitialState: () => NULL_STATE,
tokenize: undefined!,
tokenize2: (line, state) => {
tokenize2: (line, hasEOL, state) => {
switch (line) {
case 'function hello() {': {
const tokens = new Uint32Array([
@@ -399,8 +399,8 @@ suite('TextModelWithTokens', () => {
model.forceTokenization(2);
model.forceTokenization(3);
assert.deepEqual(model.matchBracket(new Position(2, 23)), null);
assert.deepEqual(model.matchBracket(new Position(2, 20)), null);
assert.deepStrictEqual(model.matchBracket(new Position(2, 23)), null);
assert.deepStrictEqual(model.matchBracket(new Position(2, 20)), null);
model.dispose();
registration1.dispose();
@@ -434,7 +434,7 @@ suite('TextModelWithTokens regression tests', () => {
foreground: token.getForeground()
};
};
assert.deepEqual(actual, expected.map(decode));
assert.deepStrictEqual(actual, expected.map(decode));
}
let _tokenId = 10;
@@ -446,7 +446,7 @@ suite('TextModelWithTokens regression tests', () => {
const tokenizationSupport: ITokenizationSupport = {
getInitialState: () => NULL_STATE,
tokenize: undefined!,
tokenize2: (line, state) => {
tokenize2: (line, hasEOL, state) => {
let myId = ++_tokenId;
let tokens = new Uint32Array(2);
tokens[0] = 0;
@@ -512,7 +512,7 @@ suite('TextModelWithTokens regression tests', () => {
].join('\n'), undefined, languageIdentifier);
let actual = model.matchBracket(new Position(4, 1));
assert.deepEqual(actual, [new Range(4, 1, 4, 7), new Range(9, 1, 9, 11)]);
assert.deepStrictEqual(actual, [new Range(4, 1, 4, 7), new Range(9, 1, 9, 11)]);
model.dispose();
registration.dispose();
@@ -537,7 +537,7 @@ suite('TextModelWithTokens regression tests', () => {
].join('\n'), undefined, languageIdentifier);
let actual = model.matchBracket(new Position(3, 9));
assert.deepEqual(actual, [new Range(3, 6, 3, 17), new Range(2, 6, 2, 14)]);
assert.deepStrictEqual(actual, [new Range(3, 6, 3, 17), new Range(2, 6, 2, 14)]);
model.dispose();
registration.dispose();
@@ -550,7 +550,7 @@ suite('TextModelWithTokens regression tests', () => {
const tokenizationSupport: ITokenizationSupport = {
getInitialState: () => NULL_STATE,
tokenize: undefined!,
tokenize2: (line, state) => {
tokenize2: (line, hasEOL, state) => {
let tokens = new Uint32Array(2);
tokens[0] = 0;
tokens[1] = (
@@ -565,7 +565,7 @@ suite('TextModelWithTokens regression tests', () => {
let model = createTextModel('A model with one line', undefined, outerMode);
model.forceTokenization(1);
assert.equal(model.getLanguageIdAtPosition(1, 1), innerMode.id);
assert.strictEqual(model.getLanguageIdAtPosition(1, 1), innerMode.id);
model.dispose();
registration.dispose();
@@ -586,7 +586,7 @@ suite('TextModel.getLineIndentGuide', () => {
actual[line - 1] = [actualIndents[line - 1], activeIndentGuide.startLineNumber, activeIndentGuide.endLineNumber, activeIndentGuide.indent, model.getLineContent(line)];
}
assert.deepEqual(actual, lines);
assert.deepStrictEqual(actual, lines);
model.dispose();
}
@@ -764,7 +764,7 @@ suite('TextModel.getLineIndentGuide', () => {
].join('\n'));
const actual = model.getActiveIndentGuide(2, 4, 9);
assert.deepEqual(actual, { startLineNumber: 2, endLineNumber: 9, indent: 1 });
assert.deepStrictEqual(actual, { startLineNumber: 2, endLineNumber: 9, indent: 1 });
model.dispose();
});

16
src/vs/editor/test/common/model/tokensStore.test.ts
View File

@@ -104,7 +104,7 @@ suite('TokensStore', () => {
model.applyEdits(edits);
const actualState = extractState(model);
assert.deepEqual(actualState, rawFinalState);
assert.deepStrictEqual(actualState, rawFinalState);
model.dispose();
}
@@ -191,7 +191,7 @@ suite('TokensStore', () => {
decodedTokens.push(lineTokens.getEndOffset(i), lineTokens.getMetadata(i));
}
assert.deepEqual(decodedTokens, [
assert.deepStrictEqual(decodedTokens, [
20, 16793600,
24, 17022976,
25, 16793600,
@@ -252,7 +252,7 @@ suite('TokensStore', () => {
]);
const lineTokens = store.addSemanticTokens(10, new LineTokens(new Uint32Array([12, 1]), `enum Enum1 {`));
assert.equal(lineTokens.getCount(), 3);
assert.strictEqual(lineTokens.getCount(), 3);
});
test('partial tokens 2', () => {
@@ -293,7 +293,7 @@ suite('TokensStore', () => {
]);
const lineTokens = store.addSemanticTokens(20, new LineTokens(new Uint32Array([12, 1]), `enum Enum1 {`));
assert.equal(lineTokens.getCount(), 3);
assert.strictEqual(lineTokens.getCount(), 3);
});
test('partial tokens 3', () => {
@@ -320,7 +320,7 @@ suite('TokensStore', () => {
]);
const lineTokens = store.addSemanticTokens(5, new LineTokens(new Uint32Array([12, 1]), `enum Enum1 {`));
assert.equal(lineTokens.getCount(), 3);
assert.strictEqual(lineTokens.getCount(), 3);
});
test('issue #94133: Semantic colors stick around when using (only) range provider', () => {
@@ -337,7 +337,7 @@ suite('TokensStore', () => {
store.setPartial(new Range(1, 1, 1, 20), []);
const lineTokens = store.addSemanticTokens(1, new LineTokens(new Uint32Array([12, 1]), `enum Enum1 {`));
assert.equal(lineTokens.getCount(), 1);
assert.strictEqual(lineTokens.getCount(), 1);
});
test('bug', () => {
@@ -385,7 +385,7 @@ suite('TokensStore', () => {
);
const lineTokens = store.addSemanticTokens(36451, new LineTokens(new Uint32Array([60, 1]), ` if (flags & ModifierFlags.Ambient) {`));
assert.equal(lineTokens.getCount(), 7);
assert.strictEqual(lineTokens.getCount(), 7);
});
@@ -424,7 +424,7 @@ suite('TokensStore', () => {
]), `const hello = 123;`));
const actual = toArr(lineTokens);
assert.deepEqual(actual, [
assert.deepStrictEqual(actual, [
5, createTMMetadata(5, FontStyle.Bold, 53),
6, createTMMetadata(1, FontStyle.None, 53),
11, createTMMetadata(1, FontStyle.None, 53),