• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Copyright (C) 2023 The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//      http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15import {
16  c,
17  cmpFromExpr,
18  cmpFromSort,
19  ConcreteEventSet,
20  Direction,
21  EmptyEventSet,
22  EmptyKeySet,
23  eq,
24  Event,
25  EventSet,
26  isConcreteEventSet,
27  isEmptyEventSet,
28  KeySet,
29  Num,
30  Str,
31  UntypedEvent,
32  v,
33} from './event_set';
34
35describe('EventSet', () => {
36  test('Event', () => {
37    {
38      const keyset: EmptyKeySet = {};
39      const event: Event<typeof keyset> = {
40        id: 'foo',
41      };
42      void event;
43    }
44    {
45      const keyset = {
46        bar: Num,
47      };
48      const event: Event<typeof keyset> = {
49        id: 'foo',
50        bar: 42,
51      };
52      void event;
53    }
54  });
55
56  describe('EmptyEventSet', () => {
57    test('isEmpty', async () => {
58      const events = EmptyEventSet.get();
59      expect(await events.isEmpty()).toEqual(true);
60      expect(await events.count()).toEqual(0);
61    });
62
63    test('isEmptyEventSet', () => {
64      const events: EventSet<KeySet> = EmptyEventSet.get();
65      expect(isEmptyEventSet(events)).toEqual(true);
66    });
67
68    test('materialise', async () => {
69      const events: EventSet<KeySet> = EmptyEventSet.get();
70      const materialised = await events.materialise({});
71
72      expect(await materialised.isEmpty()).toEqual(true);
73      expect(await materialised.count()).toEqual(0);
74      expect(materialised.events).toEqual([]);
75      expect(isConcreteEventSet(materialised)).toEqual(true);
76    });
77
78    test('union', async () => {
79      const a: EventSet<KeySet> = EmptyEventSet.get();
80      const b: EventSet<KeySet> = EmptyEventSet.get();
81
82      const aUnionB = a.union(b);
83
84      expect(await aUnionB.isEmpty()).toEqual(true);
85      expect(await aUnionB.count()).toEqual(0);
86    });
87
88    test('intersect', async () => {
89      const a: EventSet<KeySet> = EmptyEventSet.get();
90      const b: EventSet<KeySet> = EmptyEventSet.get();
91
92      const aIntersectB = a.intersect(b);
93
94      expect(await aIntersectB.isEmpty()).toEqual(true);
95      expect(await aIntersectB.count()).toEqual(0);
96    });
97
98    test('filter', async () => {
99      const events: EventSet<KeySet> = EmptyEventSet.get();
100      const filtered = await events.filter(c(true));
101
102      expect(filtered).toBe(events);
103      expect(await filtered.isEmpty()).toEqual(true);
104      expect(await filtered.count()).toEqual(0);
105    });
106
107    test('sort', async () => {
108      const events: EventSet<KeySet> = EmptyEventSet.get();
109      const sorted = await events.sort({
110        direction: Direction.ASC,
111        expression: c(0),
112      });
113
114      expect(sorted).toBe(events);
115      expect(await sorted.isEmpty()).toEqual(true);
116      expect(await sorted.count()).toEqual(0);
117    });
118  });
119
120  describe('ConcreteEventSet', () => {
121    test('isEmpty', async () => {
122      const event: Event<EmptyKeySet> = {
123        id: 'foo',
124      };
125      const empty = new ConcreteEventSet<EmptyKeySet>({}, []);
126      const events = new ConcreteEventSet<EmptyKeySet>({}, [event]);
127      expect(await empty.isEmpty()).toEqual(true);
128      expect(await empty.count()).toEqual(0);
129      expect(await events.isEmpty()).toEqual(false);
130      expect(await events.count()).toEqual(1);
131    });
132
133    test('isConcreteEventSet', () => {
134      expect(
135        isConcreteEventSet(new ConcreteEventSet<EmptyKeySet>({}, [])),
136      ).toEqual(true);
137      expect(isConcreteEventSet(EmptyEventSet.get())).toEqual(false);
138    });
139
140    test('materialise', async () => {
141      const keys = {
142        num: Num,
143        char: Str,
144      };
145
146      const a: Event<typeof keys> = {
147        id: 'a',
148        num: 97,
149        char: 'a',
150      };
151      const b: Event<typeof keys> = {
152        id: 'b',
153        num: 98,
154        char: 'b',
155      };
156      const d: Event<typeof keys> = {
157        id: 'd',
158        num: 100,
159        char: 'd',
160      };
161
162      const events = new ConcreteEventSet(keys, [a, b, d]);
163
164      expect((await events.materialise(keys)).events).toEqual([a, b, d]);
165      expect((await events.materialise(keys, 1)).events).toEqual([b, d]);
166      expect((await events.materialise(keys, 1, 1)).events).toEqual([b]);
167      expect((await events.materialise(keys, 99)).events).toEqual([]);
168      expect((await events.materialise(keys, 99, 0)).events).toEqual([]);
169      expect((await events.materialise({num: Num})).events).toEqual([
170        {id: 'a', num: 97},
171        {id: 'b', num: 98},
172        {id: 'd', num: 100},
173      ]);
174      expect((await events.materialise({char: Str}, 1, 1)).events).toEqual([
175        {id: 'b', char: 'b'},
176      ]);
177    });
178
179    test('union', async () => {
180      const a: Event<EmptyKeySet> = {
181        id: 'a',
182      };
183      const b: Event<EmptyKeySet> = {
184        id: 'b',
185      };
186      const d: Event<EmptyKeySet> = {
187        id: 'd',
188      };
189
190      const empty = EmptyEventSet.get();
191      const justA = new ConcreteEventSet({}, [a]);
192      const justB = new ConcreteEventSet({}, [b]);
193      const justD = new ConcreteEventSet({}, [d]);
194
195      const aAndB = justA.union(justB);
196      const aAndA = justA.union(justA);
197      const aAndD = justA.union(justD);
198      const aAndBAndEmpty = aAndB.union(empty);
199      const aAndDAndAAndB = aAndD.union(aAndB);
200
201      expect((await aAndB.materialise({})).events).toEqual([a, b]);
202      expect((await aAndA.materialise({})).events).toEqual([a]);
203      expect((await aAndD.materialise({})).events).toEqual([a, d]);
204      expect((await aAndBAndEmpty.materialise({})).events).toEqual([a, b]);
205      expect((await aAndDAndAAndB.materialise({})).events).toEqual([a, d, b]);
206
207      expect(await aAndB.isEmpty()).toEqual(false);
208      expect(await aAndA.isEmpty()).toEqual(false);
209      expect(await aAndD.isEmpty()).toEqual(false);
210      expect(await aAndBAndEmpty.isEmpty()).toEqual(false);
211      expect(await aAndDAndAAndB.isEmpty()).toEqual(false);
212
213      expect(await aAndB.count()).toEqual(2);
214      expect(await aAndA.count()).toEqual(1);
215      expect(await aAndD.count()).toEqual(2);
216      expect(await aAndBAndEmpty.count()).toEqual(2);
217      expect(await aAndDAndAAndB.count()).toEqual(3);
218    });
219
220    test('intersection', async () => {
221      const a: Event<EmptyKeySet> = {
222        id: 'a',
223      };
224      const b: Event<EmptyKeySet> = {
225        id: 'b',
226      };
227      const d: Event<EmptyKeySet> = {
228        id: 'd',
229      };
230
231      const empty = EmptyEventSet.get();
232      const justA = new ConcreteEventSet({}, [a]);
233      const justB = new ConcreteEventSet({}, [b]);
234      const justD = new ConcreteEventSet({}, [d]);
235
236      const aAndB = justA.intersect(justB);
237      const aAndA = justA.intersect(justA);
238      const aAndD = justA.intersect(justD);
239      const aBAndEmpty = justA.union(justB).intersect(empty);
240      const aDAndAB = justA.union(justB).intersect(justA.union(justD));
241
242      expect((await aAndB.materialise({})).events).toEqual([]);
243      expect((await aAndA.materialise({})).events).toEqual([a]);
244      expect((await aAndD.materialise({})).events).toEqual([]);
245      expect((await aBAndEmpty.materialise({})).events).toEqual([]);
246      expect((await aDAndAB.materialise({})).events).toEqual([a]);
247
248      expect(await aAndB.isEmpty()).toEqual(true);
249      expect(await aAndA.isEmpty()).toEqual(false);
250      expect(await aAndD.isEmpty()).toEqual(true);
251      expect(await aBAndEmpty.isEmpty()).toEqual(true);
252      expect(await aDAndAB.isEmpty()).toEqual(false);
253
254      expect(await aAndB.count()).toEqual(0);
255      expect(await aAndA.count()).toEqual(1);
256      expect(await aAndD.count()).toEqual(0);
257      expect(await aBAndEmpty.count()).toEqual(0);
258      expect(await aDAndAB.count()).toEqual(1);
259    });
260
261    test('filter', async () => {
262      const keys = {
263        num: Num,
264        char: Str,
265      };
266
267      const a: Event<typeof keys> = {
268        id: 'a',
269        num: 97,
270        char: 'a',
271      };
272      const b: Event<typeof keys> = {
273        id: 'b',
274        num: 98,
275        char: 'b',
276      };
277      const d: Event<typeof keys> = {
278        id: 'd',
279        num: 100,
280        char: 'd',
281      };
282
283      const events = new ConcreteEventSet(keys, [a, b, d]);
284
285      const justA = events.filter(eq(v('id'), c('a')));
286      const justD = events.filter(eq(v('num'), c(100)));
287
288      expect((await justA.materialise(keys)).events).toEqual([a]);
289      expect((await justD.materialise(keys)).events).toEqual([d]);
290    });
291
292    test('sort', async () => {
293      const keys = {
294        num: Num,
295        char: Str,
296      };
297
298      const a: Event<typeof keys> = {
299        id: 'a',
300        num: 97,
301        char: 'a',
302      };
303      const b: Event<typeof keys> = {
304        id: 'b',
305        num: 98,
306        char: 'b',
307      };
308      const d: Event<typeof keys> = {
309        id: 'd',
310        num: 100,
311        char: 'd',
312      };
313
314      const events = new ConcreteEventSet(keys, [a, b, d]);
315
316      const byNum = events.sort({
317        expression: v('num'),
318        direction: Direction.ASC,
319      });
320      const byStr = events.sort({
321        expression: v('char'),
322        direction: Direction.ASC,
323      });
324
325      expect((await byNum.materialise(keys)).events).toEqual([a, b, d]);
326      expect((await byStr.materialise(keys)).events).toEqual([a, b, d]);
327    });
328
329    test('sort desc', async () => {
330      const keys = {
331        num: Num,
332        char: Str,
333      };
334
335      const a: Event<typeof keys> = {
336        id: 'a',
337        num: 97,
338        char: 'a',
339      };
340      const b: Event<typeof keys> = {
341        id: 'b',
342        num: 98,
343        char: 'b',
344      };
345      const d: Event<typeof keys> = {
346        id: 'd',
347        num: 100,
348        char: 'd',
349      };
350
351      const events = new ConcreteEventSet(keys, [a, b, d]);
352
353      const byNum = events.sort({
354        expression: v('num'),
355        direction: Direction.DESC,
356      });
357      const byStr = events.sort({
358        expression: v('char'),
359        direction: Direction.DESC,
360      });
361
362      expect((await byNum.materialise(keys)).events).toEqual([d, b, a]);
363      expect((await byStr.materialise(keys)).events).toEqual([d, b, a]);
364    });
365  });
366});
367
368describe('cmpFromExpr', () => {
369  test('simple', () => {
370    const a: UntypedEvent = {
371      id: 'a',
372      x: 0,
373    };
374    const b: UntypedEvent = {
375      id: 'b',
376      x: 42,
377    };
378    const c: UntypedEvent = {
379      id: 'c',
380      x: 0,
381    };
382
383    const cmp = cmpFromExpr(v('x'));
384    expect(cmp(a, b)).toEqual(-1);
385    expect(cmp(a, a)).toEqual(0);
386    expect(cmp(b, a)).toEqual(1);
387    expect(cmp(a, c)).toEqual(0);
388  });
389
390  test('kinds', () => {
391    const nullEvent: UntypedEvent = {
392      id: 'nullEvent',
393      x: null,
394    };
395    const sevenEvent: UntypedEvent = {
396      id: 'sevenEvent',
397      x: 7,
398    };
399    const oneEvent: UntypedEvent = {
400      id: 'oneEvent',
401      x: 1,
402    };
403    const zeroEvent: UntypedEvent = {
404      id: 'zeroEvent',
405      x: 0,
406    };
407    const trueEvent: UntypedEvent = {
408      id: 'trueEvent',
409      x: true,
410    };
411    const falseEvent: UntypedEvent = {
412      id: 'falseEvent',
413      x: false,
414    };
415    const aardvarkEvent: UntypedEvent = {
416      id: 'aardvarkEvent',
417      x: 'aardvark',
418    };
419    const zigguratEvent: UntypedEvent = {
420      id: 'zigguratEvent',
421      x: 'ziggurat',
422    };
423    const bigZeroEvent: UntypedEvent = {
424      id: 'bigZeroEvent',
425      x: 0n,
426    };
427    const bigOneEvent: UntypedEvent = {
428      id: 'bigOneEvent',
429      x: 1n,
430    };
431    const bigTwoEvent: UntypedEvent = {
432      id: 'bigTwoEvent',
433      x: 2n,
434    };
435
436    const cmp = cmpFromExpr(v('x'));
437
438    // Everything is equal to itself:
439    expect(cmp(nullEvent, nullEvent)).toEqual(0);
440    expect(cmp(sevenEvent, sevenEvent)).toEqual(0);
441    expect(cmp(oneEvent, oneEvent)).toEqual(0);
442    expect(cmp(zeroEvent, zeroEvent)).toEqual(0);
443    expect(cmp(falseEvent, falseEvent)).toEqual(0);
444    expect(cmp(trueEvent, trueEvent)).toEqual(0);
445    expect(cmp(aardvarkEvent, aardvarkEvent)).toEqual(0);
446    expect(cmp(zigguratEvent, zigguratEvent)).toEqual(0);
447    expect(cmp(bigZeroEvent, bigZeroEvent)).toEqual(0);
448    expect(cmp(bigOneEvent, bigOneEvent)).toEqual(0);
449    expect(cmp(bigTwoEvent, bigTwoEvent)).toEqual(0);
450
451    // BigInt(x) == x
452    expect(cmp(bigZeroEvent, zeroEvent)).toEqual(0);
453    expect(cmp(bigOneEvent, oneEvent)).toEqual(0);
454
455    // one = true, zero = false:
456    expect(cmp(oneEvent, trueEvent)).toEqual(0);
457    expect(cmp(zeroEvent, falseEvent)).toEqual(0);
458    expect(cmp(bigOneEvent, trueEvent)).toEqual(0);
459    expect(cmp(bigZeroEvent, falseEvent)).toEqual(0);
460
461    // 0 < 1 < 7
462    expect(cmp(zeroEvent, oneEvent)).toEqual(-1);
463    expect(cmp(sevenEvent, oneEvent)).toEqual(1);
464
465    // 0n < 1n < 2n
466    expect(cmp(bigZeroEvent, bigOneEvent)).toEqual(-1);
467    expect(cmp(bigTwoEvent, bigOneEvent)).toEqual(1);
468
469    // 0 < 1n < 7
470    expect(cmp(zeroEvent, bigOneEvent)).toEqual(-1);
471    expect(cmp(sevenEvent, bigOneEvent)).toEqual(1);
472
473    // aardvark < ziggurat
474    expect(cmp(aardvarkEvent, zigguratEvent)).toEqual(-1);
475
476    // null < {bools, numbers, BigInt} < strings
477    expect(cmp(nullEvent, falseEvent)).toEqual(-1);
478    expect(cmp(aardvarkEvent, sevenEvent)).toEqual(1);
479    expect(cmp(nullEvent, bigZeroEvent)).toEqual(-1);
480    expect(cmp(bigZeroEvent, sevenEvent)).toEqual(-1);
481    expect(cmp(nullEvent, falseEvent)).toEqual(-1);
482    expect(cmp(falseEvent, sevenEvent)).toEqual(-1);
483  });
484});
485
486describe('cmpFromSort', () => {
487  test('simple asc', () => {
488    const a: UntypedEvent = {
489      id: 'a',
490      x: 0,
491    };
492    const b: UntypedEvent = {
493      id: 'b',
494      x: 42,
495    };
496    const c: UntypedEvent = {
497      id: 'c',
498      x: 0,
499    };
500
501    const cmp = cmpFromSort({
502      expression: v('x'),
503      direction: Direction.ASC,
504    });
505    expect(cmp(a, b)).toEqual(-1);
506    expect(cmp(a, a)).toEqual(0);
507    expect(cmp(b, a)).toEqual(1);
508    expect(cmp(a, c)).toEqual(0);
509  });
510
511  test('kinds asc', () => {
512    const nullEvent: UntypedEvent = {
513      id: 'nullEvent',
514      x: null,
515    };
516    const sevenEvent: UntypedEvent = {
517      id: 'sevenEvent',
518      x: 7,
519    };
520    const oneEvent: UntypedEvent = {
521      id: 'oneEvent',
522      x: 1,
523    };
524    const zeroEvent: UntypedEvent = {
525      id: 'zeroEvent',
526      x: 0,
527    };
528    const trueEvent: UntypedEvent = {
529      id: 'trueEvent',
530      x: true,
531    };
532    const falseEvent: UntypedEvent = {
533      id: 'falseEvent',
534      x: false,
535    };
536    const aardvarkEvent: UntypedEvent = {
537      id: 'aardvarkEvent',
538      x: 'aardvark',
539    };
540    const zigguratEvent: UntypedEvent = {
541      id: 'zigguratEvent',
542      x: 'ziggurat',
543    };
544    const bigZeroEvent: UntypedEvent = {
545      id: 'bigZeroEvent',
546      x: 0n,
547    };
548    const bigOneEvent: UntypedEvent = {
549      id: 'bigOneEvent',
550      x: 1n,
551    };
552    const bigTwoEvent: UntypedEvent = {
553      id: 'bigTwoEvent',
554      x: 2n,
555    };
556
557    const cmp = cmpFromSort({
558      expression: v('x'),
559      direction: Direction.ASC,
560    });
561
562    // Everything is equal to itself:
563    expect(cmp(nullEvent, nullEvent)).toEqual(0);
564    expect(cmp(sevenEvent, sevenEvent)).toEqual(0);
565    expect(cmp(oneEvent, oneEvent)).toEqual(0);
566    expect(cmp(zeroEvent, zeroEvent)).toEqual(0);
567    expect(cmp(falseEvent, falseEvent)).toEqual(0);
568    expect(cmp(trueEvent, trueEvent)).toEqual(0);
569    expect(cmp(aardvarkEvent, aardvarkEvent)).toEqual(0);
570    expect(cmp(zigguratEvent, zigguratEvent)).toEqual(0);
571    expect(cmp(bigZeroEvent, bigZeroEvent)).toEqual(0);
572    expect(cmp(bigOneEvent, bigOneEvent)).toEqual(0);
573    expect(cmp(bigTwoEvent, bigTwoEvent)).toEqual(0);
574
575    // BigInt(x) == x
576    expect(cmp(bigZeroEvent, zeroEvent)).toEqual(0);
577    expect(cmp(bigOneEvent, oneEvent)).toEqual(0);
578
579    // one = true, zero = false:
580    expect(cmp(oneEvent, trueEvent)).toEqual(0);
581    expect(cmp(zeroEvent, falseEvent)).toEqual(0);
582    expect(cmp(bigOneEvent, trueEvent)).toEqual(0);
583    expect(cmp(bigZeroEvent, falseEvent)).toEqual(0);
584
585    // 0 < 1 < 7
586    expect(cmp(zeroEvent, oneEvent)).toEqual(-1);
587    expect(cmp(sevenEvent, oneEvent)).toEqual(1);
588
589    // 0n < 1n < 2n
590    expect(cmp(bigZeroEvent, bigOneEvent)).toEqual(-1);
591    expect(cmp(bigTwoEvent, bigOneEvent)).toEqual(1);
592
593    // 0 < 1n < 7
594    expect(cmp(zeroEvent, bigOneEvent)).toEqual(-1);
595    expect(cmp(sevenEvent, bigOneEvent)).toEqual(1);
596
597    // aardvark < ziggurat
598    expect(cmp(aardvarkEvent, zigguratEvent)).toEqual(-1);
599
600    // null < {bools, numbers, BigInt} < strings
601    expect(cmp(nullEvent, falseEvent)).toEqual(-1);
602    expect(cmp(aardvarkEvent, sevenEvent)).toEqual(1);
603    expect(cmp(nullEvent, bigZeroEvent)).toEqual(-1);
604    expect(cmp(bigZeroEvent, sevenEvent)).toEqual(-1);
605    expect(cmp(nullEvent, falseEvent)).toEqual(-1);
606    expect(cmp(falseEvent, sevenEvent)).toEqual(-1);
607  });
608
609  test('simple desc', () => {
610    const a: UntypedEvent = {
611      id: 'a',
612      x: 0,
613    };
614    const b: UntypedEvent = {
615      id: 'b',
616      x: 42,
617    };
618    const c: UntypedEvent = {
619      id: 'c',
620      x: 0,
621    };
622
623    const cmp = cmpFromSort({
624      expression: v('x'),
625      direction: Direction.DESC,
626    });
627    expect(cmp(a, b)).toEqual(1);
628    expect(cmp(a, a)).toEqual(0);
629    expect(cmp(b, a)).toEqual(-1);
630    expect(cmp(a, c)).toEqual(0);
631  });
632
633  test('kinds desc', () => {
634    const nullEvent: UntypedEvent = {
635      id: 'nullEvent',
636      x: null,
637    };
638    const sevenEvent: UntypedEvent = {
639      id: 'sevenEvent',
640      x: 7,
641    };
642    const oneEvent: UntypedEvent = {
643      id: 'oneEvent',
644      x: 1,
645    };
646    const zeroEvent: UntypedEvent = {
647      id: 'zeroEvent',
648      x: 0,
649    };
650    const trueEvent: UntypedEvent = {
651      id: 'trueEvent',
652      x: true,
653    };
654    const falseEvent: UntypedEvent = {
655      id: 'falseEvent',
656      x: false,
657    };
658    const aardvarkEvent: UntypedEvent = {
659      id: 'aardvarkEvent',
660      x: 'aardvark',
661    };
662    const zigguratEvent: UntypedEvent = {
663      id: 'zigguratEvent',
664      x: 'ziggurat',
665    };
666    const bigZeroEvent: UntypedEvent = {
667      id: 'bigZeroEvent',
668      x: 0n,
669    };
670    const bigOneEvent: UntypedEvent = {
671      id: 'bigOneEvent',
672      x: 1n,
673    };
674    const bigTwoEvent: UntypedEvent = {
675      id: 'bigTwoEvent',
676      x: 2n,
677    };
678
679    const cmp = cmpFromSort({
680      expression: v('x'),
681      direction: Direction.DESC,
682    });
683
684    // Everything is equal to itself:
685    expect(cmp(nullEvent, nullEvent)).toEqual(0);
686    expect(cmp(sevenEvent, sevenEvent)).toEqual(0);
687    expect(cmp(oneEvent, oneEvent)).toEqual(0);
688    expect(cmp(zeroEvent, zeroEvent)).toEqual(0);
689    expect(cmp(falseEvent, falseEvent)).toEqual(0);
690    expect(cmp(trueEvent, trueEvent)).toEqual(0);
691    expect(cmp(aardvarkEvent, aardvarkEvent)).toEqual(0);
692    expect(cmp(zigguratEvent, zigguratEvent)).toEqual(0);
693    expect(cmp(bigZeroEvent, bigZeroEvent)).toEqual(0);
694    expect(cmp(bigOneEvent, bigOneEvent)).toEqual(0);
695    expect(cmp(bigTwoEvent, bigTwoEvent)).toEqual(0);
696
697    // BigInt(x) == x
698    expect(cmp(bigZeroEvent, zeroEvent)).toEqual(0);
699    expect(cmp(bigOneEvent, oneEvent)).toEqual(0);
700
701    // one = true, zero = false:
702    expect(cmp(oneEvent, trueEvent)).toEqual(0);
703    expect(cmp(zeroEvent, falseEvent)).toEqual(0);
704    expect(cmp(bigOneEvent, trueEvent)).toEqual(0);
705    expect(cmp(bigZeroEvent, falseEvent)).toEqual(0);
706
707    // 0 < 1 < 7
708    expect(cmp(zeroEvent, oneEvent)).toEqual(1);
709    expect(cmp(sevenEvent, oneEvent)).toEqual(-1);
710
711    // 0n < 1n < 2n
712    expect(cmp(bigZeroEvent, bigOneEvent)).toEqual(1);
713    expect(cmp(bigTwoEvent, bigOneEvent)).toEqual(-1);
714
715    // 0 < 1n < 7
716    expect(cmp(zeroEvent, bigOneEvent)).toEqual(1);
717    expect(cmp(sevenEvent, bigOneEvent)).toEqual(-1);
718
719    // aardvark < ziggurat
720    expect(cmp(aardvarkEvent, zigguratEvent)).toEqual(1);
721
722    // null < {bools, numbers, BigInt} < strings
723    expect(cmp(nullEvent, falseEvent)).toEqual(1);
724    expect(cmp(aardvarkEvent, sevenEvent)).toEqual(-1);
725    expect(cmp(nullEvent, bigZeroEvent)).toEqual(1);
726    expect(cmp(bigZeroEvent, sevenEvent)).toEqual(1);
727    expect(cmp(nullEvent, falseEvent)).toEqual(1);
728    expect(cmp(falseEvent, sevenEvent)).toEqual(1);
729  });
730});
731