public void OffsetDateTimeConverter()
{
var value = new LocalDateTime(2012, 1, 2, 3, 4, 5, 6, 7).WithOffset(Offset.FromHoursAndMinutes(-1, -30));
string json = "\"2012-01-02T03:04:05.0060007-01:30\"";
AssertConversions(value, json, NodaConverters.OffsetDateTimeConverter);
}
public void OffsetConverter()
{
var value = Offset.FromHoursAndMinutes(5, 30);
string json = "\"+05:30\"";
AssertConversions(value, json, NodaConverters.OffsetConverter);
}
public void OffsetConverter()
{
var value = Offset.FromHoursAndMinutes(5, 30);
string json = "+05:30";
this.AssertCsvSerialization(value, json, NodatimeConverters.OffsetConverter);
}
public void Can_Write_And_Read_A_Null_Offset_Stored_As_Time()
{
Offset startOffset = Offset.FromHoursAndMinutes(-1, -30);
var testEvent = new OffsetTestEntity
{
Description = "Can_Write_And_Read_A_Null_Offset_Stored_As_Time",
StartOffset = startOffset,
FinishOffset = null
};
using (ISession session = SessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(testEvent);
transaction.Commit();
}
OffsetTestEntity retrievedEvent;
using (ISession session = SessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
retrievedEvent = session.Get <OffsetTestEntity>(testEvent.Id);
transaction.Commit();
}
Assert.That(retrievedEvent.StartOffset, Is.EqualTo(testEvent.StartOffset));
Assert.That(retrievedEvent.FinishOffset, Is.EqualTo(testEvent.FinishOffset));
}
public void OffsetDateConverter()
{
var value = new LocalDate(2012, 1, 2).WithOffset(Offset.FromHoursAndMinutes(-1, -30));
string json = "\"2012-01-02-01:30\"";
AssertConversions(value, json, NodaConverters.OffsetDateConverter);
}
public void OffsetDateTimeConverter()
{
var value = new LocalDateTime(2012, 1, 2, 3, 4, 5, 6).WithOffset(Offset.FromHoursAndMinutes(-1, -30) + Offset.FromMilliseconds(-1234));
string json = "2012-01-02T03:04:05.006-01:30:01";
AssertConversions(value, json, NodaSerializerDefinitions.OffsetDateTimeSerializer);
}
public void TimeTz()
{
using (var conn = OpenConnection())
{
var time = new LocalTime(1, 2, 3, 4).PlusNanoseconds(5000);
var offset = Offset.FromHoursAndMinutes(3, 30) + Offset.FromSeconds(5);
var expected = new OffsetTime(time, offset);
using (var cmd = new NpgsqlCommand("SELECT @p1, @p2", conn))
{
cmd.Parameters.Add(new NpgsqlParameter("p1", NpgsqlDbType.TimeTz)
{
Value = expected
});
cmd.Parameters.Add(new NpgsqlParameter {
ParameterName = "p2", Value = expected
});
using (var reader = cmd.ExecuteReader())
{
reader.Read();
for (var i = 0; i < cmd.Parameters.Count; i++)
{
Assert.That(reader.GetFieldType(i), Is.EqualTo(typeof(OffsetTime)));
Assert.That(reader.GetFieldValue <OffsetTime>(i), Is.EqualTo(expected));
Assert.That(reader.GetValue(i), Is.EqualTo(expected));
}
}
}
}
}
public void OffsetConverter()
{
var value = Offset.FromHoursAndMinutes(5, 30);
string json = "+05:30";
AssertConversions(value, json, NodaSerializerDefinitions.OffsetSerializer);
}
public TimestampMessage(LocalDate baseDate, string rawMessage)
{
var match = LogRegex.TimestampMessage.Match(rawMessage);
if (!match.Success)
{
throw new Exception("Not a timestamp message");
}
if (match.Groups.Count < 6)
{
throw new Exception("Unexpected number of captures");
}
int hour, minute, second, offset;
if (!int.TryParse(match.Groups[1].Value, out hour) ||
!int.TryParse(match.Groups[2].Value, out minute) ||
!int.TryParse(match.Groups[3].Value, out second) ||
!int.TryParse(match.Groups[4].Value, out offset))
{
throw new Exception("Error extracting time values");
}
int hours = offset / 100;
int minutes = offset % 100;
Offset tsOffset = Offset.FromHoursAndMinutes(hours, minutes);
var localDateTime = new LocalDateTime(baseDate.Year, baseDate.Month, baseDate.Day, hour, minute, second);
Timestamp = new OffsetDateTime(localDateTime, tsOffset);
RawContent = match.Groups[5].Value.Trim();
}
public void With_TimeAdjuster()
{
Offset offset = Offset.FromHoursAndMinutes(2, 30);
OffsetDateTime start = new LocalDateTime(2014, 6, 27, 12, 15, 8, 100, 1234).WithOffset(offset);
OffsetDateTime expected = new LocalDateTime(2014, 6, 27, 12, 15, 8).WithOffset(offset);
Assert.AreEqual(expected, start.With(TimeAdjusters.TruncateToSecond));
}
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 BinarySerialization()
{
var time = new LocalTime(5, 6, 7).PlusNanoseconds(123456789L);
var offset = Offset.FromHoursAndMinutes(5, 30);
var value = new OffsetTime(time, offset);
TestHelper.AssertBinaryRoundtrip(value);
}
public void FormatPartial()
{
var builder = new StringBuilder("x");
var offset = Offset.FromHoursAndMinutes(20, 30);
SimpleOffsetPattern.FormatPartial(offset, builder);
Assert.AreEqual("x20:30", builder.ToString());
}
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 With_DateAdjuster()
{
Offset offset = Offset.FromHoursAndMinutes(2, 30);
OffsetDateTime start = new LocalDateTime(2014, 6, 27, 12, 5, 8).PlusNanoseconds(123456789).WithOffset(offset);
OffsetDateTime expected = new LocalDateTime(2014, 6, 30, 12, 5, 8).PlusNanoseconds(123456789).WithOffset(offset);
Assert.AreEqual(expected, start.With(DateAdjusters.EndOfMonth));
}
public void ToOffsetTime()
{
var offset = Offset.FromHoursAndMinutes(2, 30);
var odt = new LocalDateTime(2014, 6, 27, 12, 15, 8).PlusNanoseconds(123456789).WithOffset(offset);
var expected = new OffsetTime(new LocalTime(12, 15, 8).PlusNanoseconds(123456789), offset);
Assert.AreEqual(expected, odt.ToOffsetTime());
}
public void AppendFormat()
{
var builder = new StringBuilder("x");
var offset = Offset.FromHoursAndMinutes(17, 30);
SimpleOffsetPattern.AppendFormat(offset, builder);
Assert.AreEqual("x17:30", builder.ToString());
}
public void ToString_PartHourOffset()
{
LocalDateTime local = new LocalDateTime(2012, 10, 6, 1, 2, 3);
Offset offset = Offset.FromHoursAndMinutes(1, 30);
OffsetDateTime odt = new OffsetDateTime(local, offset);
Assert.AreEqual("2012-10-06T01:02:03+01:30", odt.ToString());
}
public void For_Id_FixedOffset()
{
string id = "UTC+05:30";
DateTimeZone zone = FixedDateTimeZone.GetFixedZoneOrNull(id) !;
Assert.AreEqual(DateTimeZone.ForOffset(Offset.FromHoursAndMinutes(5, 30)), zone);
Assert.AreEqual(id, zone.Id);
}
/// <summary>
/// Перевод из времени с временным смещением в UTC.
/// </summary>
/// <param name="dateTime">Время с учетом временного смещения.</param>
/// <param name="offsetInMinutes">Времянное смещение в минутах.</param>
/// <returns>Время в UTC-формате.</returns>
public static DateTime ConvertToUtc(DateTime dateTime, int offsetInMinutes)
{
var offset = Offset.FromHoursAndMinutes(0, offsetInMinutes);
var localDateTime = LocalDateTime.FromDateTime(dateTime);
return(new OffsetDateTime(localDateTime, offset).ToInstant()
.ToDateTimeUtc());
}
public void WithOffset()
{
var offset = Offset.FromHoursAndMinutes(5, 10);
var localDateTime = new LocalDateTime(2009, 12, 22, 21, 39, 30);
var offsetDateTime = localDateTime.WithOffset(offset);
Assert.AreEqual(localDateTime, offsetDateTime.LocalDateTime);
Assert.AreEqual(offset, offsetDateTime.Offset);
}
/// <summary>
/// Перевод времени из UTC во время со смещением.
/// </summary>
/// <param name="dateTime">Время в UTC-формате.</param>
/// <param name="offsetInMinutes">Времянное смешение в минутах.</param>
/// <returns>Время с учетом временного смещения.</returns>
public static DateTime ConvertFromUtc(DateTime dateTime, int offsetInMinutes)
{
var offset = Offset.FromHoursAndMinutes(0, offsetInMinutes);
var instant = Instant.FromDateTimeUtc(dateTime);
return(instant.WithOffset(offset)
.LocalDateTime
.ToDateTimeUnspecified());
}
public void ToInstant()
{
Instant instant = Instant.FromUtc(2012, 6, 25, 16, 5, 20);
LocalDateTime local = new LocalDateTime(2012, 6, 25, 21, 35, 20);
Offset offset = Offset.FromHoursAndMinutes(5, 30);
OffsetDateTime odt = new OffsetDateTime(local, offset);
Assert.AreEqual(instant, odt.ToInstant());
}
public void OffsetArrayTest()
{
Offset[] offSet = new Offset[]
{ Offset.FromHoursAndMinutes(1, 3),
Offset.FromSeconds(80),
Offset.FromMilliseconds(200),
Offset.FromHours(3),
Offset.FromNanoseconds(99) };
Assert.Equal(TestTools.Convert(offSet), offSet);
}
public void GenerateSqlLiteral_returns_offset_time_literal()
{
var mapping = GetMapping(typeof(OffsetTime));
Assert.Equal("TIMETZ '10:31:33+02'", mapping.GenerateSqlLiteral(
new OffsetTime(new LocalTime(10, 31, 33), Offset.FromHours(2))));
Assert.Equal("TIMETZ '10:31:33-02:30'", mapping.GenerateSqlLiteral(
new OffsetTime(new LocalTime(10, 31, 33), Offset.FromHoursAndMinutes(-2, -30))));
Assert.Equal("TIMETZ '10:31:33.666666Z'", mapping.GenerateSqlLiteral(
new OffsetTime(new LocalTime(10, 31, 33, 666) + Period.FromTicks(6660), Offset.Zero)));
}
public void Equals()
{
var offset1 = Offset.FromHoursAndMinutes(1, 30);
var inequalOffset = Offset.FromHours(2);
var unequal = Snippet.For(offset1.Equals(inequalOffset));
var equal = offset1.Equals(offset1);
Assert.False(unequal);
Assert.True(equal);
}
public void FixedOffsetSucceedsWithoutConsultingSourceWhenAdvertised()
{
string id = "UTC+05:30";
var source = new TestDateTimeZoneSource("Test1", "Test2", id);
var provider = new DateTimeZoneCache(source);
DateTimeZone zone = provider[id];
Assert.AreEqual(DateTimeZone.ForOffset(Offset.FromHoursAndMinutes(5, 30)), zone);
Assert.AreEqual(id, zone.Id);
Assert.IsNull(source.LastRequestedId);
}
public void XmlSerialization(
int hour, int minute, int second, long nanoseconds,
int offsetHours, int offsetMinutes,
string expected)
{
var time = new LocalTime(hour, minute, second).PlusNanoseconds(nanoseconds);
var offset = Offset.FromHoursAndMinutes(offsetHours, offsetMinutes);
var value = new OffsetTime(time, offset);
TestHelper.AssertXmlRoundtrip(value, $"<value>{expected}</value>");
}
public void ToDateTimeOffset_TruncatedOffset(int hours, int minutes, int seconds)
{
var ldt = new LocalDateTime(2017, 1, 9, 21, 45, 20);
var offset = Offset.FromHoursAndMinutes(hours, minutes).Plus(Offset.FromSeconds(seconds));
var odt = ldt.WithOffset(offset);
var dto = odt.ToDateTimeOffset();
// We preserve the local date/time, so the instant will move forward as the offset
// is truncated.
Assert.AreEqual(new DateTime(2017, 1, 9, 21, 45, 20, DateTimeKind.Unspecified), dto.DateTime);
Assert.AreEqual(TimeSpan.FromHours(hours) + TimeSpan.FromMinutes(minutes), dto.Offset);
}
public void ParsePartial_ValidAtEnd()
{
var value = new ValueCursor("x17:30");
value.MoveNext();
value.MoveNext();
var result = SimpleOffsetPattern.ParsePartial(value);
Assert.AreEqual(Offset.FromHoursAndMinutes(17, 30), result.Value);
// Finish just after the value, which in this case is at the end.
Assert.AreEqual(TextCursor.Nul, value.Current);
}
