start on hat stats and golden tests

Author: josharian

Diff for: packages/common/src/index.ts

@@ -86,3 +86,4 @@ export * from "./getFakeCommandServerApi";
 export * from "./types/TestCaseFixture";
 export * from "./util/getEnvironmentVariableStrict";
 export * from "./util/CompositeKeyDefaultMap";
+export { MockTextDocument, MockTextEditor } from "./testUtil/mockEditor";

Diff for: packages/common/src/testUtil/mockEditor.test.ts

@@ -0,0 +1,36 @@
+import * as assert from "assert";
+import { MockTextDocument, Range } from "..";
+
+suite("mockEditor", () => {
+  test("basic", () => {
+    const s = "abc\n\n123\n";
+    const doc: MockTextDocument = new MockTextDocument(
+      "test.txt",
+      "plaintext",
+      s,
+    );
+
+    for (let i = 0; i < s.length; i++) {
+      const pos = doc.positionAt(i);
+      const offset = doc.offsetAt(pos);
+      assert.equal(offset, i);
+    }
+    const line0 = doc.lineAt(0);
+    assert.equal(line0.text, "abc");
+    assert.equal(line0.firstNonWhitespaceCharacterIndex, 0);
+    assert.equal(line0.isEmptyOrWhitespace, false);
+    assert.equal(line0.lineNumber, 0);
+    assert.ok(line0.range.isEqual(new Range(0, 0, 0, 3)));
+    assert.equal(line0.rangeIncludingLineBreak.start.character, 0);
+    assert.equal(line0.lastNonWhitespaceCharacterIndex, 2);
+
+    const line1 = doc.lineAt(1);
+    assert.equal(line1.text, "");
+    assert.equal(line1.firstNonWhitespaceCharacterIndex, 0);
+    assert.equal(line1.isEmptyOrWhitespace, true);
+    assert.equal(line1.lineNumber, 1);
+    assert.ok(line1.range.isEqual(new Range(1, 0, 1, 0)));
+    assert.equal(line1.rangeIncludingLineBreak.start.character, 0);
+    assert.equal(line1.lastNonWhitespaceCharacterIndex, 0);
+  });
+});

Diff for: packages/common/src/testUtil/mockEditor.ts

