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