58 lines
2.1 KiB
TypeScript
58 lines
2.1 KiB
TypeScript
import * as assert from 'node:assert'
|
|
|
|
export namespace Assert {
|
|
export function HasProperty<K extends PropertyKey>(value: unknown, key: K): asserts value is Record<K, unknown> {
|
|
if (typeof value === 'object' && value !== null && key in value) return
|
|
throw new Error(`Expected value to have property '${key as string}'`)
|
|
}
|
|
export function IsTrue(value: boolean): asserts value is true {
|
|
return assert.strictEqual(value, true)
|
|
}
|
|
export function IsFalse(value: boolean): asserts value is false {
|
|
return assert.strictEqual(value, false)
|
|
}
|
|
export function IsEqual(actual: unknown, expect: unknown) {
|
|
if (actual instanceof Uint8Array && expect instanceof Uint8Array) {
|
|
assert.equal(actual.length, expect.length)
|
|
for (let i = 0; i < actual.length; i++) assert.equal(actual[i], expect[i])
|
|
}
|
|
return assert.deepStrictEqual(actual, expect)
|
|
}
|
|
export function NotEqual(actual: unknown, expect: unknown) {
|
|
return assert.notEqual(actual, expect)
|
|
}
|
|
/** Asserts a numeric value is within range of the expected */
|
|
export function InRange(value: number, expect: number, range: number) {
|
|
if (Math.abs(value - expect) <= range) return
|
|
throw Error('Expected value to be in range')
|
|
}
|
|
let nextIdOrdinal = 0
|
|
export function NextId() {
|
|
return `$id-${nextIdOrdinal++}`
|
|
}
|
|
export function Throws(callback: Function) {
|
|
try {
|
|
callback()
|
|
} catch {
|
|
return
|
|
}
|
|
throw Error('Expected throw')
|
|
}
|
|
export async function ThrowsAsync(callback: Function) {
|
|
try {
|
|
await callback()
|
|
} catch {
|
|
return
|
|
}
|
|
throw Error('Expected throw')
|
|
}
|
|
export function IsInstanceOf<T extends new (...args: any[]) => any>(value: any, constructor: T): asserts value is InstanceType<T> {
|
|
if (value instanceof constructor) return
|
|
throw Error(`Value is not instance of ${constructor}`)
|
|
}
|
|
export function IsTypeOf<T extends 'string' | 'boolean' | 'number' | 'bigint' | 'symbol' | 'object' | 'function'>(value: any, type: T) {
|
|
if (typeof value === type) return
|
|
throw Error(`Value is not typeof ${type}`)
|
|
}
|
|
}
|