@@ -0,0 +1,170 @@
+import { URI } from "vscode-uri";
+import {
+  EndOfLine,
+  Position,
+  Range,
+  Selection,
+  TextDocument,
+  TextEditor,
+  TextEditorOptions,
+  TextLine,
+} from "..";
+
+// See the TextLine, TextEditor, and TextDocument interfaces
+// for documentation of these classes and their fields.
+
+export class MockTextLine implements TextLine {
+  readonly lineNumber: number;
+  readonly text: string;
+  private eol: string;
+  readonly range: Range;
+  readonly rangeIncludingLineBreak: Range;
+  readonly firstNonWhitespaceCharacterIndex: number;
+  readonly lastNonWhitespaceCharacterIndex: number;
+  readonly isEmptyOrWhitespace: boolean;
+
+  constructor(lineNumber: number, text: string, eol: string) {
+    if (lineNumber < 0) {
+      throw new Error("lineNumber must be non-negative");
+    }
+    this.lineNumber = lineNumber;
+    this.text = text;
+    if (eol !== "\n" && eol !== "\r\n") {
+      throw new Error("eol must be \\n or \\r\\n");
+    }
+    this.eol = eol;
+    this.range = new Range(
+      this.lineNumber,
+      0,
+      this.lineNumber,
+      this.text.length,
+    );
+    this.rangeIncludingLineBreak = new Range(
+      this.lineNumber,
+      0,
+      this.lineNumber,
+      this.text.length + this.eol.length,
+    );
+    const first = this.text.search(/\S/);
+    this.firstNonWhitespaceCharacterIndex =
+      first === -1 ? this.text.length : first;
+    const all = this.text.match(/\S/g);
+    this.lastNonWhitespaceCharacterIndex = all
+      ? this.text.lastIndexOf(all[all.length - 1])
+      : 0;
+    this.isEmptyOrWhitespace =
+      this.firstNonWhitespaceCharacterIndex === this.text.length;
+  }
+}
+
+export class MockTextDocument implements TextDocument {
+  readonly uri: URI;
+  readonly languageId: string;
+  readonly version: number;
+  readonly range: Range;
+  readonly eol: EndOfLine;
+  private lines: MockTextLine[];
+  private contents: string;
+
+  constructor(filename: string, languageId: string, contents: string) {
+    this.uri = URI.file(filename);
+    this.languageId = languageId;
+    this.version = 1;
+    if (contents.indexOf("\r\n") !== -1) {
+      throw new Error("InMemoryTextDocument does not support CRLF (yet?)");
+    }
+    this.contents = contents;
+    const rawLines = contents.split("\n");
+    this.lines = rawLines.map((line, i) => {
+      return new MockTextLine(i, line, "\n");
+    });
+    this.range = new Range(
+      0,
+      0,
+      this.lineCount - 1,
+      this.lineLength(this.lineCount - 1),
+    );
+    this.eol = "LF";
+  }
+
+  get lineCount(): number {
+    return this.lines.length;
+  }
+
+  private lineLength(line: number): number {
+    return this.lines[line].text.length + 1; // EOF
+  }
+
+  public lineAt(x: number | Position): TextLine {
+    if (typeof x === "number") {
+      return this.lines[x];
+    }
+    return this.lines[x.line];
+  }
+
+  public offsetAt(position: Position): number {
+    let offset = 0;
+    for (let i = 0; i < position.line; i++) {
+      offset += this.lineAt(i).rangeIncludingLineBreak.end.character;
+    }
+    offset += position.character;
+    return offset;
+  }
+
+  public positionAt(offset: number): Position {
+    let line = 0;
+    while (offset >= this.lineAt(line).rangeIncludingLineBreak.end.character) {
+      offset -= this.lineAt(line).rangeIncludingLineBreak.end.character;
+      line++;
+    }
+    return new Position(line, offset);
+  }
+
+  public getText(range?: Range): string {
+    if (range === undefined) {
+      return this.contents;
+    }
+    const startOffset = this.offsetAt(range.start);
+    const endOffset = this.offsetAt(range.end);
+    return this.contents.slice(startOffset, endOffset);
+  }
+}
+
+export class MockTextEditor implements TextEditor {
+  public primarySelection: Selection;
+  readonly id: string;
+  readonly document: TextDocument;
+  readonly options: TextEditorOptions;
+  readonly isActive: boolean;
+
+  constructor(document: TextDocument, active: boolean) {
+    this.id = document.uri.toString();
+    this.document = document;
+    this.primarySelection = new Selection(0, 0, 0, 0);
+    this.options = new DefaultTextEditorOptions();
+    this.isActive = active;
+    // TODO: support visible ranges, multiple selections, options
+  }
+
+  get visibleRanges(): Range[] {
+    return [this.document.range];
+  }
+
+  get selections(): Selection[] {
+    return [this.primarySelection];
+  }
+
+  isEqual(other: TextEditor): boolean {
+    return this.id === other.id;
+  }
+}
+
+class DefaultTextEditorOptions implements TextEditorOptions {
+  get tabSize(): number | string {
+    return 4;
+  }
+
+  get insertSpaces(): boolean | string {
+    return true;
+  }
+}

Diff for: packages/common/src/types/Position.ts

@@ -138,4 +138,12 @@ export class Position {
   public toEmptyRange(): Range {
     return new Range(this, this);
   }
+
+  /**
+   * Return a concise string representation of the position, for debugging
+   * @returns concise representation
+   **/
+  public concise(): string {
+    return `${this.line}:${this.character}`;
+  }
 }

Diff for: packages/common/src/types/Range.ts

@@ -64,6 +64,17 @@ export class Range {
     return this.start.isEqual(this.end);
   }
 
+  /**
+   * Check if this range is equal to `other`.
+   *
+   * @param other A range.
+   * @return `true` if the start and end of the given range are equal to
+   * the start and end of this range.
+   */
+  public isEqual(other: Range): boolean {
+    return this.start.isEqual(other.start) && this.end.isEqual(other.end);
+  }
+
   /**
    * `true` if `start.line` and `end.line` are equal.
    */
@@ -146,4 +157,12 @@ export class Range {
       ? new Selection(this.end, this.start)
       : new Selection(this.start, this.end);
   }
+
+  /**
+   * Return a concise string representation of the range, for debugging
+   * @returns concise representation
+   **/
+  public concise(): string {
+    return `${this.start.concise()}-${this.end.concise()}`;
+  }
 }