public void FromMillisecondsSinceUnixEpoch_Valid() { Instant actual = Instant.FromMillisecondsSinceUnixEpoch(12345L); Instant expected = Instant.FromTicksSinceUnixEpoch(12345L * NodaConstants.TicksPerMillisecond); Assert.AreEqual(expected, actual); }
public void DirectConstruction() { Instant instant = Instant.FromTicksSinceUnixEpoch(100L); FakeClock clock = new FakeClock(instant); Assert.AreEqual(instant, clock.GetCurrentInstant()); }
public void FromTicksSinceUnixEpoch() { Instant actual = Instant.FromTicksSinceUnixEpoch(12345L); Instant expected = new Instant(12345L); Assert.AreEqual(expected, actual); }
public void FieldsOf_GreatAchievement() { LocalDateTime now = Instant.FromTicksSinceUnixEpoch((TimeOfGreatAchievement - UnixEpochDateTime).Ticks).InUtc().LocalDateTime; Assert.AreEqual(2009, now.Year); Assert.AreEqual(2009, now.YearOfEra); Assert.AreEqual(2009, now.WeekYear); Assert.AreEqual(48, now.WeekOfWeekYear); Assert.AreEqual(11, now.Month); Assert.AreEqual(27, now.Day); Assert.AreEqual(TimeOfGreatAchievement.DayOfYear, now.DayOfYear); Assert.AreEqual(IsoDayOfWeek.Friday, now.IsoDayOfWeek); Assert.AreEqual(5, now.DayOfWeek); Assert.AreEqual(Era.Common, now.Era); Assert.AreEqual(18, now.Hour); Assert.AreEqual(38, now.Minute); Assert.AreEqual(25, now.Second); Assert.AreEqual(345, now.Millisecond); Assert.AreEqual(3458765, now.TickOfSecond); Assert.AreEqual(18 * NodaConstants.TicksPerHour + 38 * NodaConstants.TicksPerMinute + 25 * NodaConstants.TicksPerSecond + 3458765, now.TickOfDay); }
public void AdvanceTicks() { FakeClock clock = new FakeClock(Instant.FromTicksSinceUnixEpoch(100L)); clock.AdvanceTicks(3); Assert.AreEqual(103, clock.GetCurrentInstant().Ticks); }
/// <summary> /// Reads an instant representing a zone interval transition from the stream. /// </summary> /// <remarks> /// The value must have been written by <see cref="DateTimeZoneWriter.WriteZoneIntervalTransition" />. /// </remarks> /// <param name="previous">The previous transition written (usually for a given timezone), or null if there is /// no previous transition.</param> /// <returns>The instant read from the stream</returns> public Instant ReadZoneIntervalTransition(Instant?previous) { unchecked { int value = ReadCount(); if (value < DateTimeZoneWriter.ZoneIntervalConstants.MinValueForHoursSincePrevious) { switch (value) { case DateTimeZoneWriter.ZoneIntervalConstants.MarkerMinValue: return(Instant.BeforeMinValue); case DateTimeZoneWriter.ZoneIntervalConstants.MarkerMaxValue: return(Instant.AfterMaxValue); case DateTimeZoneWriter.ZoneIntervalConstants.MarkerRaw: return(Instant.FromTicksSinceUnixEpoch(ReadInt64())); default: throw new InvalidNodaDataException("Unrecognised marker value: " + value); } } if (value < DateTimeZoneWriter.ZoneIntervalConstants.MinValueForMinutesSinceEpoch) { if (previous == null) { throw new InvalidNodaDataException( "No previous value, so can't interpret value encoded as delta-since-previous: " + value); } return((Instant)previous + Duration.FromHours(value)); } return(DateTimeZoneWriter.ZoneIntervalConstants.EpochForMinutesSinceEpoch + Duration.FromMinutes(value)); } }
public void AdvanceMilliseconds() { FakeClock clock = new FakeClock(Instant.FromTicksSinceUnixEpoch(100L)); clock.AdvanceMilliseconds(3); Assert.AreEqual(100 + 3 * NodaConstants.TicksPerMillisecond, clock.GetCurrentInstant().Ticks); }
public void Comparison() { Instant early = Instant.FromTicksSinceUnixEpoch(1000); Instant late = Instant.FromTicksSinceUnixEpoch(2000); Assert.That(early < late); }
public void Advance() { FakeClock clock = new FakeClock(Instant.FromTicksSinceUnixEpoch(100L)); Duration d = Duration.FromTicks(25); clock.Advance(d); Assert.AreEqual(125, clock.GetCurrentInstant().Ticks); }
public void GetPeriod_BeforeLast() { Instant april1981 = Instant.FromUtc(1981, 4, 1, 0, 0); var actual = Algiers.GetZoneInterval(april1981); var expected = new ZoneInterval("WET", Instant.FromTicksSinceUnixEpoch(3418020000000000L), Instant.FromTicksSinceUnixEpoch(3575232000000000L), Offset.Zero, Offset.Zero); Assert.AreEqual(expected, actual); }
public static Instant InstantFromUnixTimeTicks(long ticks) { #if NODATIME2 return(Instant.FromUnixTimeTicks(ticks)); #else return(Instant.FromTicksSinceUnixEpoch(ticks)); #endif }
public void GetPeriod_AfterLastTransition() { var may1981 = DateTimeZone.Utc.AtStrictly(new LocalDateTime(1981, 5, 1, 0, 0, 1)).ToInstant(); var actual = Algiers.GetZoneInterval(may1981); var expected = new ZoneInterval("CET", Instant.FromTicksSinceUnixEpoch(3575232000000000L), null, Offset.FromSeconds(NodaConstants.SecondsPerHour), Offset.Zero); Assert.AreEqual(expected, actual); }
public void Validation_BadFirstStartingPoint() { ZoneInterval[] intervals = { new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(10), Instant.FromTicksSinceUnixEpoch(20), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(20), Instant.FromTicksSinceUnixEpoch(30), Offset.Zero, Offset.Zero) }; Assert.Throws <ArgumentException>(() => PrecalculatedDateTimeZone.ValidatePeriods(intervals, DateTimeZone.Utc)); }
public void Validation_NullTailZoneWithMiddleOfTimeFinalPeriod() { ZoneInterval[] intervals = { new ZoneInterval("foo", Instant.BeforeMinValue, Instant.FromTicksSinceUnixEpoch(20), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(20), Instant.FromTicksSinceUnixEpoch(30), Offset.Zero, Offset.Zero) }; Assert.Throws <ArgumentException>(() => PrecalculatedDateTimeZone.ValidatePeriods(intervals, null)); }
public void Validation_NullTailZoneWithEotPeriodEnd() { ZoneInterval[] intervals = { new ZoneInterval("foo", Instant.BeforeMinValue, Instant.FromTicksSinceUnixEpoch(20), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(20), Instant.AfterMaxValue, Offset.Zero, Offset.Zero) }; PrecalculatedDateTimeZone.ValidatePeriods(intervals, null); }
public void Validation_NonAdjoiningIntervals() { ZoneInterval[] intervals = { new ZoneInterval("foo", Instant.BeforeMinValue, Instant.FromTicksSinceUnixEpoch(20), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(25), Instant.FromTicksSinceUnixEpoch(30), Offset.Zero, Offset.Zero) }; Assert.Throws <ArgumentException>(() => PrecalculatedDateTimeZone.ValidatePeriods(intervals, DateTimeZone.Utc)); }
public void Reset() { Instant instant1 = Instant.FromTicksSinceUnixEpoch(100L); Instant instant2 = Instant.FromTicksSinceUnixEpoch(500L); FakeClock clock = new FakeClock(instant1); Assert.AreEqual(instant1, clock.GetCurrentInstant()); clock.Reset(instant2); Assert.AreEqual(instant2, clock.GetCurrentInstant()); }
public void AdditionWithDuration() { // Some arbitrary instant. I've no idea when. Instant instant = Instant.FromTicksSinceUnixEpoch(150000000); // A very short duration: a duration is simply a number of ticks. Duration duration = Duration.FromTicks(1000); Instant later = instant + duration; Assert.AreEqual(Instant.FromTicksSinceUnixEpoch(150001000), later); }
public void Construction() { // 10 million ticks = 1 second... Instant instant = Instant.FromTicksSinceUnixEpoch(10000000); // Epoch is 1970 UTC // An instant isn't really "in" a time zone or calendar, but // it's convenient to consider UTC in the ISO-8601 calendar. Assert.AreEqual("1970-01-01T00:00:01Z", instant.ToString()); }
public void GetZoneIntervals_NullTailZone_Eot() { ZoneInterval[] intervals = { new ZoneInterval("foo", Instant.BeforeMinValue, Instant.FromTicksSinceUnixEpoch(20), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(20), Instant.AfterMaxValue, Offset.Zero, Offset.Zero) }; var zone = new PrecalculatedDateTimeZone("Test", intervals, null); Assert.AreEqual(intervals[1], zone.GetZoneInterval(Instant.MaxValue)); }
public void Validation_Success() { ZoneInterval[] intervals = { new ZoneInterval("foo", Instant.BeforeMinValue, Instant.FromTicksSinceUnixEpoch(20), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(20), Instant.FromTicksSinceUnixEpoch(30), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(30), Instant.FromTicksSinceUnixEpoch(100), Offset.Zero, Offset.Zero), new ZoneInterval("foo", Instant.FromTicksSinceUnixEpoch(100), Instant.FromTicksSinceUnixEpoch(200), Offset.Zero, Offset.Zero) }; PrecalculatedDateTimeZone.ValidatePeriods(intervals, DateTimeZone.Utc); }
public void ConstructionWithAdvance() { Instant instant = Instant.FromTicksSinceUnixEpoch(100L); Duration advance = Duration.FromTicks(5); FakeClock clock = new FakeClock(instant, advance); Assert.AreEqual(advance, clock.AutoAdvance); Assert.AreEqual(instant, clock.GetCurrentInstant()); Assert.AreEqual(instant + advance, clock.GetCurrentInstant()); Assert.AreEqual(instant + advance + advance, clock.GetCurrentInstant()); }
public void Settings_ConfigureForNodaTime_WithIsoIntervalConverter() { var configuredSettings = new JsonSerializerSettings().ConfigureForNodaTime(DateTimeZoneProviders.Tzdb).WithIsoIntervalConverter(); var explicitSettings = new JsonSerializerSettings { Converters = { NodaConverters.IsoIntervalConverter } }; var interval = new Interval(Instant.FromTicksSinceUnixEpoch(1000L), Instant.FromTicksSinceUnixEpoch(20000L)); Assert.AreEqual(JsonConvert.SerializeObject(interval, explicitSettings), JsonConvert.SerializeObject(interval, configuredSettings)); }
public void Serializer_ConfigureForNodaTime_DefaultInterval() { var configuredSerializer = new JsonSerializer().ConfigureForNodaTime(DateTimeZoneProviders.Tzdb); var explicitSerializer = new JsonSerializer { Converters = { NodaConverters.IntervalConverter, NodaConverters.InstantConverter } }; var interval = new Interval(Instant.FromTicksSinceUnixEpoch(1000L), Instant.FromTicksSinceUnixEpoch(20000L)); Assert.AreEqual(Serialize(interval, explicitSerializer), Serialize(interval, configuredSerializer)); }
public void Min() { Instant x = Instant.FromTicksSinceUnixEpoch(100); Instant y = Instant.FromTicksSinceUnixEpoch(200); Assert.AreEqual(x, Instant.Min(x, y)); Assert.AreEqual(x, Instant.Min(y, x)); Assert.AreEqual(Instant.MinValue, Instant.Min(x, Instant.MinValue)); Assert.AreEqual(Instant.MinValue, Instant.Min(Instant.MinValue, x)); Assert.AreEqual(x, Instant.Min(Instant.MaxValue, x)); Assert.AreEqual(x, Instant.Min(x, Instant.MaxValue)); }
public void Test_ZoneIntervalTransition() { var dio = DtzIoHelper.CreateNoStringPool(); dio.TestZoneIntervalTransition(null, Instant.BeforeMinValue); dio.TestZoneIntervalTransition(null, Instant.MinValue); // No test for Instant.MaxValue, as it's not on a tick boundary. dio.TestZoneIntervalTransition(null, Instant.AfterMaxValue); dio.TestZoneIntervalTransition(null, Instant.MinValue.PlusTicks(1)); // The ZoneIntervalTransition has precision to the tick (with no real need to change that). // Round to the tick just lower than Instant.MaxValue... Instant tickBeforeMaxInstant = Instant.FromTicksSinceUnixEpoch(Instant.MaxValue.Ticks); dio.TestZoneIntervalTransition(null, tickBeforeMaxInstant); // Encoding as hours-since-previous. Instant previous = Instant.FromUtc(1990, 1, 1, 11, 30); // arbitrary dio.TestZoneIntervalTransition(previous, previous); dio.TestZoneIntervalTransition(previous, previous + Duration.FromHours( DateTimeZoneWriter.ZoneIntervalConstants.MinValueForHoursSincePrevious)); dio.TestZoneIntervalTransition(previous, previous + Duration.FromHours( DateTimeZoneWriter.ZoneIntervalConstants.MinValueForHoursSincePrevious - 1)); // too soon dio.TestZoneIntervalTransition(previous, previous + Duration.FromHours(1)); // too soon dio.TestZoneIntervalTransition(previous, previous + Duration.FromHours( DateTimeZoneWriter.ZoneIntervalConstants.MinValueForMinutesSinceEpoch - 1)); // maximum hours dio.TestZoneIntervalTransition(previous, previous + Duration.FromHours( DateTimeZoneWriter.ZoneIntervalConstants.MinValueForMinutesSinceEpoch)); // out of range // A large difference from the previous transition. dio.TestZoneIntervalTransition(Instant.MinValue.PlusTicks(1), tickBeforeMaxInstant); // Encoding as minutes-since-epoch. Instant epoch = DateTimeZoneWriter.ZoneIntervalConstants.EpochForMinutesSinceEpoch; dio.TestZoneIntervalTransition(null, epoch); dio.TestZoneIntervalTransition(null, epoch + Duration.FromMinutes(DateTimeZoneWriter.ZoneIntervalConstants.MinValueForMinutesSinceEpoch)); dio.TestZoneIntervalTransition(null, epoch + Duration.FromMinutes(int.MaxValue)); // maximum minutes // Out of range cases, or not a multiple of minutes since the epoch. dio.TestZoneIntervalTransition(null, epoch + Duration.FromHours(1)); // too soon dio.TestZoneIntervalTransition(null, epoch + Duration.FromMinutes(1)); // too soon dio.TestZoneIntervalTransition(null, epoch + Duration.FromSeconds(1)); dio.TestZoneIntervalTransition(null, epoch + Duration.FromMilliseconds(1)); dio.TestZoneIntervalTransition(null, epoch - Duration.FromHours(1)); dio.TestZoneIntervalTransition(null, epoch + Duration.FromMinutes((long)int.MaxValue + 1)); // Example from Pacific/Auckland which failed at one time, and a similar one with seconds. dio.TestZoneIntervalTransition(null, Instant.FromUtc(1927, 11, 5, 14, 30)); dio.TestZoneIntervalTransition(null, Instant.FromUtc(1927, 11, 5, 14, 30, 5)); }
public void ConstructionThenAdvance() { Instant instant = Instant.FromTicksSinceUnixEpoch(100L); FakeClock clock = new FakeClock(instant); Assert.AreEqual(instant, clock.GetCurrentInstant()); Assert.AreEqual(instant, clock.GetCurrentInstant()); Duration advance = Duration.FromTicks(5); clock.AutoAdvance = advance; // Setting auto-advance doesn't actually change the clock... // but this call will. Assert.AreEqual(instant, clock.GetCurrentInstant()); Assert.AreEqual(instant + advance, clock.GetCurrentInstant()); Assert.AreEqual(instant + advance + advance, clock.GetCurrentInstant()); }
public void ComplexBuilding() { var transition1 = Instant.FromTicksSinceUnixEpoch(0L); var transition2 = Instant.FromTicksSinceUnixEpoch(100000L); var zone = new MultiTransitionDateTimeZone.Builder(2, 1, "X") { { transition1, 2, 0, "Y" }, { transition2, 1, 1, "Z" } }.Build(); var actual = zone.GetZoneIntervals(transition1 - Duration.Epsilon, transition2 + Duration.Epsilon).ToList(); // ZoneInterval uses wall offset and savings... var expected = new[] { new ZoneInterval("X", Instant.BeforeMinValue, transition1, Offset.FromHours(3), Offset.FromHours(1)), new ZoneInterval("Y", transition1, transition2, Offset.FromHours(2), Offset.FromHours(0)), new ZoneInterval("Z", transition2, Instant.AfterMaxValue, Offset.FromHours(2), Offset.FromHours(1)), }; CollectionAssert.AreEqual(expected, actual); }
public void SimpleBuilding() { var transition1 = Instant.FromTicksSinceUnixEpoch(0L); var transition2 = Instant.FromTicksSinceUnixEpoch(100000L); var zone = new MultiTransitionDateTimeZone.Builder { { transition1, 5 }, { transition2, 3 } }.Build(); var intervals = zone.GetZoneIntervals(transition1 - Duration.Epsilon, transition2 + Duration.Epsilon).ToList(); Assert.AreEqual(3, intervals.Count); Assert.AreEqual(Offset.Zero, intervals[0].WallOffset); Assert.AreEqual(Instant.BeforeMinValue, intervals[0].RawStart); Assert.AreEqual(transition1, intervals[0].End); Assert.AreEqual(Offset.FromHours(5), intervals[1].WallOffset); Assert.AreEqual(transition1, intervals[1].Start); Assert.AreEqual(transition2, intervals[1].End); Assert.AreEqual(Offset.FromHours(3), intervals[2].WallOffset); Assert.AreEqual(transition2, intervals[2].Start); Assert.AreEqual(Instant.AfterMaxValue, intervals[2].RawEnd); }
public void Equals_DifferentToOtherType() { LocalDate date = new LocalDate(2011, 1, 2); Assert.IsFalse(date.Equals(Instant.FromTicksSinceUnixEpoch(0))); }