public void XmlSerialization_NonIso()
{
var date = new LocalDate(2013, 4, 12, CalendarSystem.Julian);
var value = new OffsetDate(date, Offset.Zero);
TestHelper.AssertXmlRoundtrip(value, "<value calendar=\"Julian\">2013-04-12Z</value>");
}
public void ToString_WithNullFormat()
{
LocalDate date = new LocalDate(2012, 10, 6);
Offset offset = Offset.FromHours(1);
OffsetDate offsetDate = new OffsetDate(date, offset);
Assert.AreEqual("2012-10-06+01", offsetDate.ToString(null, CultureInfo.InvariantCulture));
}
public void ToString_WithFormat()
{
LocalDate date = new LocalDate(2012, 10, 6);
Offset offset = Offset.FromHours(1);
OffsetDate offsetDate = new OffsetDate(date, offset);
Assert.AreEqual("2012/10/06 01", offsetDate.ToString("yyyy/MM/dd o<-HH>", CultureInfo.InvariantCulture));
}
public void WithAdjuster()
{
var initial = new OffsetDate(new LocalDate(2016, 6, 19), Offset.FromHours(-5));
var actual = initial.With(DateAdjusters.StartOfMonth);
var expected = new OffsetDate(new LocalDate(2016, 6, 1), Offset.FromHours(-5));
Assert.AreEqual(expected, actual);
}
public void WithOffset()
{
var date = new LocalDate(2011, 6, 29);
var offset = Offset.FromHours(5);
var expected = new OffsetDate(date, offset);
Assert.AreEqual(expected, date.WithOffset(offset));
}
public void XmlSerialization_Bce(int year, int month, int day, string expectedText)
{
var date = new LocalDate(Era.BeforeCommon, year, month, day);
var offset = Offset.FromHoursAndMinutes(5, 30);
var value = new OffsetDate(date, offset);
TestHelper.AssertXmlRoundtrip(value, $"<value>{expectedText}</value>");
}
public void ToOffsetDate()
{
var offset = Offset.FromHoursAndMinutes(2, 30);
var odt = new LocalDateTime(2014, 6, 27, 12, 15, 8).PlusNanoseconds(123456789).WithOffset(offset);
var expected = new OffsetDate(new LocalDate(2014, 6, 27), offset);
Assert.AreEqual(expected, odt.ToOffsetDate());
}
public void BinarySerialization()
{
var date = new LocalDate(2013, 4, 12);
var offset = Offset.FromHoursAndMinutes(5, 30);
var value = new OffsetDate(date, offset);
TestHelper.AssertBinaryRoundtrip(value);
}
public void Construction()
{
OffsetDate offsetDate = Snippet.For(new OffsetDate(
new LocalDate(2019, 5, 3),
Offset.FromHours(3)));
Assert.AreEqual(Offset.FromHours(3), offsetDate.Offset);
Assert.AreEqual(new LocalDate(2019, 5, 3), offsetDate.Date);
}
public void WithOffset()
{
var date = new LocalDate(2012, 6, 19);
var initial = new OffsetDate(date, Offset.FromHours(2));
var actual = initial.WithOffset(Offset.FromHours(5));
var expected = new OffsetDate(date, Offset.FromHours(5));
Assert.AreEqual(expected, actual);
}
public override byte[] ToBytes()
{
return(TLUtils.Combine(
TLUtils.SignatureToBytes(Signature),
Query.ToBytes(),
OffsetDate.ToBytes(),
OffsetPeer.ToBytes(),
OffsetId.ToBytes(),
Limit.ToBytes()));
}
public void ComponentProperties()
{
var date = new LocalDate(2012, 1, 2);
var offset = Offset.FromHours(5);
var offsetDate = new OffsetDate(date, offset);
Assert.AreEqual(offset, offsetDate.Offset);
Assert.AreEqual(date, offsetDate.Date);
}
public void WithCalendar()
{
var julianDate = new LocalDate(2012, 6, 19, CalendarSystem.Julian);
var isoDate = julianDate.WithCalendar(CalendarSystem.Iso);
var offset = Offset.FromHours(5);
var actual = new OffsetDate(julianDate, offset).WithCalendar(CalendarSystem.Iso);
var expected = new OffsetDate(isoDate, offset);
Assert.AreEqual(expected, actual);
}
public void WithCalendar()
{
var original = new OffsetDate(
new LocalDate(2019, 5, 3, CalendarSystem.Iso),
Offset.FromHours(3));
OffsetDate updated = Snippet.For(original.WithCalendar(CalendarSystem.Gregorian));
Assert.AreEqual(original.Offset, updated.Offset);
Assert.AreEqual(CalendarSystem.Gregorian, updated.Calendar);
}
public void WithOffset()
{
var original = new OffsetDate(
new LocalDate(2019, 5, 3),
Offset.FromHours(3));
OffsetDate updated = Snippet.For(original.WithOffset(Offset.FromHours(-3)));
Assert.AreEqual(Offset.FromHours(-3), updated.Offset);
Assert.AreEqual(original.Date, updated.Date);
}
public void ToString_NoFormat()
{
LocalDate date = new LocalDate(2012, 10, 6);
Offset offset = Offset.FromHours(1);
OffsetDate offsetDate = new OffsetDate(date, offset);
using (CultureSaver.SetCultures(CultureInfo.InvariantCulture))
{
Assert.AreEqual("2012-10-06+01", offsetDate.ToString());
}
}
public override byte[] ToBytes()
{
return(TLUtils.Combine(
TLUtils.SignatureToBytes(Signature),
Channel.ToBytes(),
OffsetId.ToBytes(),
OffsetDate.ToBytes(),
AddOffset.ToBytes(),
Limit.ToBytes(),
MaxId.ToBytes(),
MinId.ToBytes()));
}
public void With()
{
var original = new OffsetDate(
new LocalDate(2019, 5, 3),
Offset.FromHours(3));
Func <LocalDate, LocalDate> tomorrowAdjuster = x => x + Period.FromDays(1);
OffsetDate updated = Snippet.For(original.With(tomorrowAdjuster));
Assert.AreEqual(original.Offset, updated.Offset);
Assert.AreEqual(tomorrowAdjuster(original.Date), updated.Date);
}
public override byte[] ToBytes()
{
return(TLUtils.Combine(
TLUtils.SignatureToBytes(Signature),
Flags.ToBytes(),
//ToBytes(FeedId, Flags, (int)GetDialogsFlags.FeedId),
OffsetDate.ToBytes(),
OffsetId.ToBytes(),
OffsetPeer.ToBytes(),
Limit.ToBytes(),
Hash.ToBytes()));
}
/// <summary>
/// Creates schemas container.
/// </summary>
/// <returns>Initialized <see cref="Schema"/> instance.</returns>
public Schemas CreateSchemas()
{
IDateTimeZoneProvider dateTimeZoneProvider = _settings.DateTimeZoneProvider ?? DateTimeZoneProviders.Tzdb;
var dateTimeZone = dateTimeZoneProvider.GetSystemDefault();
var instant = Instant.FromDateTimeUtc(DateTime.UtcNow);
var zonedDateTime = instant.InZone(dateTimeZone);
var interval = new Interval(instant,
instant.PlusTicks(TimeSpan.TicksPerDay)
.PlusTicks(TimeSpan.TicksPerHour)
.PlusTicks(TimeSpan.TicksPerMinute)
.PlusTicks(TimeSpan.TicksPerSecond)
.PlusTicks(TimeSpan.TicksPerMillisecond));
var dateInterval = new DateInterval(zonedDateTime.Date, zonedDateTime.Date.PlusDays(1));
Period period = Period.Between(zonedDateTime.LocalDateTime, interval.End.InZone(dateTimeZone).LocalDateTime, PeriodUnits.AllUnits);
var offsetDate = new OffsetDate(zonedDateTime.Date, zonedDateTime.Offset);
var offsetTime = new OffsetTime(zonedDateTime.TimeOfDay, zonedDateTime.Offset);
// https://xml2rfc.tools.ietf.org/public/rfc/html/rfc3339.html#anchor14
return(new Schemas
{
Instant = () => StringSchema(instant, "date-time"),
LocalDate = () => StringSchema(zonedDateTime.Date, "full-date"),
LocalTime = () => StringSchema(zonedDateTime.TimeOfDay, "partial-time"),
LocalDateTime = () => StringSchema(zonedDateTime.LocalDateTime),
OffsetDateTime = () => StringSchema(instant.WithOffset(zonedDateTime.Offset), "date-time"),
ZonedDateTime = () => StringSchema(zonedDateTime),
Interval = () => new OpenApiSchema
{
Type = "object",
Properties = new Dictionary <string, OpenApiSchema>
{
{ ResolvePropertyName(nameof(Interval.Start)), StringSchema(interval.Start, "date-time") },
{ ResolvePropertyName(nameof(Interval.End)), StringSchema(interval.End, "date-time") },
},
},
DateInterval = () => new OpenApiSchema
{
Type = "object",
Properties = new Dictionary <string, OpenApiSchema>
{
{ ResolvePropertyName(nameof(DateInterval.Start)), StringSchema(dateInterval.Start, "full-date") },
{ ResolvePropertyName(nameof(DateInterval.End)), StringSchema(dateInterval.End, "full-date") },
},
},
Offset = () => StringSchema(zonedDateTime.Offset, "time-numoffset"),
Period = () => StringSchema(period),
Duration = () => StringSchema(interval.Duration),
OffsetDate = () => StringSchema(offsetDate),
OffsetTime = () => StringSchema(offsetTime),
DateTimeZone = () => StringSchema(dateTimeZone),
});
}
public void Deconstruction()
{
LocalDate date = new LocalDate(2015, 3, 28);
Offset offset = Offset.FromHours(-2);
OffsetDate offsetDate = new OffsetDate(date, offset);
var(actualDate, actualOffset) = offsetDate;
Assert.Multiple(() =>
{
Assert.AreEqual(date, actualDate);
Assert.AreEqual(offset, actualOffset);
});
}
public void Equality()
{
LocalDate date1 = new LocalDate(2012, 10, 6);
LocalDate date2 = new LocalDate(2012, 9, 5);
Offset offset1 = Offset.FromHours(1);
Offset offset2 = Offset.FromHours(2);
OffsetDate equal1 = new OffsetDate(date1, offset1);
OffsetDate equal2 = new OffsetDate(date1, offset1);
OffsetDate unequalByOffset = new OffsetDate(date1, offset2);
OffsetDate unequalByLocal = new OffsetDate(date2, offset1);
TestHelper.TestEqualsStruct(equal1, equal2, unequalByOffset);
TestHelper.TestEqualsStruct(equal1, equal2, unequalByLocal);
TestHelper.TestOperatorEquality(equal1, equal2, unequalByOffset);
TestHelper.TestOperatorEquality(equal1, equal2, unequalByLocal);
}
/// <summary>
/// Initializes a new instance of the <see cref="SchemaExamples"/> class.
/// Creates example value by provided <see cref="DateTime"/> and <see cref="IDateTimeZoneProvider"/>.
/// </summary>
/// <param name="dateTimeZoneProvider">IDateTimeZoneProvider instance.</param>
/// <param name="dateTimeUtc"><see cref="DateTime"/>. If not set then <see cref="DateTime.UtcNow"/> will be used.</param>
/// <param name="dateTimeZone">Optional DateTimeZone name. If not set SystemDefault will be used.</param>
public SchemaExamples(
IDateTimeZoneProvider dateTimeZoneProvider,
DateTime?dateTimeUtc = null,
string?dateTimeZone = null)
{
DateTime dateTimeUtcValue = dateTimeUtc ?? DateTime.UtcNow;
if (dateTimeUtcValue.Kind != DateTimeKind.Utc)
{
throw new ArgumentException("dateTimeUtc should be UTC", nameof(dateTimeUtc));
}
if (dateTimeZone != null)
{
DateTimeZone = dateTimeZoneProvider.GetZoneOrNull(dateTimeZone) ?? dateTimeZoneProvider.GetSystemDefault();
}
else
{
DateTimeZone = dateTimeZoneProvider.GetSystemDefault();
}
Instant = Instant.FromDateTimeUtc(dateTimeUtcValue);
ZonedDateTime = Instant.InZone(DateTimeZone);
Interval = new Interval(Instant,
Instant.PlusTicks(TimeSpan.TicksPerDay)
.PlusTicks(TimeSpan.TicksPerHour)
.PlusTicks(TimeSpan.TicksPerMinute)
.PlusTicks(TimeSpan.TicksPerSecond)
.PlusTicks(TimeSpan.TicksPerMillisecond));
DateInterval = new DateInterval(ZonedDateTime.Date, ZonedDateTime.Date.PlusDays(1));
Period = Period.Between(ZonedDateTime.LocalDateTime, Interval.End.InZone(DateTimeZone).LocalDateTime, PeriodUnits.AllUnits);
OffsetDate = new OffsetDate(ZonedDateTime.Date, ZonedDateTime.Offset);
OffsetTime = new OffsetTime(ZonedDateTime.TimeOfDay, ZonedDateTime.Offset);
OffsetDateTime = Instant.WithOffset(ZonedDateTime.Offset);
}
public void LocalDateProperties()
{
LocalDate local = new LocalDate(2012, 6, 19, CalendarSystem.Julian);
Offset offset = Offset.FromHours(5);
OffsetDate od = new OffsetDate(local, offset);
var localDateProperties = typeof(LocalDate).GetTypeInfo()
.DeclaredProperties
.ToDictionary(p => p.Name);
var commonProperties = typeof(OffsetDate).GetTypeInfo()
.DeclaredProperties
.Where(p => localDateProperties.ContainsKey(p.Name));
foreach (var property in commonProperties)
{
Assert.AreEqual(localDateProperties[property.Name].GetValue(local, null),
property.GetValue(od, null));
}
}
protected override DateTimeOffset Wrap(OffsetDate value) => value.At(LocalTime.MinValue).ToDateTimeOffset();
public virtual void SupportsEquals(OffsetDate offsetDate)
{
SupportsPropertyOrMethod(x => x.Equals(offsetDate));
}
public OffsetDate Test(OffsetDate arg) => arg;
