public void Iso8601ToInstantPassedValidValueReturnsCorrectResult(string testValue, Instant expectedValue)
{
var result = NodaTimeConverter.Iso8601ToInstant(testValue,
Iso8601ParseOptions.AllowBeginningOfTime | Iso8601ParseOptions.AllowEndOfTime);
Assert.That(result, Is.EqualTo(expectedValue));
}
public void ToOffsetDateTime_AndToDateTimeOffset_ConvertsMaxInstantToMaxDateTimeOffset(Offset offset)
{
var offsetDateTime = NodaTimeConverter.ToOffsetDateTime(Instant.MaxValue, offset);
var dateTimeOffset = NodaTimeConverter.ToDateTimeOffset(offsetDateTime);
dateTimeOffset.Should().Be(DateTimeOffset.MaxValue);
}
public void ToDateTimeUtc_ThenToInstant_ReturnsSameValue(Instant expected)
{
var dateTime = NodaTimeConverter.ToDateTimeUtc(expected);
var actual = NodaTimeConverter.UtcDateTimeToInstant(dateTime);
Assert.That(actual, Is.EqualTo(expected));
}
public void UtcDateTimeAllowingUnspecifiedKindToInstant_WithUnspecifiedDateTimeKind_IsTreatedAsUtc()
{
var input = new DateTime(2000, 01, 01, 00, 00, 00, DateTimeKind.Unspecified);
var output = NodaTimeConverter.UtcDateTimeAllowingUnspecifiedKindToInstant(input);
Assert.That(output.ToDateTimeUtc(), Is.EqualTo(input));
}
public void OffsetToHours_WithValueInAllowedRange_ConvertsCorrectly(double expectedUtcOffsetInHours, long offsetInTicks)
{
var offset = Offset.FromTicks(offsetInTicks);
var actual = NodaTimeConverter.OffsetToHours(offset);
actual.ShouldBeEquivalentTo(expectedUtcOffsetInHours);
}
public void OffsetToHours_WithOffsetGreaterThanAllowedMaximum_Throws()
{
var offsetGreaterThanAllowedMaximum = Offset.FromHours(15);
Action action = () => NodaTimeConverter.OffsetToHours(offsetGreaterThanAllowedMaximum);
action.ShouldThrow <ArgumentOutOfRangeException>();
}
public void HoursToOffsetPassedValueGreaterThanMaximumAllowedOffsetThrows()
{
const double utcOffsetGreaterThanMaximum = 15.0;
TestDelegate testDelegate = () => NodaTimeConverter.HoursToOffset(utcOffsetGreaterThanMaximum);
Assert.That(testDelegate, Throws.TypeOf <ArgumentOutOfRangeException>());
}
public void ToOffsetDateTime_GivenInstant_ReturnsExpected(Offset offset)
{
var time = _fixture.Create <Instant>();
var offsetDateTime = NodaTimeConverter.ToOffsetDateTime(time, offset);
offsetDateTime.ToInstant().Should().Be(time);
offsetDateTime.Offset.Should().Be(offset);
}
public void ToDateTimeOffset_GivenMaxOffsetDateTime_ReturnsDateTimeOffsetMaxValue()
{
var maxOffsetDateTime = NodaTimeConverter.MaxOffsetDateTime;
var maxDateTimeOffset = NodaTimeConverter.ToDateTimeOffset(maxOffsetDateTime);
maxDateTimeOffset.DateTime.Should().Be(NodaTimeConverter.MaxDateTimeUtc);
maxDateTimeOffset.Should().Be(DateTimeOffset.MaxValue);
}
public void ToDateTimeOffset_GivenMaxDateTimeInstant_WithZeroOffset_Throws()
{
var maxDateTimeInstant = NodaTimeConverter.MaxDateTimeInstant;
var offsetDateTimeWithMaxInstant = NodaTimeConverter.ToOffsetDateTime(maxDateTimeInstant, Offset.Zero);
Action toDateTimeOffset = () => NodaTimeConverter.ToDateTimeOffset(offsetDateTimeWithMaxInstant);
toDateTimeOffset.ShouldThrow <ArgumentOutOfRangeException>();
}
public void ToDateTimeOffsetUtc_ReturnsExpectedValueWithOffsetZero()
{
var expected = new DateTimeOffset(2001, 01, 02, 03, 04, 05, TimeSpan.FromHours(-8));
var instant = Instant.FromDateTimeOffset(expected);
var actual = NodaTimeConverter.InstantToDateTimeOffsetUtc(instant);
Assert.That(actual, Is.EqualTo(expected));
Assert.That(actual.Offset, Is.EqualTo(TimeSpan.Zero));
}
public void ToDateTimeOffset_GivenOffsetDateTime_ReturnsExpected(Offset offset)
{
var instant = _fixture.Create <Instant>();
var offsetDateTime = instant.WithOffset(offset);
var dateTimeOffset = NodaTimeConverter.ToDateTimeOffset(offsetDateTime);
Instant.FromDateTimeOffset(dateTimeOffset).Should().Be(instant);
Offset.FromTicks(dateTimeOffset.Offset.Ticks).Should().Be(offset);
}
public void HoursToOffsetPassedValueWithinAllowedRangeReturnsCorrectResult(double testUtcOffset, long expectedResultInTicks)
{
var result = NodaTimeConverter.HoursToOffset(testUtcOffset);
Assert.That(result, Is.EqualTo(Offset.FromTicks(expectedResultInTicks)));
}
public void ToDateTimeUtc_ConvertsDateTimeCorrectly()
{
Assert.That(NodaTimeConverter.ToDateTimeUtc(Instant0101), Is.EqualTo(DateTimeUtc0101));
}
public void Iso8601ToInstantPassedInvalidValueThrowsArgumentException(string testValue, Iso8601ParseOptions options)
{
Assert.That(() => NodaTimeConverter.Iso8601ToInstant(testValue, options), Throws.ArgumentException);
}
public void UtcDateTimeToInstant_ThrowsIfDateTimeIsNotUtcKind()
{
var dateTime = new DateTime(2001, 01, 02);
Assert.That(() => NodaTimeConverter.UtcDateTimeToInstant(dateTime), Throws.TypeOf <ArgumentException>());
}
public void ToOffsetDateTime_GivenMaxValue_ReturnsMaxOffsetDateTime(Offset offset)
{
var maxOffsetDateTime = NodaTimeConverter.ToOffsetDateTime(Instant.MaxValue, offset);
maxOffsetDateTime.Should().Be(NodaTimeConverter.MaxOffsetDateTime);
}
public void ToOffsetDateTime_GivenMinValue_ReturnsOffsetDateTime_WithMinInstantValue(Offset offset)
{
var minOffsetDateTime = NodaTimeConverter.ToOffsetDateTime(Instant.MinValue, offset);
minOffsetDateTime.ToInstant().Should().Be(Instant.MinValue);
}
public void ToNullableDateTimeUtc_MaxValue_ConvertsToNull()
{
var dateTimeUtc = NodaTimeConverter.ToNullableDateTimeUtc(Instant.MaxValue);
dateTimeUtc.ShouldBeEquivalentTo(null);
}
public void ToDateTimeUtc_WithValuesOutsideOfRange_Throws(Instant input)
{
Assert.That(() => NodaTimeConverter.ToDateTimeUtc(input), Throws.TypeOf <ArgumentOutOfRangeException>());
}
public void UtcDateTimeToInstant_ConvertsMaxDateTimeUtcToInstantMaxValue()
{
Assert.That(NodaTimeConverter.UtcDateTimeToInstant(MaxDateTimeUtc), Is.EqualTo(Instant.MaxValue));
}
public void ToDateTimeUtc_ConvertsMaxInstantToMaxDateTimeUtc()
{
Assert.That(NodaTimeConverter.ToDateTimeUtc(Instant.MaxValue), Is.EqualTo(MaxDateTimeUtc));
}
public void ToNullableDateTimeUtc_NullInstant_ConvertsToNullDateTime()
{
var dateTimeUtc = NodaTimeConverter.ToNullableDateTimeUtc(null);
dateTimeUtc.ShouldBeEquivalentTo(null);
}
public void ToNullableDateTimeUtc_ValuesOutsideOfRange_Throws(Instant input)
{
Action action = () => NodaTimeConverter.ToNullableDateTimeUtc(input);
action.ShouldThrow <ArgumentOutOfRangeException>();
}
public void NullableUtcDateTimeToNullableInstant_GivenNull_ReturnsNull()
{
var result = NodaTimeConverter.NullableUtcDateTimeToNullableInstant(null);
Assert.That(result, Is.Null);
}
public void ToNullableDateTimeUtc_ConvertToDateTimeCorrectly()
{
var dateTimeUtc = NodaTimeConverter.ToNullableDateTimeUtc(Instant0101);
dateTimeUtc.ShouldBeEquivalentTo(DateTimeUtc0101);
}
public void NullableUtcDateTimeToDefaultEndOfTimeInstant_WithNull_ReturnsMaxInstant()
{
var output = NodaTimeConverter.NullableUtcDateTimeToDefaultEndOfTimeInstant(null);
Assert.That(output, Is.EqualTo(Instant.MaxValue));
}
