test("randomInt32-upper-bound-is-excluded", (t: AssertContext) => {
    // WARNING: No deterministric test (no seeded radom function)
    for (let i = 0; i < 100; i++) {
        t.is(randomInt32(0, 1), 0)
        t.is(randomInt32(-1, 0), -1)
    }
})

test("generateWithSameBase", (t: AssertContext) => {
    const expected = 5
    const tuple1: IdentifierTuple = new IdentifierTuple(42, 7, 8, 26)
    const tuple2: IdentifierTuple = IdentifierTuple.fromBase(tuple1, expected)

    t.true(tuple1.equalsBase(tuple2))
    t.is(tuple2.offset, expected)
})

test("two-noncontiguous-bases", (t: AssertContext) => {
    const replicaNumber = 0
    const clock = 1
    const id1: Identifier = new Identifier([new IdentifierTuple(0, replicaNumber, clock - 1, 0)])
    const id2: Identifier = new Identifier([new IdentifierTuple(42, 0, 0, 0)])

    const newId: Identifier = createBetweenPosition(id1, id2, replicaNumber, clock)

    t.is(id1.compareTo(newId), Ordering.Less)
    t.is(newId.compareTo(id2), Ordering.Less)
})

test("union-prepend-append", (t: AssertContext) => {
    const begin = 0
    const end = 5
    const idInterval = generateIdInterval(begin, end)

    const aBegin = -5
    const aEnd = 10
    const unionInterval = idInterval.union(aBegin, aEnd)

    const expectedBegin = aBegin
    const expectedEnd = aEnd

    t.is(unionInterval.begin, expectedBegin)
    t.is(unionInterval.end, expectedEnd)
})

function equalsBaseMacro (
    t: AssertContext,
    id1: Identifier, id2: Identifier, expected: boolean): void {

    const actual = id1.equalsBase(id2)
    t.is(actual, expected)
}

/**
 * Macro to check if equalsBase() returns the expected result
 */
function equalsBaseMacro (
    t: AssertContext,
    tuple: IdentifierTuple, other: IdentifierTuple,
    expected: boolean): void {

    const actual: boolean = tuple.equalsBase(other)
    t.is(actual, expected)
}