vscode-codeql/extensions/ql-vscode/test/unit-tests/common/disposable-object.test.ts at e71ea8d975761c0432c6d623e53fe1220e06968a · github/vscode-codeql · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
import { DisposableObject } from "../../../src/common/disposable-object";

describe("DisposableObject and DisposeHandler", () => {
  const disposable1 = {
    dispose: jest.fn(),
  };
  const disposable2 = {
    dispose: jest.fn(),
  };
  const disposable3 = {
    dispose: jest.fn(),
  };
  const disposable4 = {
    dispose: jest.fn(),
  };
  let disposableObject: any;
  let nestedDisposableObject: any;

  beforeEach(() => {
    disposable1.dispose.mockClear();
    disposable2.dispose.mockClear();
    disposable3.dispose.mockClear();
    disposable4.dispose.mockClear();

    disposableObject = new MyDisposableObject();
    nestedDisposableObject = new MyDisposableObject();
  });

  it("should dispose tracked and pushed objects", () => {
    disposableObject.push(disposable1);
    disposableObject.push(disposable2);
    disposableObject.track(nestedDisposableObject);
    nestedDisposableObject.track(disposable3);

    disposableObject.dispose();

    expect(disposable1.dispose).toHaveBeenCalled();
    expect(disposable2.dispose).toHaveBeenCalled();
    expect(disposable3.dispose).toHaveBeenCalled();

    // pushed items must be called in reverse order
    expect(disposable2.dispose.mock.invocationCallOrder[0]).toBeLessThan(
      disposable1.dispose.mock.invocationCallOrder[0],
    );

    // now that disposableObject has been disposed, subsequent disposals are
    // no-ops
    disposable1.dispose.mockClear();
    disposable2.dispose.mockClear();
    disposable3.dispose.mockClear();

    disposableObject.dispose();

    expect(disposable1.dispose).not.toHaveBeenCalled();
    expect(disposable2.dispose).not.toHaveBeenCalled();
    expect(disposable3.dispose).not.toHaveBeenCalled();
  });

  it("should dispose and stop tracking objects", () => {
    disposableObject.track(disposable1);
    disposableObject.disposeAndStopTracking(disposable1);

    expect(disposable1.dispose).toHaveBeenCalled();
    disposable1.dispose.mockClear();

    disposableObject.dispose();
    expect(disposable1.dispose).not.toHaveBeenCalled();
  });

  it("should avoid disposing an object that is not tracked", () => {
    disposableObject.push(disposable1);
    disposableObject.disposeAndStopTracking(disposable1);

    expect(disposable1.dispose).not.toHaveBeenCalled();

    disposableObject.dispose();
    expect(disposable1.dispose).toHaveBeenCalled();
  });

  it("should use a dispose handler", () => {
    const handler = (d: any) =>
      d === disposable1 || d === disposable3 || d === nestedDisposableObject
        ? void d.dispose(handler)
        : void 0;

    disposableObject.push(disposable1);
    disposableObject.push(disposable2);
    disposableObject.track(nestedDisposableObject);
    nestedDisposableObject.track(disposable3);
    nestedDisposableObject.track(disposable4);

    disposableObject.dispose(handler);

    expect(disposable1.dispose).toHaveBeenCalled();
    expect(disposable2.dispose).not.toHaveBeenCalled();
    expect(disposable3.dispose).toHaveBeenCalled();
    expect(disposable4.dispose).not.toHaveBeenCalled();

    // now that disposableObject has been disposed, subsequent disposals are
    // no-ops
    disposable1.dispose.mockClear();
    disposable2.dispose.mockClear();
    disposable3.dispose.mockClear();
    disposable4.dispose.mockClear();

    disposableObject.dispose();

    expect(disposable1.dispose).not.toHaveBeenCalled();
    expect(disposable2.dispose).not.toHaveBeenCalled();
    expect(disposable3.dispose).not.toHaveBeenCalled();
    expect(disposable4.dispose).not.toHaveBeenCalled();
  });

  class MyDisposableObject extends DisposableObject {
    constructor() {
      super();
    }
  }
});