public void GivenAValidString_WhenParsed_ThenCorrectPartialDateTimeShouldBeCreated( string s, int year, int?month, int?day, int?hour, int?minute, int?second, decimal?fraction, int?utcOffsetInMinute) { PartialDateTime dateTime = PartialDateTime.Parse(s); Assert.NotNull(dateTime); Assert.Equal(year, dateTime.Year); Assert.Equal(month, dateTime.Month); Assert.Equal(day, dateTime.Day); Assert.Equal(hour, dateTime.Hour); Assert.Equal(minute, dateTime.Minute); Assert.Equal(second, dateTime.Second); Assert.Equal(fraction, dateTime.Fraction); TimeSpan?utcOffset = null; if (utcOffsetInMinute != null) { utcOffset = TimeSpan.FromMinutes(utcOffsetInMinute.Value); } Assert.Equal(utcOffset, dateTime.UtcOffset); }
public void DateTimeConstructor() { PartialDateTime.Parse("2012-03"); PartialDateTime.Parse("2012-03-04"); PartialDateTime.Parse("2012-03-04T12:34:34+02:00"); PartialDateTime.Parse("2012-03-04T12:34:34Z"); PartialDateTime pd; Assert.True(PartialDateTime.TryParse("2012-03", out pd)); Assert.Equal(pd, PartialDateTime.Parse("2012-03")); Assert.Equal("2012-03", pd.ToString()); Assert.False(PartialDateTime.TryParse("2012-03T12:34", out pd)); Assert.False(PartialDateTime.TryParse("20120304", out pd)); Assert.True(PartialDateTime.TryParse("2012-03-04T12:04:45", out pd)); //FHIR does not allow this, ISO8601 does. Assert.True(PartialDateTime.TryParse("2012-03-04T12:04:45Z", out pd)); Assert.False(PartialDateTime.TryParse("T12:04:45Z", out pd)); Assert.False(PartialDateTime.TryParse("12:04:45Z", out pd)); Assert.True(PartialDateTime.Parse("2012-03-04") > PartialDateTime.Parse("2012-03-01")); Assert.Equal(PartialDateTime.Today().ToString(), PartialDateTime.FromDateTime(DateTime.Today).ToString().Substring(0, 10)); Assert.Equal(PartialDateTime.Now().ToString().Substring(0, 19), PartialDateTime.FromDateTime(DateTimeOffset.Now).ToString().Substring(0, 19)); }
public void GivenAValidPartialDateTime_WhenToStringIsCalled_ThenCorrectStringShouldBeReturned(string input, string expected) { PartialDateTime dateTime = PartialDateTime.Parse(input); Assert.NotNull(dateTime); Assert.Equal(expected, dateTime.ToString()); }
public void GiveAStartDateTimeThatIsEarlierThanOrEqualToEndDateTime_WhenInitialized_ThenNoExceptionShouldBeThrown(string start, string end) { PartialDateTime startDateTime = PartialDateTime.Parse(start); PartialDateTime endDateTime = PartialDateTime.Parse(end); new DateTimeSearchValue(startDateTime, endDateTime); }
public void GivenAStartDateTimeLaterThanEndDateTime_WhenInitializing_ThenNoExceptionShouldBeThrown(string start, string end) { PartialDateTime startDateTime = PartialDateTime.Parse(start); PartialDateTime endDateTime = PartialDateTime.Parse(end); new DateTimeSearchValue(startDateTime, endDateTime); }
public void GivenAStartDateTimeLaterThanEndDateTime_WhenInitializing_ThenExceptionShouldBeThrown(string start, string end) { PartialDateTime startDateTime = PartialDateTime.Parse(start); PartialDateTime endDateTime = PartialDateTime.Parse(end); Assert.Throws <ArgumentOutOfRangeException>(ParamNameStartDateTime, () => new DateTimeSearchValue(startDateTime, endDateTime)); }
public void FhirPath_Lex_DateTime() { var parser = Lexer.DateTime.End(); accept("@2015-01T"); accept("@2015-01-02T12:34:00Z"); accept("@2015-01-03T12:34:34+02:30"); accept("@2015-01-03T12:34:34"); accept("@2015-01-01T23"); accept("@2015-01-01T"); accept("@2015-01-01T23Z"); accept("@2015-01-01T+01:00"); reject("@2015-01"); // must have a T suffix reject("@2015-01-02"); // since this is a date, not a dateTime reject("@2015-01-02+01:00"); // since this is a date, not a dateTime reject("T12:34:34+02:30"); reject("12:34:34+02:30"); reject("@T12:34:34+02:30"); reject("@12:34:34+02:30"); reject("@20150103T12:34:34+02:30"); reject("@-2015-01"); void accept(string s) => AssertParser.SucceedsMatch(parser, s, PartialDateTime.Parse(Lexer.CleanupDateTimeLiteral(s))); void reject(string s) => AssertParser.FailsMatch(parser, s); }
public void GivenAPartialDateTimeWithMissingComponents_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned() { const int expectedMonth = 2; const int expectedDay = 10; const int expectedHour = 15; const int expectedMinute = 13; const int expectedSecond = 12; const decimal expectedFraction = 0.3009953m; var expectedUtcOffset = TimeSpan.FromMinutes(30); var dateTime = PartialDateTime.Parse("2013"); var actualOffset = dateTime.ToDateTimeOffset( expectedMonth, (year, month) => expectedDay, expectedHour, expectedMinute, expectedSecond, expectedFraction, expectedUtcOffset); var expectedOffset = new DateTimeOffset( 2013, expectedMonth, expectedDay, expectedHour, expectedMinute, expectedSecond, expectedUtcOffset); expectedOffset = expectedOffset.AddTicks((long)(expectedFraction * TimeSpan.TicksPerSecond)); Assert.Equal(expectedOffset, actualOffset); }
public void GivenAPartialDateTimeWithNoMissingComponent_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned() { var dateTime = PartialDateTime.Parse("2013-10-12T23:01:35.9995555+02:00"); var actualOffset = dateTime.ToDateTimeOffset( 2, (year, month) => 10, 15, 13, 12, 0.300250m, TimeSpan.FromMinutes(30)); var expectedOffset = new DateTimeOffset( 2013, 10, 12, 23, 01, 35, TimeSpan.FromMinutes(120)); expectedOffset = expectedOffset.AddTicks((long)(0.9995555m * TimeSpan.TicksPerSecond)); Assert.Equal(expectedOffset, actualOffset); }
public override bool Equals(object obj) { if (obj is Date) { var other = (Date)obj; var otherValue = !Object.ReferenceEquals(other, null) ? other.Value : null; if (Value == null) { return(otherValue == null); } if (otherValue == null) { return(false); } if (this.Value == otherValue) { return(true); // Default reference/string comparison works in most cases } var left = PartialDateTime.Parse(Value); var right = PartialDateTime.Parse(otherValue); return(left == right); } else { return(false); } }
public async Task GivenAnEverythingOperationRequest_WhenValid_ThenProperResponseShouldBeReturned() { _mediator.Send(Arg.Any <EverythingOperationRequest>(), Arg.Any <CancellationToken>()).Returns(Task.FromResult(GetEverythingOperationResponse())); var result = await _everythingController.PatientEverythingById( idParameter : "123", start : PartialDateTime.Parse("2019"), end : PartialDateTime.Parse("2020"), since : PartialDateTime.Parse("2021"), type : ResourceType.Observation.ToString(), ct : null) as FhirResult; await _mediator.Received().Send( Arg.Is <EverythingOperationRequest>( r => string.Equals(r.EverythingOperationType, ResourceType.Patient.ToString(), StringComparison.Ordinal) && string.Equals(r.ResourceId.ToString(), "123", StringComparison.OrdinalIgnoreCase) && string.Equals(r.Start.ToString(), "2019", StringComparison.Ordinal) && string.Equals(r.End.ToString(), "2020", StringComparison.Ordinal) && string.Equals(r.Since.ToString(), "2021", StringComparison.Ordinal) && string.Equals(r.ResourceTypes, ResourceType.Observation.ToString(), StringComparison.Ordinal) && r.ContinuationToken == null), Arg.Any <CancellationToken>()); _mediator.ClearReceivedCalls(); var bundleResource = (result?.Result as ResourceElement)?.ResourceInstance as Bundle; Assert.Equal(System.Net.HttpStatusCode.OK, result?.StatusCode); Assert.Equal(Bundle.BundleType.Searchset, bundleResource?.Type); }
/// <summary> /// Parses the string value to an instance of <see cref="DateTimeSearchValue"/>. /// </summary> /// <param name="s">The string to be parsed.</param> /// <returns>An instance of <see cref="DateTimeSearchValue"/>.</returns> public static DateTimeSearchValue Parse(string s) { EnsureArg.IsNotNullOrWhiteSpace(s, nameof(s)); PartialDateTime dateTime = PartialDateTime.Parse(s); return(new DateTimeSearchValue(dateTime)); }
public void GivenACulture_WhenToStringisCalled_ThenCorrectStringShouldBeReturned(string culture, string input, string expected) { System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo(culture); PartialDateTime dateTime = PartialDateTime.Parse(input); Assert.NotNull(dateTime); Assert.Equal(expected, dateTime.ToString()); }
public void GivenHourIsSpecifiedWithoutMinutes_WhenParsingPartialDateTime_ThenFormatExceptionShouldBeThrown(string inputString) { Exception ex = Assert.Throws <FormatException>(() => PartialDateTime.Parse(inputString)); string expectedMessage = string.Format(Resources.DateTimeStringIsIncorrectlyFormatted, inputString); Assert.Equal(expectedMessage, ex.Message); }
public void GivenACulture_WhenToStringIsCalled_ThenCorrectStringShouldBeReturned(string culture, string inputString, string expectedString) { System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo(culture); var dateTime = PartialDateTime.Parse(inputString); Assert.NotNull(dateTime); Assert.Equal(expectedString, dateTime.ToString()); }
[InlineData("2013-05-18T23:57:09.999999999999999999999999+01:00")] // Fraction cannot be rounded up to 1 minute. public void GivenAOutOfRangeParameter_WhenInitializing_ThenFormatExceptionShouldBeThrown(string inputString) { Exception ex = Assert.Throws <FormatException>(() => PartialDateTime.Parse(inputString)); string expectedMessage = string.Format(Resources.DateTimeStringIsIncorrectlyFormatted, inputString); Assert.Equal(expectedMessage, ex.Message); }
public void TimeComparison() { Assert.True(PartialDateTime.Parse("2012-03-04T13:00:00Z") > PartialDateTime.Parse("2012-03-04T12:00:00Z")); Assert.True(PartialDateTime.Parse("2012-03-04T13:00:00Z") < PartialDateTime.Parse("2012-03-04T18:00:00+02:00")); Assert.True(Time.Parse("12:34:00+00:00") > Time.Parse("12:33:55+00:00")); Assert.True(Time.Parse("13:00:00+00:00") < Time.Parse("15:01:00+02:00")); Assert.True(Time.Parse("13:00:00+00:00") > Time.Parse("14:59:00+02:00")); }
/// <summary> /// Parses the string value to an instance of <see cref="DateTimeSearchValue"/>. /// </summary> /// <param name="startDateTime">The string to be parsed as start time.</param> /// <param name="endDateTime">The string to be parsed as end time.</param> /// <returns>An instance of <see cref="DateTimeSearchValue"/>.</returns> public static DateTimeSearchValue Parse(string startDateTime, string endDateTime) { EnsureArg.IsNotNullOrWhiteSpace(startDateTime, nameof(startDateTime)); EnsureArg.IsNotNullOrWhiteSpace(endDateTime, nameof(endDateTime)); PartialDateTime startPartial = PartialDateTime.Parse(startDateTime); PartialDateTime endPartial = PartialDateTime.Parse(endDateTime); return(new DateTimeSearchValue(startPartial, endPartial)); }
public void CheckOrdering() { Assert.Equal(1, PartialDateTime.Parse("2012-03-04T13:00:00Z").CompareTo(PartialDateTime.Parse("2012-03-04T12:00:00Z"))); Assert.Equal(-1, PartialDateTime.Parse("2012-03-04T13:00:00Z").CompareTo(PartialDateTime.Parse("2012-03-04T18:00:00+02:00"))); Assert.Equal(0, PartialDateTime.Parse("2015-01-01").CompareTo(PartialDateTime.Parse("2015-01-01"))); Assert.Equal(1, Time.Parse("12:34:00+00:00").CompareTo(Time.Parse("12:33:55+00:00"))); Assert.Equal(-1, Time.Parse("13:00:00+00:00").CompareTo(Time.Parse("15:01:00+02:00"))); Assert.Equal(0, Time.Parse("13:45:02+01:00").CompareTo(Time.Parse("13:45:02+01:00"))); }
public void TestFhirPathTrace() { var patient = new Hl7.Fhir.Model.Patient() { Id = "pat45", Active = false }; patient.Meta = new Meta() { LastUpdated = new DateTimeOffset(2018, 5, 24, 14, 48, 0, TimeSpan.Zero) }; var nav = patient.ToTypedElement(); EvaluationContext ctx = new FhirEvaluationContext(); var result = nav.Select("Resource.meta.trace('log').lastUpdated", ctx); Assert.IsNotNull(result.FirstOrDefault()); Assert.AreEqual(PartialDateTime.Parse("2018-05-24T14:48:00+00:00"), result.First().Value); bool traced = false; ctx.Tracer = (string name, System.Collections.Generic.IEnumerable <ITypedElement> results) => { System.Diagnostics.Trace.WriteLine($"{name}"); Assert.AreEqual("log", name); foreach (ITypedElement item in results) { var fhirValue = item.Annotation <IFhirValueProvider>(); System.Diagnostics.Trace.WriteLine($"--({fhirValue.FhirValue.GetType().Name}): {item.Value} {fhirValue.FhirValue}"); Assert.AreEqual(patient.Meta, fhirValue.FhirValue); traced = true; } }; result = nav.Select("Resource.meta.trace('log').lastUpdated", ctx); Assert.IsNotNull(result.FirstOrDefault()); Assert.AreEqual(PartialDateTime.Parse("2018-05-24T14:48:00+00:00"), result.First().Value); Assert.IsTrue(traced); traced = false; ctx.Tracer = (string name, System.Collections.Generic.IEnumerable <ITypedElement> results) => { System.Diagnostics.Trace.WriteLine($"{name}"); Assert.IsTrue(name == "id" || name == "log"); foreach (ITypedElement item in results) { var fhirValue = item.Annotation <IFhirValueProvider>(); System.Diagnostics.Trace.WriteLine($"--({fhirValue.FhirValue.GetType().Name}): {item.Value} {fhirValue.FhirValue}"); traced = true; } }; result = nav.Select("Resource.trace('id', id).meta.trace('log', lastUpdated).lastUpdated", ctx); Assert.IsNotNull(result.FirstOrDefault()); Assert.AreEqual(PartialDateTime.Parse("2018-05-24T14:48:00+00:00"), result.First().Value); Assert.IsTrue(traced); }
public void GivenAPartialDateTime_WhenInitialized_ThenCorrectStartDateTimeAndEndDateTimeShouldBeAssigned(string input, string start, string end) { PartialDateTime inputDateTime = PartialDateTime.Parse(input); DateTimeOffset expectedStartDateTime = DateTimeOffset.Parse(start); DateTimeOffset expectedEndDateTime = DateTimeOffset.Parse(end); DateTimeSearchValue value = new DateTimeSearchValue(inputDateTime); Assert.Equal(expectedStartDateTime, value.Start); Assert.Equal(expectedEndDateTime, value.End); }
public Hl7.FhirPath.PartialDateTime?ToPartialDateTime() { if (Value != null) { return(PartialDateTime.Parse(Value)); } else { return(null); } }
public void ConvertToString() { var inputs = ElementNode.CreateList("hoi", 4L, 3.4m, true, false, PartialTime.Parse("15:47:00+01:00"), PartialDateTime.Parse("2019-01-11T15:47:00+01:00")); var vals = new[] { "hoi", "4", "3.4", "true", "false", "15:47:00+01:00", "2019-01-11T15:47:00+01:00" }; inputs.Zip(vals, (i, v) => (i, v)) .ToList() .ForEach(c => Assert.AreEqual(c.v, c.i.ToString())); inputs.ToList().ForEach(c => Assert.IsTrue(c.ConvertsToString())); }
protected override IEnumerable <ISearchValue> ConvertTo(Period value) { PartialDateTime start = string.IsNullOrWhiteSpace(value.Start) ? PartialDateTime.MinValue : PartialDateTime.Parse(value.Start); PartialDateTime end = string.IsNullOrWhiteSpace(value.End) ? PartialDateTime.MaxValue : PartialDateTime.Parse(value.End); yield return(new DateTimeSearchValue(start, end)); }
public void TimeEquality() { Assert.True(PartialDateTime.Parse("2015-01-01") == PartialDateTime.Parse("2015-01-01")); Assert.True(PartialDateTime.Parse("2015-01-01") != PartialDateTime.Parse("2015-01")); Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+02:00") == PartialDateTime.Parse("2015-01-01T13:40:50+02:00")); Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+00:00") == PartialDateTime.Parse("2015-01-01T13:40:50Z")); Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+00:10") != PartialDateTime.Parse("2015-01-01T13:40:50Z")); Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+00:10") != PartialDateTime.Parse("2015-01-01")); Assert.True(Time.Parse("13:45:02Z") == Time.Parse("13:45:02+00:00")); Assert.True(Time.Parse("13:45:02+01:00") == Time.Parse("13:45:02+01:00")); Assert.True(Time.Parse("13:45:02+00:00") != Time.Parse("13:45:02+01:00")); }
public void GivenADateWithComparatorOfSingleBinaryOperator_WhenBuilt_ThenCorrectExpressionShouldBeCreated(string prefix, string dateTimeInput, FieldName fieldName, BinaryOperator binaryOperator, bool expectStartTimeValue) { var partialDateTime = PartialDateTime.Parse(dateTimeInput); var dateTimeSearchValue = new DateTimeSearchValue(partialDateTime); Validate( CreateSearchParameter(SearchParamType.Date), null, prefix + dateTimeInput, e => ValidateDateTimeBinaryOperatorExpression( e, fieldName, binaryOperator, expectStartTimeValue ? dateTimeSearchValue.Start : dateTimeSearchValue.End)); }
public void GivenADateWithNeComparator_WhenBuilt_ThenCorrectExpressionShouldBeCreated(string dateTimeInput) { var partialDateTime = PartialDateTime.Parse(dateTimeInput); var dateTimeSearchValue = new DateTimeSearchValue(partialDateTime); Validate( CreateSearchParameter(SearchParamType.Date), null, "ne" + dateTimeInput, e => ValidateMultiaryExpression( e, MultiaryOperator.Or, e1 => ValidateDateTimeBinaryOperatorExpression(e1, FieldName.DateTimeStart, BinaryOperator.LessThan, dateTimeSearchValue.Start), e2 => ValidateDateTimeBinaryOperatorExpression(e2, FieldName.DateTimeEnd, BinaryOperator.GreaterThan, dateTimeSearchValue.End))); }
public void GivenADateTimeSearchValue_WhenGenerated_ThenCorrectJObjectShouldBeCreated() { var value = new DateTimeSearchValue(PartialDateTime.Parse("2000"), PartialDateTime.Parse("2001")); var expectedValues = new[] { CreateTuple("st", "2000-01-01T00:00:00.0000000+00:00"), CreateTuple("et", "2001-12-31T23:59:59.9999999+00:00"), }; TestAndValidateOutput( "date", value, expectedValues); }
public void TestCompare() { Assert.Equal(0, MinMaxValidationExtensions.Compare(PartialDateTime.Parse("1972-11-30"), new Model.FhirDateTime(1972, 11, 30))); Assert.Equal(1, MinMaxValidationExtensions.Compare(PartialDateTime.Parse("1972-12-01"), new Model.Date(1972, 11, 30))); Assert.Equal(-1, MinMaxValidationExtensions.Compare(PartialDateTime.Parse("1972-12-01T13:00:00Z"), new Model.Instant(new DateTimeOffset(1972, 12, 01, 14, 00, 00, TimeSpan.Zero)))); Assert.Equal(0, MinMaxValidationExtensions.Compare(Hl7.FhirPath.Time.Parse("12:00:00Z"), new Model.Time("12:00:00Z"))); Assert.Equal(1, MinMaxValidationExtensions.Compare(3.14m, new Model.FhirDecimal(2.14m))); Assert.Equal(-1, MinMaxValidationExtensions.Compare(-3L, new Model.Integer(3))); Assert.Equal(-1, MinMaxValidationExtensions.Compare("aaa", new Model.FhirString("bbb"))); Assert.Equal(1, MinMaxValidationExtensions.Compare(new Hl7.FhirPath.Quantity(5.0m, "kg"), new Model.Quantity(4.0m, "kg"))); Assert.Throws <NotSupportedException>(() => MinMaxValidationExtensions.Compare(PartialDateTime.Parse("1972-11-30"), new Model.Quantity(4.0m, "kg"))); }
protected override IEnumerable <ISearchValue> Convert(ITypedElement value) { var startString = value.Scalar("start")?.ToString(); var endString = value.Scalar("end")?.ToString(); PartialDateTime start = string.IsNullOrWhiteSpace(startString) ? PartialDateTime.MinValue : PartialDateTime.Parse(startString); PartialDateTime end = string.IsNullOrWhiteSpace(endString) ? PartialDateTime.MaxValue : PartialDateTime.Parse(endString); yield return(new DateTimeSearchValue(start, end)); }