@jony_starc/rostime/dist/timeUtils.test.js

ROS (Robot Operating System) Time and Duration primitives and helper methods

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var rostime = require(".");
describe("isTime", function () {
    it("works", function () {
        expect(rostime.isTime(undefined)).toEqual(false);
        expect(rostime.isTime(false)).toEqual(false);
        expect(rostime.isTime(true)).toEqual(false);
        expect(rostime.isTime({})).toEqual(false);
        expect(rostime.isTime({ sec: 1 })).toEqual(false);
        expect(rostime.isTime({ nsec: 1 })).toEqual(false);
        expect(rostime.isTime({ sec: 1, nsec: 1, other: undefined })).toEqual(false);
        expect(rostime.isTime({ sec: 1, nsec: 1, other: 0 })).toEqual(false);
        expect(rostime.isTime({ sec: 0, nsec: 0 })).toEqual(true);
        expect(rostime.isTime({ sec: 1, nsec: 0 })).toEqual(true);
        expect(rostime.isTime({ sec: 1624947142, nsec: 42 })).toEqual(true);
    });
});
describe("toRFC3339String", function () {
    it("formats whole values correctly", function () {
        expect(rostime.toRFC3339String({ sec: 1, nsec: 0 })).toEqual("1970-01-01T00:00:01.000000000Z");
    });
    it("formats partial nanos", function () {
        expect(rostime.toRFC3339String({ sec: 102, nsec: 304 })).toEqual("1970-01-01T00:01:42.000000304Z");
        expect(rostime.toRFC3339String({ sec: 102, nsec: 99900000 })).toEqual("1970-01-01T00:01:42.099900000Z");
    });
    it("formats max nanos", function () {
        expect(rostime.toRFC3339String({ sec: 102, nsec: 999999999 })).toEqual("1970-01-01T00:01:42.999999999Z");
    });
    it("does not format negative times", function () {
        expect(function () { return rostime.toRFC3339String({ sec: -1, nsec: 0 }); }).toThrow();
    });
    it("interoperates with Date.parse", function () {
        var date = new Date(Date.UTC(2021, 8, 29, 18, 12, 8, 123));
        expect(Date.parse(rostime.toRFC3339String(rostime.fromDate(date)))).toEqual(+date);
    });
});
describe("fromRFC3339String", function () {
    it("parses nanosecond precision", function () {
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.0000000Z")).toEqual({
            sec: 0,
            nsec: 0,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.000000001Z")).toEqual({
            sec: 0,
            nsec: 1,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.0000000001Z")).toEqual({
            sec: 0,
            nsec: 0,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.100000000Z")).toEqual({
            sec: 0,
            nsec: 100000000,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.0123Z")).toEqual({
            sec: 0,
            nsec: 12300000,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.012345678Z")).toEqual({
            sec: 0,
            nsec: 12345678,
        });
    });
    it("rounds to nearest nanosecond", function () {
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.0123456789Z")).toEqual({
            sec: 0,
            nsec: 12345679,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.9999999991Z")).toEqual({
            sec: 0,
            nsec: 999999999,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:00.9999999995Z")).toEqual({
            sec: 1,
            nsec: 0,
        });
        expect(rostime.fromRFC3339String("1970-01-01T00:00:01.9999999995Z")).toEqual({
            sec: 2,
            nsec: 0,
        });
    });
    it("handles time zone offsets", function () {
        expect(rostime.fromRFC3339String("2021-09-29T18:12:08.123456789+00:00")).toEqual({
            sec: 1632939128,
            nsec: 123456789,
        });
        expect(rostime.fromRFC3339String("2021-09-29T18:12:08.123456789-00:00")).toEqual({
            sec: 1632939128,
            nsec: 123456789,
        });
        expect(rostime.fromRFC3339String("2021-09-29T18:12:08.123456789+00:01")).toEqual({
            sec: 1632939128 - 60,
            nsec: 123456789,
        });
        expect(rostime.fromRFC3339String("2021-09-29T18:12:08.123456789-00:01")).toEqual({
            sec: 1632939128 + 60,
            nsec: 123456789,
        });
        expect(rostime.fromRFC3339String("2021-09-29T18:12:08.123456789+10:09")).toEqual({
            sec: 1632939128 - (10 * 60 + 9) * 60,
            nsec: 123456789,
        });
        expect(rostime.fromRFC3339String("2021-09-29T18:12:08.123456789-10:09")).toEqual({
            sec: 1632939128 + (10 * 60 + 9) * 60,
            nsec: 123456789,
        });
    });
    it("interoperates with Date.toISOString", function () {
        var date = new Date(Date.UTC(2021, 8, 29, 18, 12, 8, 123));
        expect(rostime.fromRFC3339String(date.toISOString())).toEqual({
            sec: 1632939128,
            nsec: 123000000,
        });
    });
});
describe("toString", function () {
    it("formats whole values correctly", function () {
        expect(rostime.toString({ sec: 1, nsec: 0 })).toEqual("1.000000000");
    });
    it("formats partial nanos", function () {
        expect(rostime.toString({ sec: 102, nsec: 304 })).toEqual("102.000000304");
        expect(rostime.toString({ sec: 102, nsec: 99900000 })).toEqual("102.099900000");
    });
    it("formats max nanos", function () {
        expect(rostime.toString({ sec: 102, nsec: 999000000 })).toEqual("102.999000000");
    });
    it("does not format negative times", function () {
        expect(function () { return rostime.toString({ sec: -1, nsec: 0 }); }).toThrow();
    });
});
describe("fromString", function () {
    it("converts from nanoseconds to time", function () {
        var nanos1 = "1508410740.582458241";
        expect(rostime.fromString(nanos1)).toEqual({ sec: 1508410740, nsec: 582458241 });
        var nanos2 = "1508428043.155306000";
        expect(rostime.fromString(nanos2)).toEqual({ sec: 1508428043, nsec: 155306000 });
        expect(rostime.fromString("5001")).toEqual({ sec: 5001, nsec: 0 });
        var nanos3 = "".concat(1e10 + 1);
        expect(rostime.fromString(nanos3)).toEqual({ sec: 1e10 + 1, nsec: 0 });
        expect(rostime.fromString("0")).toEqual({ sec: 0, nsec: 0 });
        expect(rostime.fromString("1000.000")).toEqual({ sec: 1000, nsec: 0 });
    });
    it("does not convert invalid times", function () {
        expect(rostime.fromString("1000x00")).toBeUndefined();
        expect(rostime.fromString("1000 00")).toBeUndefined();
        expect(rostime.fromString("")).toBeUndefined();
        expect(rostime.fromString("-1")).toBeUndefined();
    });
    it("returns undefined if the input string is formatted incorrectly", function () {
        expect(rostime.fromString("")).toEqual(undefined);
        expect(rostime.fromString(".12121")).toEqual(undefined);
        expect(rostime.fromString(".")).toEqual(undefined);
    });
    it("returns the correct time", function () {
        expect(rostime.fromString("12121.")).toEqual({ sec: 12121, nsec: 0 });
        expect(rostime.fromString("1")).toEqual({ sec: 1, nsec: 0 });
        expect(rostime.fromString("1.")).toEqual({ sec: 1, nsec: 0 });
        expect(rostime.fromString("1.12")).toEqual({ sec: 1, nsec: 0.12e9 });
        expect(rostime.fromString("100.100")).toEqual({ sec: 100, nsec: 0.1e9 });
        expect(rostime.fromString("100")).toEqual({ sec: 100, nsec: 0 });
        // Full nanosecond timestamp
        expect(rostime.fromString("1.123456789")).toEqual({ sec: 1, nsec: 0.123456789e9 });
        // Too much precision
        expect(rostime.fromString("1.0123456789")).toEqual({ sec: 1, nsec: 0.012345679e9 });
        // Too much precision, round seconds up.
        expect(rostime.fromString("1.999999999999")).toEqual({ sec: 2, nsec: 0 });
    });
});
describe("toDate & fromDate", function () {
    it("converts to date and from date", function () {
        var totalSeconds = Math.round(Date.now() / 1000);
        var stamp = { sec: totalSeconds, nsec: 1000 };
        var now = new Date(totalSeconds * 1000);
        expect(rostime.toDate(stamp)).toEqual(now);
        expect(rostime.fromDate(now)).toEqual({ sec: totalSeconds, nsec: 0 });
        var nowPlus1ms = new Date(totalSeconds * 1000 + 1);
        expect(rostime.toDate({ sec: totalSeconds, nsec: 1 * 1e6 })).toEqual(nowPlus1ms);
        expect(rostime.fromDate(nowPlus1ms)).toEqual({
            sec: totalSeconds,
            nsec: 1000000,
        });
    });
    it("can be created from a date", function () {
        var date = new Date(1511798097280);
        var time = rostime.fromDate(date);
        expect(time.sec).toBe(Math.floor(1511798097280 / 1000));
        expect(time.nsec).toBe(280000000);
    });
    it("can convert to a date", function () {
        var date = new Date(1511798097280);
        var time = { sec: 1511798097, nsec: 280000000 };
        expect(rostime.toDate(time)).toEqual(date);
    });
});
describe("percentOf", function () {
    it("gives percentages correctly", function () {
        var start = { sec: 0, nsec: 0 };
        var end = { sec: 10, nsec: 0 };
        expect(rostime.percentOf(start, end, { sec: 5, nsec: 0 })).toEqual(0.5);
        expect(rostime.percentOf(start, end, { sec: 1, nsec: 0 })).toEqual(0.1);
        expect(rostime.percentOf(start, end, { sec: 0, nsec: 1e9 })).toEqual(0.1);
        expect(rostime.percentOf(start, end, { sec: 0, nsec: 1e7 })).toEqual(0.001);
        expect(rostime.percentOf(start, end, { sec: -1, nsec: 0 })).toEqual(-0.1);
    });
});
describe("interpolate", function () {
    it("works for zero-duration spans", function () {
        var t = { sec: 0, nsec: 0 };
        expect(rostime.interpolate(t, t, 0)).toEqual(t);
        expect(rostime.interpolate(t, t, -1)).toEqual(t);
        expect(rostime.interpolate(t, t, 1)).toEqual(t);
    });
    it("works for non-zero spans", function () {
        var start = { sec: 0, nsec: 0 };
        var end = { sec: 5, nsec: 0 };
        expect(rostime.interpolate(start, end, 0)).toEqual(start);
        expect(rostime.interpolate(start, end, 1)).toEqual(end);
        expect(rostime.interpolate(start, end, 0.5)).toEqual({ sec: 2, nsec: 5e8 });
        expect(rostime.interpolate(start, end, 2)).toEqual({ sec: 10, nsec: 0 });
    });
});
describe("fixTime", function () {
    it("works", function () {
        expect(rostime.fixTime({ sec: 0, nsec: 0 }, false)).toEqual({ sec: 0, nsec: 0 });
        expect(rostime.fixTime({ sec: 0, nsec: 1 }, false)).toEqual({ sec: 0, nsec: 1 });
        expect(rostime.fixTime({ sec: 0, nsec: 1e9 - 1 }, false)).toEqual({ sec: 0, nsec: 1e9 - 1 });
        expect(rostime.fixTime({ sec: 0, nsec: 1e9 }, false)).toEqual({ sec: 1, nsec: 0 });
        expect(rostime.fixTime({ sec: 0, nsec: 1e9 + 1 }, false)).toEqual({ sec: 1, nsec: 1 });
        expect(rostime.fixTime({ sec: 0, nsec: 2e9 }, false)).toEqual({ sec: 2, nsec: 0 });
        expect(rostime.fixTime({ sec: 0, nsec: 2e9 + 1 }, false)).toEqual({ sec: 2, nsec: 1 });
        expect(rostime.fixTime({ sec: 1, nsec: 3e9 + 5 }, false)).toEqual({ sec: 4, nsec: 5 });
        expect(rostime.fixTime({ sec: 0, nsec: 0 }, true)).toEqual({ sec: 0, nsec: 0 });
        expect(rostime.fixTime({ sec: 1, nsec: 3e9 + 5 }, true)).toEqual({ sec: 4, nsec: 5 });
        expect(rostime.fixTime({ sec: 0, nsec: -1 }, true)).toEqual({ sec: -1, nsec: 999999999 });
        expect(rostime.fixTime({ sec: 1, nsec: -1 }, true)).toEqual({ sec: 0, nsec: 999999999 });
        expect(rostime.fixTime({ sec: -1, nsec: 0 }, true)).toEqual({ sec: -1, nsec: 0 });
        expect(rostime.fixTime({ sec: -1, nsec: -1 }, true)).toEqual({ sec: -2, nsec: 999999999 });
        expect(rostime.fixTime({ sec: -2, nsec: 0 }, true)).toEqual({ sec: -2, nsec: 0 });
        expect(rostime.fixTime({ sec: -2, nsec: 1 }, true)).toEqual({ sec: -2, nsec: 1 });
        expect(rostime.fixTime({ sec: -2, nsec: -1 }, true)).toEqual({ sec: -3, nsec: 999999999 });
    });
});
describe("add", function () {
    var testAddition = function (left, right, expected) {
        expect(rostime.add(left, right)).toEqual(expected);
        expect(rostime.add(right, left)).toEqual(expected);
    };
    // eslint-disable-next-line jest/expect-expect
    it("can add two times together", function () {
        testAddition({ sec: 0, nsec: 0 }, { sec: 0, nsec: 0 }, { sec: 0, nsec: 0 });
        testAddition({ sec: 1, nsec: 100 }, { sec: 2, nsec: 200 }, { sec: 3, nsec: 300 });
        testAddition({ sec: 0, nsec: 1e9 - 1 }, { sec: 0, nsec: 1 }, { sec: 1, nsec: 0 });
        testAddition({ sec: 0, nsec: 1e9 - 1 }, { sec: 0, nsec: 101 }, { sec: 1, nsec: 100 });
        testAddition({ sec: 3, nsec: 0 }, { sec: 0, nsec: 2 * -1e9 }, { sec: 1, nsec: 0 });
        testAddition({ sec: 1, nsec: 1 }, { sec: 0, nsec: -2 }, { sec: 0, nsec: 1e9 - 1 });
        testAddition({ sec: 1, nsec: 1 }, { sec: 0, nsec: -2 }, { sec: 0, nsec: 1e9 - 1 });
        testAddition({ sec: 3, nsec: 1 }, { sec: -2, nsec: -2 }, { sec: 0, nsec: 1e9 - 1 });
        testAddition({ sec: 1, nsec: 0 }, { sec: 0, nsec: -1e9 }, { sec: 0, nsec: 0 });
        testAddition({ sec: 3, nsec: 1 }, { sec: 1, nsec: -2 }, { sec: 3, nsec: 1e9 - 1 });
        testAddition({ sec: 3, nsec: 0 }, { sec: 0, nsec: -(2 * 1e9) + 1 }, { sec: 1, nsec: 1 });
        testAddition({ sec: 10, nsec: 0 }, { sec: 10, nsec: 10 * 1e9 }, { sec: 30, nsec: 0 });
        testAddition({ sec: 10, nsec: 0 }, { sec: 10, nsec: -10 * 1e9 }, { sec: 10, nsec: 0 });
        testAddition({ sec: 0, nsec: 0 }, { sec: 10, nsec: -10 * 1e9 }, { sec: 0, nsec: 0 });
    });
    it("throws when addition results in negative time", function () {
        expect(function () { return rostime.add({ sec: 0, nsec: 0 }, { sec: -1, nsec: 0 }); }).toThrow();
        expect(function () { return rostime.add({ sec: 0, nsec: 0 }, { sec: 0, nsec: -1 }); }).toThrow();
    });
});
describe("subtractTimes", function () {
    it("subtracts times", function () {
        expect(rostime.subtract({ sec: 1, nsec: 1 }, { sec: 1, nsec: 1 })).toEqual({ sec: 0, nsec: 0 });
        expect(rostime.subtract({ sec: 1, nsec: 2 }, { sec: 2, nsec: 1 })).toEqual({
            sec: -1,
            nsec: 1,
        });
        expect(rostime.subtract({ sec: 5, nsec: 100 }, { sec: 2, nsec: 10 })).toEqual({
            sec: 3,
            nsec: 90,
        });
        expect(rostime.subtract({ sec: 1, nsec: 1e8 }, { sec: 0, nsec: 5e8 })).toEqual({
            sec: 0,
            nsec: 600000000,
        });
        expect(rostime.subtract({ sec: 1, nsec: 0 }, { sec: 0, nsec: 1e9 - 1 })).toEqual({
            sec: 0,
            nsec: 1,
        });
        expect(rostime.subtract({ sec: 0, nsec: 0 }, { sec: 0, nsec: 1 })).toEqual({
            sec: -1,
            nsec: 1e9 - 1,
        });
    });
});
describe("toNanoSec", function () {
    it("works", function () {
        expect(rostime.toNanoSec({ sec: 0, nsec: 1 })).toEqual(1n);
        expect(rostime.toNanoSec({ sec: 1, nsec: 0 })).toEqual(BigInt(1e9));
        expect(rostime.toNanoSec({ sec: 1, nsec: 1 })).toEqual(BigInt(1e9) + 1n);
        expect(rostime.toNanoSec({ sec: 2, nsec: 0 })).toEqual(BigInt(2e9));
        expect(rostime.toNanoSec({ sec: 2, nsec: 1 })).toEqual(BigInt(2e9) + 1n);
    });
});
describe("toMicroSec", function () {
    it("works", function () {
        expect(rostime.toMicroSec({ sec: 0, nsec: 1 })).toEqual(0.001);
        expect(rostime.toMicroSec({ sec: 0, nsec: 999 })).toEqual(0.999);
        expect(rostime.toMicroSec({ sec: 0, nsec: 1000 })).toEqual(1);
        expect(rostime.toMicroSec({ sec: 1, nsec: 0 })).toEqual(1e6);
        expect(rostime.toMicroSec({ sec: 1, nsec: 1 })).toEqual(1000000.001);
        expect(rostime.toMicroSec({ sec: 2, nsec: 0 })).toEqual(2e6);
        expect(rostime.toMicroSec({ sec: 2, nsec: 1 })).toEqual(2000000.001);
    });
});
describe("toSec", function () {
    it("works", function () {
        expect(rostime.toSec({ sec: 1, nsec: 0 })).toBe(1);
        expect(rostime.toSec({ sec: 1, nsec: 1 })).toBe(1.000000001);
        expect(rostime.toSec({ sec: 1, nsec: 999999999 })).toBe(1.999999999);
        expect(rostime.toSec({ sec: 1, nsec: 1000000000 })).toBe(2);
    });
});
describe("fromSec", function () {
    it("handles positive values", function () {
        expect(rostime.fromSec(1)).toEqual({ sec: 1, nsec: 0 });
        expect(rostime.fromSec(1.000000001)).toEqual({ sec: 1, nsec: 1 });
        expect(rostime.fromSec(1.999999999)).toEqual({ sec: 1, nsec: 999999999 });
        expect(rostime.fromSec(1.9999999994)).toEqual({ sec: 1, nsec: 999999999 });
        expect(rostime.fromSec(1.999999999999)).toEqual({ sec: 2, nsec: 0 });
        expect(rostime.fromSec(2)).toEqual({ sec: 2, nsec: 0 });
    });
    it("handles negative values", function () {
        expect(rostime.fromSec(-1)).toEqual({ sec: -1, nsec: 0 });
        expect(rostime.fromSec(-1.000000001)).toEqual({ sec: -1, nsec: -1 });
        expect(rostime.fromSec(-1.999999999)).toEqual({ sec: -1, nsec: -999999999 });
        expect(rostime.fromSec(-1.9999999994)).toEqual({ sec: -1, nsec: -999999999 });
        expect(rostime.fromSec(-1.999999999999)).toEqual({ sec: -2, nsec: -0 });
        expect(rostime.fromSec(-2)).toEqual({ sec: -2, nsec: 0 });
    });
});
describe("fromNanoSec", function () {
    it("works", function () {
        expect(rostime.fromNanoSec(0n)).toEqual({ sec: 0, nsec: 0 });
        expect(rostime.fromNanoSec(1n)).toEqual({ sec: 0, nsec: 1 });
        expect(rostime.fromNanoSec(10n)).toEqual({ sec: 0, nsec: 10 });
        expect(rostime.fromNanoSec(BigInt(1e9))).toEqual({ sec: 1, nsec: 0 });
        expect(rostime.fromNanoSec(BigInt(1e9) + 1n)).toEqual({ sec: 1, nsec: 1 });
        expect(rostime.fromNanoSec(BigInt(2e9))).toEqual({ sec: 2, nsec: 0 });
        expect(rostime.fromNanoSec(BigInt(2e9) + 1n)).toEqual({ sec: 2, nsec: 1 });
    });
});
describe("toMillis", function () {
    it("works", function () {
        expect(rostime.toMillis({ sec: 0, nsec: 0 }, false)).toEqual(0);
        expect(rostime.toMillis({ sec: 0, nsec: 0 }, true)).toEqual(0);
        expect(rostime.toMillis({ sec: 0, nsec: 1 }, false)).toEqual(0);
        expect(rostime.toMillis({ sec: 0, nsec: 1 }, true)).toEqual(1);
        expect(rostime.toMillis({ sec: 0, nsec: 1e6 - 1 }, false)).toEqual(0);
        expect(rostime.toMillis({ sec: 0, nsec: 1e6 - 1 }, true)).toEqual(1);
        expect(rostime.toMillis({ sec: 0, nsec: 1e6 }, false)).toEqual(1);
        expect(rostime.toMillis({ sec: 0, nsec: 1e6 }, true)).toEqual(1);
        expect(rostime.toMillis({ sec: 1, nsec: 0 }, false)).toEqual(1000);
        expect(rostime.toMillis({ sec: 1, nsec: 0 }, true)).toEqual(1000);
        expect(rostime.toMillis({ sec: 1, nsec: 1 }, false)).toEqual(1000);
        expect(rostime.toMillis({ sec: 1, nsec: 1 }, true)).toEqual(1001);
        expect(rostime.toMillis({ sec: 2, nsec: 0 }, false)).toEqual(2000);
        expect(rostime.toMillis({ sec: 2, nsec: 0 }, true)).toEqual(2000);
        expect(rostime.toMillis({ sec: 2, nsec: 1 }, false)).toEqual(2000);
        expect(rostime.toMillis({ sec: 2, nsec: 1 }, true)).toEqual(2001);
    });
});
describe("fromMillis", function () {
    it("handles positive values", function () {
        expect(rostime.fromMillis(1)).toEqual({ sec: 0, nsec: 1000000 });
        expect(rostime.fromMillis(1000)).toEqual({ sec: 1, nsec: 0 });
        expect(rostime.fromMillis(2000000000005)).toEqual({ sec: 2000000000, nsec: 5000000 });
    });
    it("handles negative values", function () {
        expect(rostime.fromMillis(-1)).toEqual({ sec: -0, nsec: -1000000 });
        expect(rostime.fromMillis(-1000)).toEqual({ sec: -1, nsec: 0 });
    });
});
describe("fromMicros", function () {
    it("handles positive values", function () {
        expect(rostime.fromMicros(1)).toEqual({ sec: 0, nsec: 1000 });
        expect(rostime.fromMicros(1000)).toEqual({ sec: 0, nsec: 1000000 });
        expect(rostime.fromMicros(1000000)).toEqual({ sec: 1, nsec: 0 });
        expect(rostime.fromMicros(2000000000000005)).toEqual({ sec: 2000000000, nsec: 5000 });
    });
    it("handles negative values", function () {
        expect(rostime.fromMicros(-1)).toEqual({ sec: -0, nsec: -1000 });
        expect(rostime.fromMicros(-1000)).toEqual({ sec: -0, nsec: -1000000 });
        expect(rostime.fromMicros(-1000000)).toEqual({ sec: -1, nsec: 0 });
    });
});
describe("clampTime", function () {
    var start = { sec: 0, nsec: 100 };
    var end = { sec: 100, nsec: 100 };
    it("returns the clamped time", function () {
        expect(rostime.clampTime({ sec: 0, nsec: 99 }, start, end)).toEqual(start);
        expect(rostime.clampTime({ sec: 0, nsec: 101 }, start, end)).toEqual({ sec: 0, nsec: 101 });
        expect(rostime.clampTime({ sec: 100, nsec: 102 }, start, end)).toEqual(end);
    });
});
describe("isTimeInRangeInclusive", function () {
    var start = { sec: 0, nsec: 100 };
    var end = { sec: 100, nsec: 100 };
    it("returns whether time is between start and end, inclusive", function () {
        expect(rostime.isTimeInRangeInclusive(start, start, end)).toEqual(true);
        expect(rostime.isTimeInRangeInclusive(end, start, end)).toEqual(true);
        expect(rostime.isTimeInRangeInclusive({ sec: 50, nsec: 50 }, start, end)).toEqual(true);
        expect(rostime.isTimeInRangeInclusive({ sec: 0, nsec: 99 }, start, end)).toEqual(false);
        expect(rostime.isTimeInRangeInclusive({ sec: 100, nsec: 101 }, start, end)).toEqual(false);
    });
});
describe("comparison", function () {
    it("can sort by compare", function () {
        var times = [
            { sec: 1, nsec: 1 },
            { sec: 0, nsec: 0 },
            { sec: 1, nsec: 0 },
            { sec: 0, nsec: 1 },
        ];
        times.sort(rostime.compare);
        expect(times).toEqual([
            { sec: 0, nsec: 0 },
            { sec: 0, nsec: 1 },
            { sec: 1, nsec: 0 },
            { sec: 1, nsec: 1 },
        ]);
    });
    it("has lessThan functionality", function () {
        var min = { sec: 0, nsec: 0 };
        var oneNano = { sec: 0, nsec: 1 };
        var max = { sec: 1, nsec: 1 };
        expect(rostime.isLessThan(min, min)).toBe(false);
        expect(rostime.isLessThan(max, min)).toBe(false);
        expect(rostime.isLessThan(oneNano, min)).toBe(false);
        expect(rostime.isLessThan(min, oneNano)).toBe(true);
        expect(rostime.isLessThan(min, max)).toBe(true);
    });
    it("has greaterThan functionality", function () {
        var min = { sec: 0, nsec: 0 };
        var oneNano = { sec: 0, nsec: 1 };
        var max = { sec: 1, nsec: 1 };
        expect(rostime.isGreaterThan(min, min)).toBe(false);
        expect(rostime.isGreaterThan(max, min)).toBe(true);
        expect(rostime.isGreaterThan(oneNano, min)).toBe(true);
        expect(rostime.isGreaterThan(min, oneNano)).toBe(false);
        expect(rostime.isGreaterThan(min, max)).toBe(false);
    });
});
describe("areEqual", function () {
    it("tests for sameness", function () {
        var min = { sec: 0, nsec: 0 };
        var min2 = { sec: 0, nsec: 0 };
        var oneNano = { sec: 0, nsec: 1 };
        expect(min === min2).toBe(false);
        expect(rostime.areEqual(min, min2)).toBe(true);
        expect(rostime.areEqual(min, oneNano)).toBe(false);
    });
});