Support numeric uncertainty ranges, lists of numeric intervals, and lists of temporal intervals

[cmoesel]

NOTE: I updated this PR from the originally submitted PR to also include support for lists of temporal intervals.

This PR follows on to #109 and #110 by extending numeric interval extraction to numeric uncertainty ranges and lists of numeric intervals during result extraction, as well as extending temporal interval extraction to lists of temporal intervals.

Numeric Uncertainty Ranges

In this CQL testing framework, uncertainties are represented as intervals since CQL does not have a literal Uncertainty type. When these are serialized as FHIR operation results, they are represented as a parameter with a CQL type indicating the original scalar result type (e.g., Integer) and a FHIR Range indicating the uncertain range.

For example, the DateTimeUncertain test is defined to expect Interval[18,49] representing the uncertain range from 18 to 49:

<test name="DateTimeUncertain" version="1.0">
  <capability code="types" />
  <expression>days between DateTime(2015, 2, 10) and DateTime(2015, 3)</expression>
  <output>Interval [ 18, 49 ]</output>
</test>

CQL engines should return this result to the test runner using this serialization:

{
  "resourceType": "Parameters",
  "parameter": [{
    "extension": [{
      "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlType",
      "valueString": "System.Integer"
    }],
    "name": "return",
    "valueRange": {
      "low": { "value": 18, "system": "http://unitsofmeasure.org", "code": "1" },
      "high": { "value": 49, "system": "http://unitsofmeasure.org", "code": "1" }
    }
  }]
}

Prior to this PR, the test runner did not recognize this as a numeric interval because the cqf-cqlType is not one of Interval<System.Integer> | Interval<System.Long> | Interval<System.Decimal>. This PR now recognizes the pattern of a numeric cqf-cqlType with a valueRange as an uncertainty that should be processed as a numeric interval.

Lists of Numeric Intervals

The Using CQL IG specifies that list-typed results should be returned as an array of parameters, each of which indicates its cqf-cqlType using the list specifier (e.g., List<Integer>) and a value serialized as the contained type (e.g., valueInteger). This means that a list of Integer intervals should result in a list of parameters, each of which has cqf-cqlType List<Interval<Integer>> and a valueRange.

For example, the IntegerIntervalCollapse2 test is defined to expect a list containing Interval[1,19] as the result:

<test name="IntegerIntervalCollapse2" version="1.0">
  <capability code="interval-operators"/>
  <expression>collapse { Interval[1,2], Interval[3,7], Interval[10,19], Interval[7,10] }</expression>
  <output>{Interval [ 1, 19 ]}</output>
</test>

CQL engines should return this result to the test runner using this serialization:

{
  "resourceType": "Parameters",
  "parameter": [{
    "extension": [{
      "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlType",
      "valueString": "List<Interval<System.Integer>>"
    }],
    "name": "return",
    "valueRange": {
      "low": { "value": 1, "system": "http://unitsofmeasure.org", "code": "1" },
      "high": { "value": 19, "system": "http://unitsofmeasure.org", "code": "1" }
    }
  }]
}

Prior to this PR, the test runner did not recognize this as a numeric interval because the cqf-cqlType is not one of Interval<System.Integer> | Interval<System.Long> | Interval<System.Decimal>. This PR now strips the outer List (if it is there) before checking to see if the type is a numeric interval.

Lists of Temporal Intervals

Similar to the approach for lists of numeric intervals, lists of temporal intervals also indicate the list specifier type within each parameter. Following this, a list of Date intervals should result in a list of parameters, each of which has cqf-cqlType List<Interval<Date>> and a valuePeriod.

For example, the ExpandPer2Days test is defined to expect a list containing Interval[@2018-01-01, @2018-01-02] and Interval[@2018-01-03, @2018-01-04] as the result:

<test name="ExpandPer2Days" version="1.3">
  <capability code="interval-operators"/>
  <expression>expand { Interval[@2018-01-01, @2018-01-04] } per 2 days</expression>
  <output>{ Interval[@2018-01-01, @2018-01-02], Interval[@2018-01-03, @2018-01-04] }</output>
</test>

CQL engines should return this result to the test runner using this serialization:

{
  "resourceType": "Parameters",
  "parameter": [
    {
      "extension": [{
        "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlType",
        "valueString": "List<Interval<System.Date>>"
      }],
      "name": "return",
      "valuePeriod": {
        "start": "2018-01-01",
        "end": "2018-01-02"
      }
    },
    {
      "extension": [{
        "url": "http://hl7.org/fhir/StructureDefinition/cqf-cqlType",
        "valueString": "List<Interval<System.Date>>"
      }],
      "name": "return",
      "valuePeriod": {
        "start": "2018-01-03",
        "end": "2018-01-04"
      }
    }
  ]
}

Prior to this PR, the test runner did not recognize this as a temporal interval because the cqf-cqlType is not one of Interval<System.Date> | Interval<System.DateTime> | Interval<System.Time>. This PR now strips the outer List (if it is there) before checking to see if the type is a temporal interval.

Testing

This PR includes unit tests demonstrating these fixes, but if you have a compliant CQL server that returns numeric uncertainty ranges and lists of intervals as specified above, then you should note that tests resulting in those types now pass.