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)));
}
