public void SubtractDuration_MethodEquivalents()
{
ZonedDateTime after = SampleZone.AtStrictly(new LocalDateTime(2011, 6, 13, 16, 0));
Assert.AreEqual(after - Duration.OneDay, ZonedDateTime.Subtract(after, Duration.OneDay));
Assert.AreEqual(after - Duration.OneDay, after.Minus(Duration.OneDay));
}
public void Past_with_custom_options()
{
var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc);
dataSet.Past(reference: starting, daysToGoBack: 500).ToDateTimeUtc().Should()
.BeOnOrBefore(starting.ToDateTimeUtc())
.And
.BeOnOrAfter(starting.Minus(Duration.FromDays(500)).ToDateTimeUtc());
}
public void Past()
{
var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc);
dataSet.Past(reference: starting).ToDateTimeUtc().Should()
.BeOnOrBefore(starting.ToDateTimeUtc())
.And
.BeOnOrAfter(starting.Minus(Duration.FromDays(100)).ToDateTimeUtc());
}
public void MinusZonedDateTime()
{
var zone = DateTimeZone.ForOffset(Offset.FromHours(-5));
ZonedDateTime subject = new ZonedDateTime(Instant.FromUtc(2017, 7, 17, 7, 17), zone);
ZonedDateTime other = new ZonedDateTime(Instant.FromUtc(2017, 7, 17, 9, 17), zone);
var difference = Snippet.For(other.Minus(subject));
Assert.AreEqual(Duration.FromHours(2), difference);
}
public void Subtraction_ZonedDateTime()
{
// Test all three approaches... not bothering to check a different calendar,
// but we'll use two different time zones.
ZonedDateTime start = new LocalDateTime(2014, 08, 14, 5, 51).InUtc();
// Sample zone is UTC+4 at this point, so this is 14:00Z.
ZonedDateTime end = SampleZone.AtStrictly(new LocalDateTime(2014, 08, 14, 18, 0));
Duration expected = Duration.FromHours(8) + Duration.FromMinutes(9);
Assert.AreEqual(expected, end - start);
Assert.AreEqual(expected, end.Minus(start));
Assert.AreEqual(expected, ZonedDateTime.Subtract(end, start));
}
public void Can_Query_By_MoreThan_ZonedDateTime_Stored_As_DateTimeOffset()
{
var timeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault();
Instant startInstant = TestClock.Now.Plus(Duration.FromHours(24));
ZonedDateTime startZonedDateTime = startInstant.InZone(timeZone);
ZonedDateTime finishZonedDateTime = startZonedDateTime.Plus(Duration.FromHours(1));
var testEvent = new ZonedDateTimeTestEntity
{
Description = "Can_Query_By_LessThan_ZonedDateTime_Stored_As_DateTimeOffset",
StartZonedDateTime = startZonedDateTime,
FinishZonedDateTime = finishZonedDateTime
};
using (ISession session = SessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(testEvent);
transaction.Commit();
}
ZonedDateTime beforeStart = startZonedDateTime.Minus(Duration.FromMinutes(1));
using (ISession session = SessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
var query = session.Query <ZonedDateTimeTestEntity>()
.Where(x => x.Id == testEvent.Id && x.StartZonedDateTime.ToDateTimeOffset() > beforeStart.ToDateTimeOffset());
var retrievedEvent = query.SingleOrDefault();
transaction.Commit();
Assert.That(testEvent, Is.Not.Null);
Assert.That(testEvent, Is.EqualTo(retrievedEvent));
}
using (ISession session = SessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
var query = session.Query <ZonedDateTimeTestEntity>()
.Where(x => x.Id == testEvent.Id &&
x.StartZonedDateTime.ToDateTimeOffset() > beforeStart.ToDateTimeOffset() &&
x.FinishZonedDateTime.Value.ToDateTimeOffset() >= finishZonedDateTime.ToDateTimeOffset());
var retrievedEvent = query.SingleOrDefault();
transaction.Commit();
Assert.That(testEvent, Is.Not.Null);
Assert.That(testEvent, Is.EqualTo(retrievedEvent));
}
}
public static void CalculateKosmorDate(ZonedDateTime currentDate)
{
LocalDateTime localTime = new LocalDateTime(2004, 2, 1, 0, 0);
ZonedDateTime startDate = new ZonedDateTime(localTime, DateTimeZone.Utc, Offset.Zero);
int kosmorDay = 6;
int kosmorYear = 3500;
PeriodBuilder pb = new PeriodBuilder();
pb.Milliseconds = MILLISECONDS_IN_A_DAY;
Period period = pb.Build();
ZonedDateTime date = currentDate.Minus(period.ToDuration());
while (startDate < currentDate)
{
startDate = startDate.Plus(period.ToDuration());
if (currentDate.Calendar.IsLeapYear(currentDate.Year))
{
if (kosmorDay > 366)
{
kosmorDay = 1;
kosmorYear++;
}
else
{
kosmorDay++;
}
}
else if (kosmorDay > 365)
{
kosmorDay = 1;
kosmorYear++;
}
else
{
kosmorDay++;
}
}
String formattedKosmorDay = kosmorDay.ToString("#000");
kosmorDate = kosmorYear + "_" + formattedKosmorDay;
}
public void SubtractDuration()
{
// Europe/Dublin transitions from UTC+1 to UTC+0 at 2am (local) on 2017-10-29
var dt = new LocalDateTime(2017, 10, 29, 1, 45, 0);
DateTimeZone dublin = DateTimeZoneProviders.Tzdb["Europe/Dublin"];
ZonedDateTime afterTransition = new ZonedDateTime(dt, dublin, Offset.FromHours(0));
var result = Snippet.For(ZonedDateTime.Subtract(afterTransition, Duration.FromHours(1)));
Assert.AreEqual(new LocalDate(2017, 10, 29), result.Date);
// Adding an hour of elapsed time takes us across the DST transition, so we have
// the same local time (shown on a clock) but a different offset.
Assert.AreEqual(new ZonedDateTime(dt, dublin, Offset.FromHours(1)), result);
// The + operator and Plus instance method are equivalent to the Add static method.
var result2 = Snippet.For(afterTransition - Duration.FromHours(1));
var result3 = Snippet.For(afterTransition.Minus(Duration.FromHours(1)));
Assert.AreEqual(result, result2);
Assert.AreEqual(result, result3);
}
internal static ZonedDateTime MinusFromDateTime(this ZonedDateTime instance, Duration duration) => instance.Minus(duration);
