import { Iso8601 } from "../../Source/Cesium.js";
|
import { JulianDate } from "../../Source/Cesium.js";
|
import { Math as CesiumMath } from "../../Source/Cesium.js";
|
import { TimeConstants } from "../../Source/Cesium.js";
|
import { TimeStandard } from "../../Source/Cesium.js";
|
|
describe("Core/JulianDate", function () {
|
// All exact Julian Dates found using NASA's Time Conversion Tool: http://ssd.jpl.nasa.gov/tc.cgi
|
it("Construct a default date", function () {
|
var defaultDate = new JulianDate();
|
expect(defaultDate.dayNumber).toEqual(0);
|
expect(defaultDate.secondsOfDay).toEqual(10);
|
});
|
|
it("Construct a date with fractional day", function () {
|
var julianDate = new JulianDate(2448257.75, 0, TimeStandard.UTC);
|
var expected = new JulianDate(2448257, 64826, TimeStandard.TAI);
|
expect(julianDate).toEqual(expected);
|
});
|
|
it("Construct a date at the current time", function () {
|
// Default constructing a date uses 'now'. Unfortunately,
|
// there's no way to know exactly what that time will be, so we
|
// give ourselves a 5 second epsilon as a hack to avoid possible
|
// race conditions. In reality, it might be better to just omit
|
// a check in this test, since if this breaks, tons of other stuff
|
// will as well.
|
var defaultDate = JulianDate.now();
|
var dateNow = JulianDate.fromDate(new Date());
|
expect(defaultDate.equalsEpsilon(dateNow, 5)).toEqual(true);
|
});
|
|
it("Construct a date from basic TAI components", function () {
|
var dayNumber = 12;
|
var seconds = 12.5;
|
var timeStandard = TimeStandard.TAI;
|
var julianDate = new JulianDate(dayNumber, seconds, timeStandard);
|
expect(julianDate.dayNumber).toEqual(dayNumber);
|
expect(julianDate.secondsOfDay).toEqual(seconds);
|
});
|
|
it("clone works without result parameter", function () {
|
var julianDate = JulianDate.now();
|
var returnedResult = julianDate.clone();
|
expect(returnedResult).toEqual(julianDate);
|
expect(returnedResult).not.toBe(julianDate);
|
});
|
|
it("clone works with result parameter", function () {
|
var julianDate = new JulianDate(1, 2);
|
var result = JulianDate.now();
|
var returnedResult = julianDate.clone(result);
|
expect(returnedResult).toBe(result);
|
expect(returnedResult).not.toBe(julianDate);
|
expect(returnedResult).toEqual(julianDate);
|
});
|
|
it("Construct a date from UTC components just before a leap second", function () {
|
var expected = new JulianDate(2443874, 43216, TimeStandard.TAI);
|
var julianDate = new JulianDate(2443874, 43199.0, TimeStandard.UTC);
|
expect(julianDate.dayNumber).toEqual(expected.dayNumber);
|
expect(julianDate.secondsOfDay).toEqual(expected.secondsOfDay);
|
});
|
|
it("Construct a date from UTC components equivalent to a LeapSecond table entry", function () {
|
var expected = new JulianDate(2443874, 43218, TimeStandard.TAI);
|
var julianDate = new JulianDate(2443874, 43200.0, TimeStandard.UTC);
|
expect(julianDate.dayNumber).toEqual(expected.dayNumber);
|
expect(julianDate.secondsOfDay).toEqual(expected.secondsOfDay);
|
});
|
|
it("Construct a date from UTC components just after a leap second", function () {
|
var expected = new JulianDate(2443874, 43219, TimeStandard.TAI);
|
var julianDate = new JulianDate(2443874, 43201.0, TimeStandard.UTC);
|
expect(julianDate.dayNumber).toEqual(expected.dayNumber);
|
expect(julianDate.secondsOfDay).toEqual(expected.secondsOfDay);
|
});
|
|
it("Construct a date from basic components with more seconds than a day", function () {
|
var dayNumber = 12;
|
var seconds = 86401;
|
var timeStandard = TimeStandard.TAI;
|
var julianDate = new JulianDate(dayNumber, seconds, timeStandard);
|
expect(julianDate.dayNumber).toEqual(13);
|
expect(julianDate.secondsOfDay).toEqual(1);
|
});
|
|
it("Construct a date from basic components with negative seconds in a day", function () {
|
var dayNumber = 12;
|
var seconds = -1;
|
var timeStandard = TimeStandard.TAI;
|
var julianDate = new JulianDate(dayNumber, seconds, timeStandard);
|
expect(julianDate.dayNumber).toEqual(11);
|
expect(julianDate.secondsOfDay).toEqual(86399);
|
});
|
|
it("Construct a date from basic components with partial day and seconds in a day", function () {
|
var dayNumber = 12.5;
|
var seconds = -1;
|
var timeStandard = TimeStandard.TAI;
|
var julianDate = new JulianDate(dayNumber, seconds, timeStandard);
|
expect(julianDate.dayNumber).toEqual(12);
|
expect(julianDate.secondsOfDay).toEqual(43199);
|
});
|
|
it("Construct a date with default time standard", function () {
|
var dayNumber = 12;
|
var seconds = 12.5;
|
var julianDateDefault = new JulianDate(dayNumber, seconds);
|
var julianDateUtc = new JulianDate(dayNumber, seconds, TimeStandard.UTC);
|
expect(julianDateDefault).toEqual(julianDateUtc);
|
});
|
|
it("Construct a date from a JavaScript Date (1)", function () {
|
var date = new Date("January 1, 1991 06:00:00 UTC");
|
var julianDate = JulianDate.fromDate(date);
|
expect(julianDate.dayNumber).toEqual(2448257);
|
expect(julianDate.secondsOfDay).toEqual(64826);
|
});
|
|
it("Construct a date from a JavaScript Date (2)", function () {
|
var date = new Date("July 4, 2011 12:00:00 UTC");
|
var julianDate = JulianDate.fromDate(date);
|
expect(julianDate.dayNumber).toEqual(2455747);
|
expect(julianDate.secondsOfDay).toEqual(34);
|
});
|
|
it("Construct a date from a JavaScript Date (3)", function () {
|
var date = new Date("December 31, 2021 18:00:00 UTC");
|
var julianDate = JulianDate.fromDate(date);
|
expect(julianDate.dayNumber).toEqual(2459580);
|
expect(julianDate.secondsOfDay).toEqual(21637);
|
});
|
|
it("Construct a date from a JavaScript Date (4)", function () {
|
var jsDate = new Date("September 1, 2011 12:00:00 UTC");
|
var julianDate = JulianDate.fromDate(jsDate);
|
expect(julianDate.dayNumber).toEqual(2455806);
|
expect(julianDate.secondsOfDay).toEqual(34);
|
});
|
|
it("Construct a date from a JavaScript Date (5)", function () {
|
var jsDate = new Date("11/17/2039 12:00:00 AM UTC");
|
var julianDate = JulianDate.fromDate(jsDate);
|
expect(julianDate.dayNumber).toEqual(2466109);
|
expect(julianDate.secondsOfDay).toEqual(43237);
|
});
|
|
it("Fail to construct from an undefined JavaScript Date", function () {
|
expect(function () {
|
return JulianDate.fromDate(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("Fail to construct from an invalid JavaScript Date", function () {
|
expect(function () {
|
return JulianDate.fromDate(new Date(Date.parse("garbage")));
|
}).toThrowDeveloperError();
|
});
|
|
it("Construct from ISO8601 calendar date, basic format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2009, 7, 1)));
|
var computedDate = JulianDate.fromIso8601("20090801");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 calendar date, extended format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2009, 7, 1)));
|
var computedDate = JulianDate.fromIso8601("2009-08-01");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 calendar date on Feb 29th, basic format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2000, 1, 29)));
|
var computedDate = JulianDate.fromIso8601("20000229");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 calendar date on Feb 29th, extended format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2000, 1, 29)));
|
var computedDate = JulianDate.fromIso8601("2000-02-29");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 ordinal date, basic format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(1985, 3, 12)));
|
var computedDate = JulianDate.fromIso8601("1985102");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 ordinal date, extended format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(1985, 3, 12)));
|
var computedDate = JulianDate.fromIso8601("1985-102");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct an ISO8601 ordinal date on a leap year", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2000, 11, 31)));
|
var computedDate = JulianDate.fromIso8601("2000-366");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 week date, basic format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(1985, 3, 12)));
|
var computedDate = JulianDate.fromIso8601("1985W155");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 week date, extended format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2008, 8, 27)));
|
var computedDate = JulianDate.fromIso8601("2008-W39-6");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 calendar week date, basic format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(1985, 3, 7)));
|
var computedDate = JulianDate.fromIso8601("1985W15");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 calendar week date, extended format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2008, 8, 21)));
|
var computedDate = JulianDate.fromIso8601("2008-W39");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
//Note, there is no 'extended format' for calendar month because eliminating the
|
//would confuse is with old YYMMDD dates
|
it("Construct from an ISO8601 calendar month, basic format", function () {
|
var expectedDate = JulianDate.fromDate(new Date(Date.UTC(1985, 3, 1)));
|
var computedDate = JulianDate.fromIso8601("1985-04");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time, basic format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 25))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T123025Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time, extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 25))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12:30:25Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time fractional seconds, basic format", function () {
|
//Date is only accurate to milliseconds, while JulianDate, much more so. The below date gets
|
//rounded to 513, so we need to construct a JulianDate directly.
|
//var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2009, 7, 1, 12, 30, 25, 5125423)));
|
var expectedDate = new JulianDate(2455045, 1825.5125423, TimeStandard.UTC);
|
var computedDate = JulianDate.fromIso8601("20090801T123025.5125423Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time fractional seconds, extended format", function () {
|
//Date is only accurate to milliseconds, while JulianDate, much more so. The below date gets
|
//rounded to 513, so we need to construct a JulianDate directly.
|
var expectedDate = new JulianDate(2455045, 1825.5125423, TimeStandard.UTC);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12:30:25.5125423Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it('Construct from ISO8601 UTC calendar date and time fractional seconds, basic format, "," instead of "."', function () {
|
//Date is only accurate to milliseconds, while JulianDate, much more so. The below date gets
|
//rounded to 513, so we need to construct a JulianDate directly.
|
//var expectedDate = JulianDate.fromDate(new Date(Date.UTC(2009, 7, 1, 12, 30, 25, 5125423)));
|
var expectedDate = new JulianDate(2455045, 1825.5125423, TimeStandard.UTC);
|
var computedDate = JulianDate.fromIso8601("20090801T123025,5125423Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it('Construct from ISO8601 UTC calendar date and time fractional seconds, extended format, "," instead of "."', function () {
|
//Date is only accurate to milliseconds, while JulianDate, much more so. The below date gets
|
//rounded to 513, so we need to construct a JulianDate directly.
|
var expectedDate = new JulianDate(2455045, 1825.5125423, TimeStandard.UTC);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12:30:25,5125423Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time no seconds, basic format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T1230Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time no seconds, extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12:30Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time fractional minutes, basic format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 30))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T1230.5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time fractional minutes, extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 30))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12:30.5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it('Construct from ISO8601 UTC calendar date and time fractional minutes, basic format, "," instead of "."', function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 30))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T1230,5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it('Construct from ISO8601 UTC calendar date and time fractional minutes, extended format, "," instead of "."', function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 30))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12:30,5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time no minutes/seconds, basic format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 0, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T12Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time no minutes/seconds, extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 0, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time fractional hours, basic format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T12.5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 UTC calendar date and time fractional hours, extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12.5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it('Construct from ISO8601 UTC calendar date and time fractional hours, basic format, "," instead of "."', function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T12,5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it('Construct from ISO8601 UTC calendar date and time fractional hours, extended format, "," instead of "."', function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T12,5Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 UTC calendar date and time on a leap second", function () {
|
var computedDate = JulianDate.fromIso8601("2008-12-31T23:59:60Z");
|
var expectedDate = new JulianDate(2454832, 43233, TimeStandard.TAI);
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 UTC calendar date and time within a leap second", function () {
|
var computedDate = JulianDate.fromIso8601("2008-12-31T23:59:60.123456789Z");
|
var expectedDate = new JulianDate(
|
2454832,
|
43233.123456789,
|
TimeStandard.TAI
|
);
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date and time on a leap second 1 hour behind UTC", function () {
|
var computedDate = JulianDate.fromIso8601("2008-12-31T22:59:60-01");
|
var expectedDate = new JulianDate(2454832, 43233, TimeStandard.TAI);
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date and time on a leap second 1 hour ahead of UTC", function () {
|
var computedDate = JulianDate.fromIso8601("2009-01-01T00:59:60+01");
|
var expectedDate = new JulianDate(2454832, 43233, TimeStandard.TAI);
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 calendar date and time using 24:00:00 midnight notation", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 2, 0, 0, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T24:00:00Z");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with UTC offset that crosses into previous month", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(1985, 2, 31, 23, 59, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("1985-04-01T00:59:00+01");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with UTC offset that crosses into next month", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(1985, 3, 1, 0, 59, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("1985-03-31T23:59:00-01");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with UTC offset that crosses into next year", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2008, 11, 31, 23, 0, 0))
|
);
|
var julianDate = JulianDate.fromIso8601("2009-01-01T01:00:00+02");
|
expect(julianDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with UTC offset that crosses into previous year", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 0, 1, 1, 0, 0))
|
);
|
var julianDate = JulianDate.fromIso8601("2008-12-31T23:00:00-02");
|
expect(julianDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with UTC offset", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2008, 10, 10, 12, 0, 0))
|
);
|
var julianDate = JulianDate.fromIso8601("2008-11-10T14:00:00+02");
|
expect(julianDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with UTC offset in extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2008, 10, 10, 11, 30, 0))
|
);
|
var julianDate = JulianDate.fromIso8601("2008-11-10T14:00:00+02:30");
|
expect(julianDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with zero UTC offset in extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2008, 10, 10, 14, 0, 0))
|
);
|
var julianDate = JulianDate.fromIso8601("2008-11-10T14:00:00+00:00");
|
expect(julianDate).toEqual(expectedDate);
|
});
|
|
it("Construct from an ISO8601 local calendar date with zero UTC offset in extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2008, 10, 10, 14, 0, 0))
|
);
|
var julianDate = JulianDate.fromIso8601("2008-11-10T14:00:00+00");
|
expect(julianDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 local calendar date and time with no seconds and UTC offset in basic format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("20090801T0730-0500");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Construct from ISO8601 local calendar date and time with no seconds and UTC offset in extended format", function () {
|
var expectedDate = JulianDate.fromDate(
|
new Date(Date.UTC(2009, 7, 1, 12, 30, 0))
|
);
|
var computedDate = JulianDate.fromIso8601("2009-08-01T07:30-05:00");
|
expect(computedDate).toEqual(expectedDate);
|
});
|
|
it("Fails to construct an ISO8601 ordinal date with day less than 1", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-000");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 ordinal date with day more than 365 on non-leap year", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2001-366");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct ISO8601 UTC calendar date of invalid YYMMDD format", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("200905");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct a complete ISO8601 date missing T delimeter", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-08-0112:30.5Z");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct a complete ISO8601 date with delimeter other than T", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-08-01Q12:30.5Z");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date from undefined", function () {
|
expect(function () {
|
return JulianDate.fromIso8601(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 from complete garbage", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("this is not a date");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date from a valid ISO8601 interval", function () {
|
expect(function () {
|
return JulianDate.fromIso8601(
|
"2007-03-01T13:00:00Z/2008-05-11T15:30:00Z"
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct from an ISO8601 with too many year digits", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("20091-05-19");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct from an ISO8601 with too many month digits", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-100-19");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct from an ISO8601 with more than 12 months", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-13-19");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct from an ISO8601 with less than 1 months", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-00-19");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 January date with more than 31 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-01-32");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 Febuary date with more than 28 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-02-29");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 Febuary leap year date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-02-30");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 March date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-03-32");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 April date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-04-31");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 May date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-05-32");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 June date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-06-31");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 July date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-07-32");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 August date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-08-32");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 September date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-09-31");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 October date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-10-32");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 November date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-11-31");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 December date with more than 29 days", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-32");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date with more than 24 hours (extra seconds)", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T24:00:01");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date with more than 24 hours (extra minutes)", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T24:01:00");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date with more than 59 minutes", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T12:60");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date with more than 60 seconds", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T12:59:61");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct from an ISO8601 with less than 1 day", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009-01-00");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct from an ISO8601 with too many dashes", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2009--01-01");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct from an ISO8601 with garbage offset", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T12:59:23ZZ+-050708::1234");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date with more than one decimal place", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T12:59:22..2");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 calendar date mixing basic and extended format", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("200108-01");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 calendar date mixing basic and extended format", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2001-0801");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 calendar week mixing basic and extended format", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2008-W396");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 calendar week mixing basic and extended format", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2008W39-6");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 date with trailing -", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2001-");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 time mixing basic and extended format", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T22:0100");
|
}).toThrowDeveloperError();
|
});
|
|
it("Fails to construct an ISO8601 time mixing basic and extended format", function () {
|
expect(function () {
|
return JulianDate.fromIso8601("2000-12-15T2201:00");
|
}).toThrowDeveloperError();
|
});
|
|
it("toDate works when using TAI", function () {
|
var julianDateTai = new JulianDate(2455927.157772, 0, TimeStandard.UTC);
|
var javascriptDate = JulianDate.toDate(julianDateTai);
|
expect(javascriptDate.getUTCFullYear()).toEqual(2011);
|
expect(javascriptDate.getUTCMonth()).toEqual(11);
|
expect(javascriptDate.getUTCDate()).toEqual(31);
|
expect(javascriptDate.getUTCHours()).toEqual(15);
|
expect(javascriptDate.getUTCMinutes()).toEqual(47);
|
expect(javascriptDate.getUTCSeconds()).toEqual(11);
|
expect(javascriptDate.getUTCMilliseconds()).toEqualEpsilon(500, 10);
|
});
|
|
it("toDate works a second before a leap second", function () {
|
var expectedDate = new Date("6/30/1997 11:59:59 PM UTC");
|
var date = JulianDate.toDate(
|
new JulianDate(2450630, 43229.0, TimeStandard.TAI)
|
);
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toDate works on a leap second", function () {
|
var expectedDate = new Date("6/30/1997 11:59:59 PM UTC");
|
var date = JulianDate.toDate(
|
new JulianDate(2450630, 43230.0, TimeStandard.TAI)
|
);
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toDate works a second after a leap second", function () {
|
var expectedDate = new Date("7/1/1997 12:00:00 AM UTC");
|
var date = JulianDate.toDate(
|
new JulianDate(2450630, 43231.0, TimeStandard.TAI)
|
);
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toDate works on date before any leap seconds", function () {
|
var expectedDate = new Date("09/10/1968 12:00:00 AM UTC");
|
var date = JulianDate.toDate(
|
new JulianDate(2440109, 43210.0, TimeStandard.TAI)
|
);
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toDate works on date later than all leap seconds", function () {
|
var expectedDate = new Date("11/17/2039 12:00:00 AM UTC");
|
var date = JulianDate.toDate(
|
new JulianDate(2466109, 43237.0, TimeStandard.TAI)
|
);
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 works a second before a leap second", function () {
|
var expectedDate = "1997-06-30T23:59:59Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate));
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 works on a leap second", function () {
|
var expectedDate = "1997-06-30T23:59:60Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate));
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 works a second after a leap second", function () {
|
var expectedDate = "1997-07-01T00:00:00Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate));
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 works on date before any leap seconds", function () {
|
var expectedDate = "1968-09-10T00:00:00Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate));
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 works on date later than all leap seconds", function () {
|
var expectedDate = "2031-11-17T00:00:00Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate));
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 works without precision", function () {
|
var expectedDate = "0950-01-02T03:04:05.5Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate));
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 pads zeros for year less than four digits or time components less than two digits", function () {
|
var expectedDate = "0950-01-02T03:04:05.005Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate), 3);
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 does not show milliseconds if they are 0", function () {
|
var expectedDate = "0950-01-02T03:04:05Z";
|
var date = JulianDate.toIso8601(JulianDate.fromIso8601(expectedDate));
|
expect(date).toEqual(expectedDate);
|
});
|
|
it("toIso8601 works with specified precision", function () {
|
var isoDate = "0950-01-02T03:04:05.012345Z";
|
var date;
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 0);
|
expect(date).toEqual("0950-01-02T03:04:05Z");
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 1);
|
expect(date).toEqual("0950-01-02T03:04:05.0Z");
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 2);
|
expect(date).toEqual("0950-01-02T03:04:05.01Z");
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 3);
|
expect(date).toEqual("0950-01-02T03:04:05.012Z");
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 4);
|
expect(date).toEqual("0950-01-02T03:04:05.0123Z");
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 5);
|
expect(date).toEqual("0950-01-02T03:04:05.01234Z");
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 6);
|
expect(date).toEqual("0950-01-02T03:04:05.012345Z");
|
date = JulianDate.toIso8601(JulianDate.fromIso8601(isoDate), 7);
|
expect(date).toEqual("0950-01-02T03:04:05.0123450Z");
|
});
|
|
it("can format Iso8601.MINIMUM_VALUE and MAXIMUM_VALUE to ISO strings", function () {
|
var minString = Iso8601.MINIMUM_VALUE.toString();
|
expect(minString).toEqual("0000-01-01T00:00:00Z");
|
expect(JulianDate.fromIso8601(minString)).toEqual(Iso8601.MINIMUM_VALUE);
|
|
var maxString = Iso8601.MAXIMUM_VALUE.toString();
|
expect(maxString).toEqual("9999-12-31T24:00:00Z");
|
expect(JulianDate.fromIso8601(maxString)).toEqual(Iso8601.MAXIMUM_VALUE);
|
});
|
|
it("secondsDifference works in UTC", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.fromDate(new Date("July 5, 2011 12:01:00 UTC"));
|
expect(JulianDate.secondsDifference(end, start)).toEqualEpsilon(
|
TimeConstants.SECONDS_PER_DAY + TimeConstants.SECONDS_PER_MINUTE,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("secondsDifference works in TAI", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.fromDate(new Date("July 5, 2011 12:01:00 UTC"));
|
expect(JulianDate.secondsDifference(end, start)).toEqualEpsilon(
|
TimeConstants.SECONDS_PER_DAY + TimeConstants.SECONDS_PER_MINUTE,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("secondsDifference works with mixed time standards", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.fromDate(new Date("July 5, 2011 12:01:00 UTC"));
|
expect(JulianDate.secondsDifference(end, start)).toEqualEpsilon(
|
TimeConstants.SECONDS_PER_DAY + TimeConstants.SECONDS_PER_MINUTE,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("daysDifference works", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00"));
|
var end = JulianDate.fromDate(new Date("July 5, 2011 14:24:00"));
|
var difference = JulianDate.daysDifference(end, start);
|
expect(difference).toEqual(1.1);
|
});
|
|
it("daysDifference works with negative result", function () {
|
var end = JulianDate.fromDate(new Date("July 4, 2011 12:00:00"));
|
var start = JulianDate.fromDate(new Date("July 5, 2011 14:24:00"));
|
var difference = JulianDate.daysDifference(end, start);
|
expect(difference).toEqual(-1.1);
|
});
|
|
it("addSeconds works with whole seconds", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:30 UTC"));
|
var end = JulianDate.addSeconds(start, 95, new JulianDate());
|
expect(JulianDate.toDate(end).getUTCSeconds()).toEqualEpsilon(
|
5,
|
CesiumMath.EPSILON5
|
);
|
expect(JulianDate.toDate(end).getUTCMinutes()).toEqualEpsilon(
|
2,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("addSeconds works with fractions (1)", function () {
|
var start = new JulianDate(2454832, 0, TimeStandard.TAI);
|
var end = JulianDate.addSeconds(start, 1.5, new JulianDate());
|
expect(JulianDate.secondsDifference(end, start)).toEqual(1.5);
|
});
|
|
it("addSeconds works with fractions (2)", function () {
|
var start = JulianDate.fromDate(new Date("August 11 2011 6:00:00 UTC"));
|
var end = JulianDate.addSeconds(start, 0.5, new JulianDate());
|
expect(JulianDate.secondsDifference(end, start, new JulianDate())).toEqual(
|
0.5
|
);
|
});
|
|
it("addSeconds works with fractions (3)", function () {
|
var start = JulianDate.fromDate(new Date("August 11 2011 11:59:59 UTC"));
|
var end = JulianDate.addSeconds(start, 1.25, new JulianDate());
|
expect(JulianDate.secondsDifference(end, start, new JulianDate())).toEqual(
|
1.25
|
);
|
});
|
|
it("addSeconds works with negative numbers", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:01:30 UTC"));
|
var end = JulianDate.addSeconds(start, -60.0, new JulianDate());
|
expect(JulianDate.secondsDifference(end, start)).toEqual(-60.0);
|
});
|
|
it("addSeconds works with more seconds than in a day", function () {
|
var seconds = TimeConstants.SECONDS_PER_DAY * 7 + 15;
|
var start = new JulianDate(2448444, 0, TimeStandard.UTC);
|
var end = JulianDate.addSeconds(start, seconds, new JulianDate());
|
expect(JulianDate.secondsDifference(end, start)).toEqual(seconds);
|
});
|
|
it("addSeconds works with negative seconds more than in a day", function () {
|
var seconds = -TimeConstants.SECONDS_PER_DAY * 7 - 15;
|
var start = new JulianDate(2448444, 0, TimeStandard.UTC);
|
var end = JulianDate.addSeconds(start, seconds, new JulianDate());
|
expect(JulianDate.secondsDifference(end, start)).toEqual(seconds);
|
});
|
it("addSeconds fails with undefined input", function () {
|
expect(function () {
|
return JulianDate.addSeconds(
|
JulianDate.now(),
|
undefined,
|
new JulianDate()
|
);
|
}).toThrowDeveloperError();
|
});
|
it("addMinutes works", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.addMinutes(start, 65, new JulianDate());
|
expect(JulianDate.toDate(end).getUTCMinutes()).toEqualEpsilon(
|
5,
|
CesiumMath.EPSILON5
|
);
|
expect(JulianDate.toDate(end).getUTCHours()).toEqualEpsilon(
|
13,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("addMinutes works with negative numbers", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.addMinutes(start, -35, new JulianDate());
|
expect(JulianDate.toDate(end).getUTCMinutes()).toEqualEpsilon(
|
25,
|
CesiumMath.EPSILON5
|
);
|
expect(JulianDate.toDate(end).getUTCHours()).toEqualEpsilon(
|
11,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("addMinutes fails with undefined input", function () {
|
expect(function () {
|
return JulianDate.addMinutes(
|
JulianDate.now(),
|
undefined,
|
new JulianDate()
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("addHours works", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.addHours(start, 6, new JulianDate());
|
expect(JulianDate.toDate(end).getUTCHours()).toEqualEpsilon(
|
18,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("addHours works with negative numbers", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.addHours(start, -6, new JulianDate());
|
expect(JulianDate.toDate(end).getUTCHours()).toEqualEpsilon(
|
6,
|
CesiumMath.EPSILON5
|
);
|
});
|
it("addHours fails with undefined input", function () {
|
expect(function () {
|
return JulianDate.addHours(JulianDate.now(), undefined, new JulianDate());
|
}).toThrowDeveloperError();
|
});
|
|
it("addDays works", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.addDays(start, 32, new JulianDate());
|
expect(JulianDate.toDate(end).getUTCDate()).toEqualEpsilon(
|
5,
|
CesiumMath.EPSILON5
|
);
|
expect(JulianDate.toDate(end).getUTCMonth()).toEqualEpsilon(
|
7,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("addDays works with negative numbers", function () {
|
var start = JulianDate.fromDate(new Date("July 4, 2011 12:00:00 UTC"));
|
var end = JulianDate.addDays(start, -4, new JulianDate());
|
expect(JulianDate.toDate(end).getUTCDate()).toEqualEpsilon(
|
30,
|
CesiumMath.EPSILON5
|
);
|
expect(JulianDate.toDate(end).getUTCMonth()).toEqualEpsilon(
|
5,
|
CesiumMath.EPSILON5
|
);
|
});
|
|
it("addDays fails with undefined input", function () {
|
expect(function () {
|
return JulianDate.addDays(JulianDate.now(), undefined, new JulianDate());
|
}).toThrowDeveloperError();
|
});
|
|
it("lessThan works", function () {
|
var start = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
var end = JulianDate.fromDate(new Date("July 6, 2011 12:01:00"));
|
expect(JulianDate.lessThan(start, end)).toEqual(true);
|
});
|
|
it("lessThan works with equal values", function () {
|
var start = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
var end = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
expect(JulianDate.lessThan(start, end)).toEqual(false);
|
expect(
|
JulianDate.lessThan(
|
start,
|
JulianDate.addSeconds(end, 1, new JulianDate())
|
)
|
).toEqual(true);
|
});
|
|
it("lessThan works with different time standards", function () {
|
var start = new JulianDate(0, 0, TimeStandard.TAI);
|
var end = new JulianDate(0, 0, TimeStandard.UTC);
|
expect(JulianDate.lessThan(start, end)).toEqual(true);
|
});
|
|
it("lessThanOrEquals works", function () {
|
var start = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
var end = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
expect(JulianDate.lessThanOrEquals(start, end)).toEqual(true);
|
expect(
|
JulianDate.lessThanOrEquals(
|
JulianDate.addSeconds(start, 1, new JulianDate()),
|
end
|
)
|
).toEqual(false);
|
expect(
|
JulianDate.lessThanOrEquals(
|
JulianDate.addSeconds(start, -1, new JulianDate()),
|
end
|
)
|
).toEqual(true);
|
});
|
|
it("greaterThan works", function () {
|
var start = JulianDate.fromDate(new Date("July 6, 2011 12:01:00"));
|
var end = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
expect(JulianDate.greaterThan(start, end)).toEqual(true);
|
});
|
|
it("greaterThan works with equal values", function () {
|
var start = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
var end = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
expect(JulianDate.greaterThan(start, end)).toEqual(false);
|
expect(
|
JulianDate.greaterThan(
|
start,
|
JulianDate.addSeconds(end, -1, new JulianDate())
|
)
|
).toEqual(true);
|
});
|
|
it("greaterThan works with different time standards", function () {
|
var start = new JulianDate(0, 0, TimeStandard.UTC);
|
var end = new JulianDate(0, 0, TimeStandard.TAI);
|
expect(JulianDate.greaterThan(start, end)).toEqual(true);
|
});
|
|
it("greaterThanOrEquals works", function () {
|
var start = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
var end = JulianDate.fromDate(new Date("July 6, 1991 12:00:00"));
|
expect(JulianDate.greaterThanOrEquals(start, end)).toEqual(true);
|
expect(
|
JulianDate.greaterThanOrEquals(
|
JulianDate.addSeconds(start, -1, new JulianDate()),
|
end
|
)
|
).toEqual(false);
|
expect(
|
JulianDate.greaterThanOrEquals(
|
JulianDate.addSeconds(start, 1, new JulianDate()),
|
end
|
)
|
).toEqual(true);
|
});
|
|
it("can be equal to within an epsilon of another JulianDate", function () {
|
var original = JulianDate.fromDate(
|
new Date("September 7, 2011 12:55:00 UTC")
|
);
|
var clone = JulianDate.fromDate(new Date("September 7, 2011 12:55:00 UTC"));
|
clone = JulianDate.addSeconds(clone, 1, new JulianDate());
|
expect(original.equalsEpsilon(clone, 2)).toEqual(true);
|
});
|
|
it("totalDays works", function () {
|
var totalDays = 2455784.7500058;
|
var original = new JulianDate(totalDays, 0, TimeStandard.TAI);
|
expect(totalDays).toEqual(JulianDate.totalDays(original));
|
});
|
|
it("equalsEpsilon works", function () {
|
var date = JulianDate.now();
|
var datePlusOne = JulianDate.addSeconds(date, 0.01, new JulianDate());
|
expect(date.equalsEpsilon(datePlusOne, CesiumMath.EPSILON1)).toEqual(true);
|
});
|
|
it("formats as ISO8601 with toString", function () {
|
var date = JulianDate.now();
|
expect(date.toString()).toEqual(JulianDate.toIso8601(date));
|
});
|
|
it("computeTaiMinusUtc works before all leap seconds", function () {
|
var date = new Date("July 11, 1970 12:00:00 UTC");
|
var jd = JulianDate.fromDate(date);
|
var difference = JulianDate.computeTaiMinusUtc(jd);
|
expect(difference).toEqual(10);
|
});
|
|
it("computeTaiMinusUtc works a second before a leap second", function () {
|
var date = new JulianDate(2456109, 43233.0, TimeStandard.TAI);
|
expect(JulianDate.computeTaiMinusUtc(date)).toEqual(34);
|
});
|
|
it("computeTaiMinusUtc works on a leap second", function () {
|
var date = new JulianDate(2456109, 43234.0, TimeStandard.TAI);
|
expect(JulianDate.computeTaiMinusUtc(date)).toEqual(34);
|
});
|
|
it("computeTaiMinusUtc works a second after a leap second", function () {
|
var date = new JulianDate(2456109, 43235.0, TimeStandard.TAI);
|
expect(JulianDate.computeTaiMinusUtc(date)).toEqual(35);
|
});
|
|
it("computeTaiMinusUtc works after all leap seconds", function () {
|
var date = new JulianDate(2556109, 43237.0, TimeStandard.TAI);
|
expect(JulianDate.computeTaiMinusUtc(date)).toEqual(37);
|
});
|
|
it("fromGregorianDate returns the same date", function () {
|
var iso86011 = "2017-01-01T10:01:01.5Z";
|
var julian1 = JulianDate.fromIso8601(iso86011);
|
var gregorian = JulianDate.toGregorianDate(julian1);
|
var julian2 = JulianDate.fromGregorianDate(gregorian);
|
var iso86012 = JulianDate.toIso8601(julian2);
|
|
expect(iso86011).toEqual(iso86012);
|
expect(JulianDate.compare(julian1, julian2)).toEqual(0);
|
});
|
});
|
