Skip to content

Commit dfcb084

Browse files
rbucktonrbuckton
committed
Add unit tests for PerformanceHooks shim
1 parent 37b247a commit dfcb084

File tree

2 files changed

+252
-0
lines changed

2 files changed

+252
-0
lines changed

‎src/testRunner/tsconfig.json‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -75,6 +75,7 @@
7575
"unittests/semver.ts",
7676
"unittests/createMapShim.ts",
7777
"unittests/createSetShim.ts",
78+
"unittests/createPerformanceHooksShim.ts",
7879
"unittests/transform.ts",
7980
"unittests/config/commandLineParsing.ts",
8081
"unittests/config/configurationExtension.ts",

‎src/testRunner/unittests/createPerformanceHooksShim.ts‎

Lines changed: 251 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,251 @@
1+
/* eslint-disable @typescript-eslint/no-unused-expressions */ // chai's expect allows you to use dot-property assertions like `.is.empty`
2+
namespace ts {
3+
describe("unittests:: createPerformanceHooksShim", () => {
4+
it("has expected API", () => {
5+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(Date.now);
6+
expect(performance).to.be.an("object");
7+
expect(performance.timeOrigin).to.be.a("number");
8+
expect(performance.clearMarks).to.be.a("function");
9+
expect(performance.mark).to.be.a("function");
10+
expect(performance.measure).to.be.a("function");
11+
expect(performance.now).to.be.a("function");
12+
expect(PerformanceObserver).to.be.a("function");
13+
let list!: PerformanceObserverEntryList;
14+
let observer2!: PerformanceObserver;
15+
const observer = new PerformanceObserver((_list, observer) => { list = _list; observer2 = observer; });
16+
expect(list).to.be.an("object");
17+
expect(observer2).to.be.an("object");
18+
expect(observer2).to.equal(observer);
19+
expect(observer2.disconnect).to.be.a("function");
20+
expect(observer2.observe).to.be.a("function");
21+
expect(list.getEntries).to.be.a("function");
22+
expect(list.getEntriesByName).to.be.a("function");
23+
expect(list.getEntriesByType).to.be.a("function");
24+
});
25+
it("only listens for events while connected", () => {
26+
let timestamp = 0;
27+
const now = () => timestamp++;
28+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
29+
let list!: PerformanceObserverEntryList;
30+
const observer = new PerformanceObserver(_list => list = _list);
31+
32+
performance.mark("a");
33+
const entries1 = list.getEntries();
34+
observer.observe({ entryTypes: ["mark"] });
35+
performance.mark("b");
36+
const entries2 = list.getEntries();
37+
observer.disconnect();
38+
performance.mark("c");
39+
const entries3 = list.getEntries();
40+
41+
expect(entries1).to.be.empty;
42+
expect(entries2).to.not.be.empty;
43+
expect(entries3).to.be.empty;
44+
});
45+
it("Can get entries by name and type (mark)", () => {
46+
let timestamp = 0;
47+
const now = () => timestamp++;
48+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
49+
let list!: PerformanceObserverEntryList;
50+
const observer = new PerformanceObserver(_list => list = _list);
51+
observer.observe({ entryTypes: ["mark", "measure"] });
52+
performance.mark("a");
53+
performance.measure("b", "a");
54+
const entries = list.getEntriesByName("a", "mark");
55+
const entries2 = list.getEntriesByName("b", "mark");
56+
observer.disconnect();
57+
expect(entries).to.have.lengthOf(1);
58+
expect(entries[0]).to.be.an("object");
59+
expect(entries[0].name).to.equal("a");
60+
expect(entries[0].entryType).to.equal("mark");
61+
expect(entries2).to.be.empty;
62+
});
63+
it("Can get entries by name and type (measure)", () => {
64+
let timestamp = 0;
65+
const now = () => timestamp++;
66+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
67+
let list!: PerformanceObserverEntryList;
68+
const observer = new PerformanceObserver(_list => list = _list);
69+
observer.observe({ entryTypes: ["mark", "measure"] });
70+
performance.mark("a");
71+
performance.measure("b", "a");
72+
const entries = list.getEntriesByName("b", "measure");
73+
const entries2 = list.getEntriesByName("a", "measure");
74+
observer.disconnect();
75+
expect(entries).to.have.lengthOf(1);
76+
expect(entries[0]).to.be.an("object");
77+
expect(entries[0].name).to.equal("b");
78+
expect(entries[0].entryType).to.equal("measure");
79+
expect(entries2).to.be.empty;
80+
});
81+
it("Can get entries by name", () => {
82+
let timestamp = 0;
83+
const now = () => timestamp++;
84+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
85+
let list!: PerformanceObserverEntryList;
86+
const observer = new PerformanceObserver(_list => list = _list);
87+
observer.observe({ entryTypes: ["mark", "measure"] });
88+
performance.mark("a");
89+
performance.measure("b", "a");
90+
const entries = list.getEntriesByName("a");
91+
const entries2 = list.getEntriesByName("b");
92+
observer.disconnect();
93+
expect(entries).to.not.be.empty;
94+
expect(entries).to.have.lengthOf(1);
95+
expect(entries[0]).to.be.an("object");
96+
expect(entries[0].name).to.equal("a");
97+
expect(entries[0].entryType).to.equal("mark");
98+
expect(entries2).to.have.lengthOf(1);
99+
expect(entries2[0]).to.be.an("object");
100+
expect(entries2[0].name).to.equal("b");
101+
expect(entries2[0].entryType).to.equal("measure");
102+
});
103+
it("Can get entries by type", () => {
104+
let timestamp = 0;
105+
const now = () => timestamp++;
106+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
107+
let list!: PerformanceObserverEntryList;
108+
const observer = new PerformanceObserver(_list => list = _list);
109+
observer.observe({ entryTypes: ["mark", "measure"] });
110+
performance.mark("a");
111+
performance.measure("b", "a");
112+
const entries = list.getEntriesByType("mark");
113+
const entries2 = list.getEntriesByType("measure");
114+
observer.disconnect();
115+
expect(entries).to.have.lengthOf(1);
116+
expect(entries[0]).to.be.an("object");
117+
expect(entries[0].name).to.equal("a");
118+
expect(entries[0].entryType).to.equal("mark");
119+
expect(entries2).to.have.lengthOf(1);
120+
expect(entries2[0]).to.be.an("object");
121+
expect(entries2[0].name).to.equal("b");
122+
expect(entries2[0].entryType).to.equal("measure");
123+
});
124+
it("Can get entries", () => {
125+
let timestamp = 0;
126+
const now = () => timestamp++;
127+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
128+
let list!: PerformanceObserverEntryList;
129+
const observer = new PerformanceObserver(_list => list = _list);
130+
observer.observe({ entryTypes: ["mark", "measure"] });
131+
performance.mark("a");
132+
performance.measure("b", "a");
133+
const entries = list.getEntries();
134+
observer.disconnect();
135+
expect(entries).to.have.lengthOf(2);
136+
expect(entries[0]).to.be.an("object");
137+
expect(entries[0].name).to.equal("a");
138+
expect(entries[0].entryType).to.equal("mark");
139+
expect(entries[1]).to.be.an("object");
140+
expect(entries[1].name).to.equal("b");
141+
expect(entries[1].entryType).to.equal("measure");
142+
});
143+
it("Unobserved entries are ignored", () => {
144+
let timestamp = 0;
145+
const now = () => timestamp++;
146+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
147+
let list!: PerformanceObserverEntryList;
148+
const observer = new PerformanceObserver(_list => list = _list);
149+
observer.observe({ entryTypes: ["mark"] });
150+
performance.mark("a");
151+
performance.measure("b", "a");
152+
const entries = list.getEntries();
153+
observer.disconnect();
154+
expect(entries).to.have.lengthOf(1);
155+
expect(entries[0]).to.be.an("object");
156+
expect(entries[0].name).to.equal("a");
157+
expect(entries[0].entryType).to.equal("mark");
158+
});
159+
it("Changing what's observed only affects new entries", () => {
160+
let timestamp = 0;
161+
const now = () => timestamp++;
162+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
163+
let list!: PerformanceObserverEntryList;
164+
const observer = new PerformanceObserver(_list => list = _list);
165+
observer.observe({ entryTypes: ["mark"] });
166+
performance.mark("a");
167+
performance.measure("b", "a");
168+
observer.observe({ entryTypes: ["measure"] });
169+
performance.mark("c");
170+
performance.measure("d", "c");
171+
const entries = list.getEntries();
172+
observer.disconnect();
173+
expect(entries).to.have.lengthOf(2);
174+
expect(entries[0]).to.be.an("object");
175+
expect(entries[0].name).to.equal("a");
176+
expect(entries[0].entryType).to.equal("mark");
177+
expect(entries[1]).to.be.an("object");
178+
expect(entries[1].name).to.equal("d");
179+
expect(entries[1].entryType).to.equal("measure");
180+
});
181+
it("mark tracks current time", () => {
182+
let timestamp = 0;
183+
const now = () => timestamp;
184+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
185+
let list!: PerformanceObserverEntryList;
186+
const observer = new PerformanceObserver(_list => list = _list);
187+
observer.observe({ entryTypes: ["mark"] });
188+
const ts1 = timestamp;
189+
performance.mark("a");
190+
timestamp++;
191+
const ts2 = timestamp;
192+
performance.mark("b");
193+
const entries = list.getEntries();
194+
observer.disconnect();
195+
expect(entries[0].startTime).to.equal(ts1);
196+
expect(entries[0].duration).to.equal(0);
197+
expect(entries[1].startTime).to.equal(ts2);
198+
expect(entries[1].duration).to.equal(0);
199+
});
200+
it("measure tracks time between marks", () => {
201+
let timestamp = 0;
202+
const now = () => timestamp;
203+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
204+
let list!: PerformanceObserverEntryList;
205+
const observer = new PerformanceObserver(_list => list = _list);
206+
observer.observe({ entryTypes: ["mark", "measure"] });
207+
const ts1 = timestamp;
208+
performance.mark("a");
209+
timestamp++;
210+
const ts2 = timestamp;
211+
performance.mark("b");
212+
performance.measure("c", "a", "b");
213+
const entries = list.getEntriesByType("measure");
214+
observer.disconnect();
215+
expect(entries[0].startTime).to.equal(ts1);
216+
expect(entries[0].duration).to.equal(ts2 - ts1);
217+
});
218+
it("measure tracks time between unobserved marks", () => {
219+
let timestamp = 0;
220+
const now = () => timestamp;
221+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
222+
let list!: PerformanceObserverEntryList;
223+
const observer = new PerformanceObserver(_list => list = _list);
224+
observer.observe({ entryTypes: ["measure"] });
225+
const ts1 = timestamp;
226+
performance.mark("a");
227+
timestamp++;
228+
const ts2 = timestamp;
229+
performance.mark("b");
230+
performance.measure("c", "a", "b");
231+
const entries = list.getEntries();
232+
observer.disconnect();
233+
expect(entries[0].startTime).to.equal(ts1);
234+
expect(entries[0].duration).to.equal(ts2 - ts1);
235+
});
236+
it("marks can be counted", () => {
237+
let timestamp = 0;
238+
const now = () => timestamp++;
239+
const { performance, PerformanceObserver } = ShimPerformance.createPerformanceHooksShim(now);
240+
let list!: PerformanceObserverEntryList;
241+
const observer = new PerformanceObserver(_list => list = _list);
242+
observer.observe({ entryTypes: ["mark"] });
243+
performance.mark("a");
244+
performance.mark("a");
245+
performance.mark("a");
246+
const entries = list.getEntries();
247+
observer.disconnect();
248+
expect(entries).to.have.lengthOf(3);
249+
});
250+
});
251+
}

0 commit comments

Comments
 (0)