public void UVPEqualsSerializationTest()
{
MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Probability = (decimal)0.0f;
aValue.Value = new MARC.Everest.DataTypes.INT(0);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void EV_1089ENXPParseTest()
{
EN myEn = EN.FromFamilyGiven(EntityNameUse.License, "Toet", "J");
myEn.Part[0].Qualifier = new SET<CS<EntityNamePartQualifier>>();
myEn.Part[1].Qualifier = new SET<CS<EntityNamePartQualifier>>();
myEn.Part[0].Qualifier.Add(EntityNamePartQualifier.Birth);
myEn.Part[1].Qualifier.Add(EntityNamePartQualifier.Initial);
String xmlString = R1SerializationHelper.SerializeAsString(myEn);
StringReader sr = new StringReader(xmlString);
DatatypeFormatter fmtr = new DatatypeFormatter();
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
while (rdr.NodeType != XmlNodeType.Element)
rdr.Read();
var result = fmtr.Parse(rdr, typeof(EN));
Assert.AreEqual(0, result.Details.Count(o=>o.Type == Connectors.ResultDetailType.Error));
}
public void PIVLEqualsSerializationTest()
{
MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Phase = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>(new MARC.Everest.DataTypes.INT(0));
aValue.Period = new MARC.Everest.DataTypes.PQ((decimal)0, "0");
aValue.Alignment = new System.Nullable<MARC.Everest.DataTypes.CalendarCycle>(MARC.Everest.DataTypes.CalendarCycle.Year);
aValue.InstitutionSpecified = false;
aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void ADEqualsSerializationTest()
{
MARC.Everest.DataTypes.AD aValue = new MARC.Everest.DataTypes.AD(), bValue = null;
aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.PostalAddressUse>>(0) { new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.PostalAddressUse>(MARC.Everest.DataTypes.PostalAddressUse.HomeAddress) };
aValue.IsNotOrdered = false;
aValue.Part.Add(new MARC.Everest.DataTypes.ADXP("123 Main Street West", MARC.Everest.DataTypes.AddressPartType.AddressLine));
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test", "urn:hl7-org:v3");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.AD>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.AD)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void TELEqualsSerializationTest()
{
MARC.Everest.DataTypes.TEL aValue = new MARC.Everest.DataTypes.TEL(), bValue = null;
aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse>>(0) { new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse>(MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse.Home) };
aValue.UseablePeriod = new MARC.Everest.DataTypes.GTS(new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.TS>(new MARC.Everest.DataTypes.TS(DateTime.Parse("2011-1-10"))));
aValue.Value = "0";
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.TEL>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.TEL)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void ADXPEqualsSerializationTest()
{
MARC.Everest.DataTypes.ADXP aValue = new MARC.Everest.DataTypes.ADXP(), bValue = null;
aValue.Value = "0";
aValue.Code = "0";
aValue.Type = new System.Nullable<MARC.Everest.DataTypes.AddressPartType>(MARC.Everest.DataTypes.AddressPartType.AddressLine);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.ADXP>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.ADXP)).Structure);
bValue.Type = MARC.Everest.DataTypes.AddressPartType.AddressLine;
Assert.AreEqual(aValue, bValue);
}
public void EIVLEqualsSerializationTest()
{
MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Event = new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.DomainTimingEventType>(MARC.Everest.DataTypes.DomainTimingEventType.BeforeMeal);
aValue.Offset = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.PQ>(new MARC.Everest.DataTypes.PQ((decimal)0, "0"));
aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void ENEqualsSerializationTest()
{
MARC.Everest.DataTypes.EN aValue = new MARC.Everest.DataTypes.EN(), bValue = null;
aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.EntityNameUse>>(MARC.Everest.DataTypes.EntityNameUse.Legal);
aValue.Flavor = "0";
aValue.Part.Add(new MARC.Everest.DataTypes.ENXP("Bob", MARC.Everest.DataTypes.EntityNamePartType.Given));
aValue.Part.Add(new MARC.Everest.DataTypes.ENXP("Dole", MARC.Everest.DataTypes.EntityNamePartType.Family));
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.EN>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.EN)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void COEqualsSerializationTest()
{
MARC.Everest.DataTypes.CO aValue = new MARC.Everest.DataTypes.CO(), bValue = null;
aValue.OriginalText = new MARC.Everest.DataTypes.ED(new System.Byte[] { 0 }, "0");
aValue.Code = new MARC.Everest.DataTypes.CD<System.String>("0");
aValue.Code.CodeSystem = "0";
aValue.Code.CodeSystemName = "0";
aValue.Code.CodeSystemVersion = "0";
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.CO>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.CO)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void IVLEqualsSerializationLowTest()
{
MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Low = new MARC.Everest.DataTypes.INT(0);
aValue.LowClosed = false;
//aValue.High = new MARC.Everest.DataTypes.INT(0);
//aValue.HighIncluded = false;
//aValue.Width = new MARC.Everest.DataTypes.PQ(0, "0");
aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void EDEqualsSerializationTest()
{
MARC.Everest.DataTypes.ED aValue = new MARC.Everest.DataTypes.ED(), bValue = null;
aValue.Data = new System.Byte[] { 0 };
aValue.Compression = new System.Nullable<MARC.Everest.DataTypes.Interfaces.EncapsulatedDataCompression>(MARC.Everest.DataTypes.Interfaces.EncapsulatedDataCompression.DF);
aValue.Representation = MARC.Everest.DataTypes.Interfaces.EncapsulatedDataRepresentation.TXT;
aValue.Language = "0";
aValue.MediaType = "0";
aValue.IntegrityCheck = new System.Byte[] { 0 };
aValue.IntegrityCheckAlgorithm = new System.Nullable<MARC.Everest.DataTypes.Interfaces.EncapsulatedDataIntegrityAlgorithm>(MARC.Everest.DataTypes.Interfaces.EncapsulatedDataIntegrityAlgorithm.SHA1);
aValue.Thumbnail = new MARC.Everest.DataTypes.ED(new System.Byte[] { 0 }, "0");
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.ED>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.ED)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void IIEqualsSerializationTest()
{
MARC.Everest.DataTypes.II aValue = new MARC.Everest.DataTypes.II(), bValue = null;
aValue.Root = "0";
aValue.Extension = "0";
aValue.Displayable = false;
aValue.Use = new System.Nullable<MARC.Everest.DataTypes.IdentifierUse>(MARC.Everest.DataTypes.IdentifierUse.Business);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.II>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.II)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void SXPRTSMixedComponentsFormatting()
{
SXPR<TS> test = SXPR<TS>.CreateSXPR(new IVL<TS>(DateTime.Now, DateTime.Now.AddDays(1)),
new PIVL<TS>(
new IVL<TS>(DateTime.Now, DateTime.Now.AddDays(1)),
new PQ((decimal)1.0, "y")
),
//new SXCM<TS>(DateTime.Now) { Operator = SetOperator.A },
new IVL<TS>(DateTime.Now) { Operator = SetOperator.Intersect },
new EIVL<TS>(DomainTimingEventType.BeforeLunch,
new IVL<PQ>(
new PQ((decimal)1.0, "d")
)
) { Operator = SetOperator.Inclusive });
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter();
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw));
xw.WriteStartElement("sxpr");
fmtr.Graph(xw, test);
xw.WriteEndElement(); // comp
xw.Flush();
Tracer.Trace(sw.ToString());
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
var parse = fmtr.Parse(rdr, typeof(SXPR<TS>)).Structure as SXPR<TS>;
Assert.AreEqual(parse.Count, test.Count);
for (int i = 0; i < parse.Count; i++)
Assert.AreEqual(parse[i].GetType(), test[i].GetType());
}
public void SXPRSTMixedComponentsFormatting()
{
SXPR<RTO<INT, INT>> test = SXPR<RTO<INT, INT>>.CreateSXPR(new IVL<RTO<INT,INT>>(new RTO<INT,INT>(1,3), new RTO<INT,INT>(2,3)),
new PIVL<RTO<INT,INT>>(
new IVL<RTO<INT,INT>>(new RTO<INT,INT>(2,3),new RTO<INT,INT>(5,6)),
new PQ((decimal)1.0, "y")
)
//new SXCM<RTO<INT,INT>>(new RTO<INT,INT>(1,2)) { Operator = SetOperator.A },
//new IVL<RTO<INT,INT>>(new RTO<INT,INT>(1,2)) { Operator = SetOperator.Intersect
);
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter();
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw));
xw.WriteStartElement("sxpr");
fmtr.Graph(xw, test);
xw.WriteEndElement(); // comp
xw.Flush();
Tracer.Trace(sw.ToString());
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
var parse = fmtr.Parse(rdr, typeof(SXPR<RTO<INT, INT>>)).Structure as SXPR<RTO<INT, INT>>;
Assert.AreEqual(parse.Count, test.Count);
for (int i = 0; i < parse.Count; i++)
Assert.AreEqual(parse[i].GetType(), test[i].GetType());
}
/// <summary>
/// Validate the MIF file
/// </summary>
public void ValidateMifFile(Stream fileStream, string fileName)
{
string mifDirectory = Path.Combine(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "schemas"), "mif2.1.4");
// First, validate the schema directory exists
if (context.Mode != Pipeline.OperationModeType.Strict)
{
Trace.Write("Not operating in strict mode, not applying MIF validation", "warn1");
return;
}
if (!Directory.Exists(mifDirectory))
throw new InvalidOperationException("Cannot find the MIF schemas, ensure that the Schemas\\mif2.1.4 directory exists");
// Load the schemas
if (m_schemas == null)
{
m_schemas = new XmlSchemaSet();
m_schemas.ValidationEventHandler += new ValidationEventHandler(m_schemas_ValidationEventHandler);
foreach (var file in Directory.GetFiles(mifDirectory, "*.xsd"))
{
XmlReader schemaReader = XmlReader.Create(file, new XmlReaderSettings() { ProhibitDtd = false });
try
{
m_schemas.Add("urn:hl7-org:v3/mif2", schemaReader);
}
finally
{
schemaReader.Close();
}
}
m_schemas.Compile();
}
// Sanity check
if (!m_schemas.IsCompiled)
throw new InvalidOperationException("The schema set must compile successfully for execution to continue");
// Reader
XmlStateReader xr = null;
try
{
// Create settings
var settings = new XmlReaderSettings()
{
ProhibitDtd = false,
ValidationType = ValidationType.Schema,
Schemas = m_schemas
};
// Is the object valid
bool isValid = true;
settings.ValidationEventHandler += new ValidationEventHandler(
delegate(object sender, ValidationEventArgs e)
{
Trace.WriteLine(String.Format("{0} : {1}", Path.GetFileName(fileName), e.Message), e.Severity == XmlSeverityType.Error ? "error" : "warn");
isValid &= e.Severity == XmlSeverityType.Warning;
}
);
// Create the reader
xr = new XmlStateReader(XmlReader.Create(fileStream, settings));
// Read
while (xr.Read()) ;
if (!isValid)
throw new XmlSchemaValidationException("File failed basic schema check");
}
finally
{
if (xr != null)
xr.Close();
}
}
public void IVLInclusiveParsingTest()
{
StringReader sr = new StringReader("<ivl xmlns=\"urn:hl7-org:v3\"><low inclusive=\"true\" value=\"1\" /><high inclusive=\"false\" value=\"4\" /></ivl>");
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
// Read to first node
while(rdr.NodeType != XmlNodeType.Element)
rdr.Read();
// Parse
MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter fmtr = new MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter();
IVL<INT> retVal = fmtr.Parse(rdr, typeof(IVL<INT>)).Structure as IVL<INT>;
Assert.IsTrue(retVal.HighClosed.HasValue);
Assert.IsTrue(retVal.LowClosed.HasValue);
Assert.IsFalse(retVal.HighClosed.Value);
Assert.IsTrue(retVal.LowClosed.Value);
}
