Use protopiler for protocol buffers

Co-authored-by: Jamie Kyle <jamie@signal.org>

ts/test-node/util/timestampLongUtils_test.std.ts

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 
 import { assert } from 'chai';
-import Long from 'long';
 
 import {
   getSafeLongFromTimestamp,
@@ -12,34 +11,38 @@ import {
   getCheckedTimestampOrUndefinedFromLong,
 } from '../../util/timestampLongUtils.std.js';
 import { MAX_SAFE_DATE } from '../../util/timestamp.std.js';
+import { MAX_VALUE } from '../../util/long.std.js';
+
+import { toNumber } from '../../util/toNumber.std.js';
 
 describe('getSafeLongFromTimestamp', () => {
   it('returns zero when passed undefined', () => {
-    assert(getSafeLongFromTimestamp(undefined).isZero());
+    assert.strictEqual(getSafeLongFromTimestamp(undefined), 0n);
   });
 
   it('returns the number as a Long when passed a "normal" number', () => {
-    assert(getSafeLongFromTimestamp(0).isZero());
+    assert.strictEqual(getSafeLongFromTimestamp(0), 0n);
     assert.strictEqual(getSafeLongFromTimestamp(123).toString(), '123');
     assert.strictEqual(getSafeLongFromTimestamp(-456).toString(), '-456');
   });
 
   it('returns MAX_SAFE_DATE when passed Infinity', () => {
     assert.strictEqual(
-      getSafeLongFromTimestamp(Infinity).toNumber(),
+      toNumber(getSafeLongFromTimestamp(Infinity)),
       MAX_SAFE_DATE
     );
   });
 
-  it('returns Long.MAX_VALUE when passed Infinity and overriden', () => {
-    assert(
-      getSafeLongFromTimestamp(Infinity, Long.MAX_VALUE).equals(Long.MAX_VALUE)
+  it('returns MAX_VALUE when passed Infinity and overriden', () => {
+    assert.strictEqual(
+      getSafeLongFromTimestamp(Infinity, MAX_VALUE),
+      MAX_VALUE
     );
   });
 
   it("returns MAX_SAFE_DATE when passed very large numbers, outside of JavaScript's safely representable range", () => {
     assert.strictEqual(
-      getSafeLongFromTimestamp(Number.MAX_VALUE).toNumber(),
+      toNumber(getSafeLongFromTimestamp(Number.MAX_VALUE)),
       MAX_SAFE_DATE
     );
   });
@@ -47,19 +50,19 @@ describe('getSafeLongFromTimestamp', () => {
 
 describe('getTimestampFromLong', () => {
   it('returns zero when passed negative Long', () => {
-    assert.equal(getTimestampFromLong(Long.fromNumber(-1)), 0);
+    assert.equal(getTimestampFromLong(BigInt(-1)), 0);
   });
 
   it('returns zero when passed 0 Long', () => {
-    assert.equal(getTimestampFromLong(Long.fromNumber(0)), 0);
+    assert.equal(getTimestampFromLong(0n), 0);
   });
 
-  it('returns MAX_SAFE_DATE when passed Long.MAX_VALUE', () => {
-    assert.equal(getTimestampFromLong(Long.MAX_VALUE), MAX_SAFE_DATE);
+  it('returns MAX_SAFE_DATE when passed MAX_VALUE', () => {
+    assert.equal(getTimestampFromLong(MAX_VALUE), MAX_SAFE_DATE);
   });
 
   it('returns a normal number', () => {
-    assert.equal(getTimestampFromLong(Long.fromNumber(16)), 16);
+    assert.equal(getTimestampFromLong(16n), 16);
   });
 
   it('returns 0 for null value', () => {
@@ -73,35 +76,29 @@ describe('getCheckedTimestampFromLong', () => {
   });
 
   it('throws on negative Long', () => {
-    assert.throws(() => getCheckedTimestampFromLong(Long.fromNumber(-1)));
+    assert.throws(() => getCheckedTimestampFromLong(BigInt(-1)));
   });
 
-  it('throws on Long.MAX_VALUE', () => {
-    assert.throws(() => getCheckedTimestampFromLong(Long.MAX_VALUE));
+  it('throws on MAX_VALUE', () => {
+    assert.throws(() => getCheckedTimestampFromLong(MAX_VALUE));
   });
 
   it('does not throw otherwise', () => {
-    assert.equal(getCheckedTimestampFromLong(Long.fromNumber(16)), 16);
+    assert.equal(getCheckedTimestampFromLong(16n), 16);
   });
 });
 
 describe('getTimestampOrUndefinedFromLong', () => {
   it('returns undefined when passed 0 Long', () => {
-    assert.equal(
-      getTimestampOrUndefinedFromLong(Long.fromNumber(0)),
-      undefined
-    );
+    assert.equal(getTimestampOrUndefinedFromLong(0n), undefined);
   });
 
-  it('returns MAX_SAFE_DATE when passed Long.MAX_VALUE', () => {
-    assert.equal(
-      getTimestampOrUndefinedFromLong(Long.MAX_VALUE),
-      MAX_SAFE_DATE
-    );
+  it('returns MAX_SAFE_DATE when passed MAX_VALUE', () => {
+    assert.equal(getTimestampOrUndefinedFromLong(MAX_VALUE), MAX_SAFE_DATE);
   });
 
   it('returns a normal number', () => {
-    assert.equal(getTimestampOrUndefinedFromLong(Long.fromNumber(16)), 16);
+    assert.equal(getTimestampOrUndefinedFromLong(16n), 16);
   });
 
   it('returns undefined for null value', () => {
@@ -111,9 +108,7 @@ describe('getTimestampOrUndefinedFromLong', () => {
 
 describe('getCheckedTimestampOrUndefinedFromLong', () => {
   it('throws on negative Long', () => {
-    assert.throws(() =>
-      getCheckedTimestampOrUndefinedFromLong(Long.fromNumber(-1))
-    );
+    assert.throws(() => getCheckedTimestampOrUndefinedFromLong(-1n));
   });
 
   it('returns undefined on absent Long', () => {
@@ -121,13 +116,10 @@ describe('getCheckedTimestampOrUndefinedFromLong', () => {
   });
 
   it('returns undefined on zero Long', () => {
-    assert.equal(getCheckedTimestampOrUndefinedFromLong(Long.ZERO), undefined);
+    assert.equal(getCheckedTimestampOrUndefinedFromLong(0n), undefined);
   });
 
   it('returns a normal number', () => {
-    assert.equal(
-      getCheckedTimestampOrUndefinedFromLong(Long.fromNumber(16)),
-      16
-    );
+    assert.equal(getCheckedTimestampOrUndefinedFromLong(16n), 16);
   });
 });