public void testConstraintBindingWithMultiTerminologies()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.constraint_binding.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
java.util.List list = archetype.getOntology().getConstraintBindingList();
Assert.AreEqual(2, list.size(), "unexpected number of onotology binding");
// verify the first constraint binding
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)list.get(0);
Assert.AreEqual("SNOMED_CT", binding.getTerminology(), "unexpected binding terminology");
org.openehr.am.archetype.ontology.QueryBindingItem item = (org.openehr.am.archetype.ontology.QueryBindingItem)binding.getBindingList().get(0);
Assert.AreEqual("ac0001", item.getCode(), "unexpected local code");
Assert.AreEqual("http://terminology.org?terminology_id=snomed_ct&&has_relation=102002;with_target=128004", item.getQuery().getUrl(), "exexpected query");
// verify the second constraint binding
binding = (org.openehr.am.archetype.ontology.OntologyBinding)list.get(1);
Assert.AreEqual("ICD10", binding.getTerminology(), "unexpected binding terminology");
item = (org.openehr.am.archetype.ontology.QueryBindingItem)binding.getBindingList().get(0);
Assert.AreEqual("ac0001", item.getCode(), "unexpected local code");
Assert.AreEqual("http://terminology.org?terminology_id=icd10&&has_relation=a2;with_target=b19",
item.getQuery().getUrl(), "exexpected query");
}
//[TestMethod]
public CDurationTest()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.durations.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
archetype = parser.parse();
}
public void testBindings()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_bindings.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
org.openehr.am.archetype.ontology.ArchetypeOntology ontology = archetype.getOntology();
Assert.IsNotNull(ontology);
object a = ontology.getTermBindingList().get(0);
OntologyBinding termBinding = a as OntologyBinding;
Assert.AreEqual("SNOMED-CT", termBinding.getTerminology(), "term bindings wrong");
TermBindingItem tbi = (TermBindingItem)termBinding.getBindingList().get(0);
Assert.AreEqual("[SNOMED-CT::123456]", tbi.getTerms().get(0), "term binding item wrong");
OntologyBinding constrBinding = (OntologyBinding)ontology.getConstraintBindingList().get(0);
Assert.AreEqual("SNOMED-CT", constrBinding.getTerminology(), "binding ontology wrong");
QueryBindingItem qbi = (QueryBindingItem)constrBinding.getBindingList().get(0);
Assert.AreEqual("http://openEHR.org/testconstraintbinding", qbi.getQuery().getUrl(), "query binding item wrong");
}
public StructureTest()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.structure_test1.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
//org.openehr.am.archetype.Archetype archetype = parser.parse();
definition = parser.parse().getDefinition();
}
public void testPathBasedBindingWithinInternalReference()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\openEHR-EHR-OBSERVATION.test_internal_ref_binding.v1.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(0);
Assert.AreEqual("DDB00", binding.getTerminology(), "wrong binding terminology");
org.openehr.am.archetype.ontology.TermBindingItem item1 = (org.openehr.am.archetype.ontology.TermBindingItem)binding.getBindingList().get(0);
Assert.AreEqual(1, item1.getTerms().size(), "wrong terms size");
Assert.AreEqual("/data[at0001]/events[at0002]/data[at0003]/items[at0004]",
item1.getCode(), "wrong local code path");
Assert.AreEqual("[DDB00::12345]", item1.getTerms().get(0), "wrong term");
org.openehr.am.archetype.ontology.TermBindingItem item2 = (org.openehr.am.archetype.ontology.TermBindingItem)binding.getBindingList().get(1);
Assert.AreEqual(1, item2.getTerms().size(), "wrong terms size");
Assert.AreEqual("/data[at0001]/events[at0005]/data[at0003]/items[at0004]",
item2.getCode(), "wrong local code path");
Assert.AreEqual("[DDB00::98765]", item2.getTerms().get(0), "wrong term");
Assert.IsTrue(archetype.physicalPaths().contains("/data[at0001]/events[at0002]/data[at0003]/items[at0004]"));
Assert.IsTrue(archetype.physicalPaths().contains("/data[at0001]/events[at0005]/data[at0003]/items[at0004]")); // path within an archetype internal ref. Must be included in the physical paths!
Assert.IsFalse(archetype.physicalPaths().contains("/data[at0001]/events[at9999]/data[at0003]/items[at0004]"));
}
public void testParsingWithUTF8Encoding()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.unicode_BOM_support.test.adl", System.Text.UTF8Encoding.UTF8);
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void testTermBindingWithMultiTerminologies()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.term_binding.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
// verify the first term binding
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(0);
Assert.AreEqual("SNOMED_CT", binding.getTerminology(), "wrong binding terminology");
org.openehr.am.archetype.ontology.TermBindingItem item = (org.openehr.am.archetype.ontology.TermBindingItem) binding.getBindingList().get(0);
Assert.AreEqual("at0000", item.getCode(), "wrong local code");
Assert.AreEqual(1, item.getTerms().size(), "wrong terms size");
Assert.AreEqual("[snomed_ct::1000339]", item.getTerms().get(0), "wrong term");
// verify the second term binding
binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(1);
Assert.AreEqual("ICD10", binding.getTerminology(), "wrong binding terminology");
item = (org.openehr.am.archetype.ontology.TermBindingItem) binding.getBindingList().get(0);
Assert.AreEqual("at0000", item.getCode(), "wrong local code");
Assert.AreEqual(2, item.getTerms().size(), "wrong terms size");
Assert.AreEqual("[icd10::1000]", item.getTerms().get(0), "wrong 1st term");
Assert.AreEqual("[icd10::1001]", item.getTerms().get(1), "wrong 2nd term");
}
public void testPathBasedBindingWithinInternalReference()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\openEHR-EHR-OBSERVATION.test_internal_ref_binding.v1.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(0);
Assert.AreEqual("DDB00", binding.getTerminology(), "wrong binding terminology");
org.openehr.am.archetype.ontology.TermBindingItem item1 = (org.openehr.am.archetype.ontology.TermBindingItem)binding.getBindingList().get(0);
Assert.AreEqual(1, item1.getTerms().size(), "wrong terms size");
Assert.AreEqual("/data[at0001]/events[at0002]/data[at0003]/items[at0004]",
item1.getCode(), "wrong local code path");
Assert.AreEqual("[DDB00::12345]", item1.getTerms().get(0), "wrong term");
org.openehr.am.archetype.ontology.TermBindingItem item2 = (org.openehr.am.archetype.ontology.TermBindingItem)binding.getBindingList().get(1);
Assert.AreEqual(1, item2.getTerms().size(), "wrong terms size");
Assert.AreEqual("/data[at0001]/events[at0005]/data[at0003]/items[at0004]",
item2.getCode(), "wrong local code path");
Assert.AreEqual("[DDB00::98765]", item2.getTerms().get(0), "wrong term");
Assert.IsTrue(archetype.physicalPaths().contains("/data[at0001]/events[at0002]/data[at0003]/items[at0004]"));
Assert.IsTrue(archetype.physicalPaths().contains("/data[at0001]/events[at0005]/data[at0003]/items[at0004]")); // path within an archetype internal ref. Must be included in the physical paths!
Assert.IsFalse(archetype.physicalPaths().contains("/data[at0001]/events[at9999]/data[at0003]/items[at0004]"));
}
public void testConstraintBindingWithMultiTerminologies()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.constraint_binding.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
java.util.List list = archetype.getOntology().getConstraintBindingList();
Assert.AreEqual(2, list.size(), "unexpected number of onotology binding");
// verify the first constraint binding
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)list.get(0);
Assert.AreEqual("SNOMED_CT", binding.getTerminology(), "unexpected binding terminology");
org.openehr.am.archetype.ontology.QueryBindingItem item = (org.openehr.am.archetype.ontology.QueryBindingItem)binding.getBindingList().get(0);
Assert.AreEqual("ac0001", item.getCode(), "unexpected local code");
Assert.AreEqual("http://terminology.org?terminology_id=snomed_ct&&has_relation=102002;with_target=128004", item.getQuery().getUrl(), "exexpected query");
// verify the second constraint binding
binding = (org.openehr.am.archetype.ontology.OntologyBinding)list.get(1);
Assert.AreEqual("ICD10", binding.getTerminology(), "unexpected binding terminology");
item = (org.openehr.am.archetype.ontology.QueryBindingItem)binding.getBindingList().get(0);
Assert.AreEqual("ac0001", item.getCode(), "unexpected local code");
Assert.AreEqual("http://terminology.org?terminology_id=icd10&&has_relation=a2;with_target=b19",
item.getQuery().getUrl(), "exexpected query");
}
//[TestMethod]
public SpecialStringTest()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.special_string.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
attributeList = parser.parse().getDefinition().getAttributes();
}
public void testParseCDvQuantityReversed()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.c_dv_quantity_reversed.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
archetype = parser.parse();
Assert.IsNotNull(archetype);
}
//[TestMethod]
public UnicodeSupportTest()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.unicode_support.test.adl", System.Text.Encoding.GetEncoding("UTF-8"));
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
archetype = parser.parse();
}
public void testParseLanguageWithAccreditationBeforeLanguage()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_language_order_of_translation_details.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Map translations = archetype.getTranslations();
TranslationDetails td = (TranslationDetails)translations.get("de");
Assert.IsNotNull(td);
Map map = td.getAuthor();
Assert.IsNotNull(map);
Assert.AreEqual("Harry Potter", map.get("name"));
Assert.AreEqual("*****@*****.**",
map.get("email"));
Assert.AreEqual(null, td.getAccreditation());
map = td.getOtherDetails();
Assert.AreEqual("Ron Weasley", map.get("review 1"));
Assert.AreEqual("Rubeus Hagrid", map.get("review 2"));
}
public BasicTypesTest()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.basic_types.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
attributeList = parser.parse().getDefinition().getAttributes();
}
public void testTermBindingWithMultiTerminologies()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.term_binding.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
// verify the first term binding
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(0);
Assert.AreEqual("SNOMED_CT", binding.getTerminology(), "wrong binding terminology");
org.openehr.am.archetype.ontology.TermBindingItem item = (org.openehr.am.archetype.ontology.TermBindingItem)binding.getBindingList().get(0);
Assert.AreEqual("at0000", item.getCode(), "wrong local code");
Assert.AreEqual(1, item.getTerms().size(), "wrong terms size");
Assert.AreEqual("[snomed_ct::1000339]", item.getTerms().get(0), "wrong term");
// verify the second term binding
binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(1);
Assert.AreEqual("ICD10", binding.getTerminology(), "wrong binding terminology");
item = (org.openehr.am.archetype.ontology.TermBindingItem)binding.getBindingList().get(0);
Assert.AreEqual("at0000", item.getCode(), "wrong local code");
Assert.AreEqual(2, item.getTerms().size(), "wrong terms size");
Assert.AreEqual("[icd10::1000]", item.getTerms().get(0), "wrong 1st term");
Assert.AreEqual("[icd10::1001]", item.getTerms().get(1), "wrong 2nd term");
}
public void testParseCommentWithSlashCharAfterSlot()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\openEHR-EHR-CLUSTER.auscultation.v1.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void testParseCDvQuantityReversed()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.c_dv_quantity_reversed.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void testParseInternalRefWithCommentWithSlashAfterOnlyOneSlashInTarget()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_internal_ref2.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void testParsingWithoutUTF8Encoding()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.unicode_BOM_support.test.adl", System.Text.Encoding.GetEncoding("ISO-8859-1"));
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void testParseInternalRefWithCommentWithSlashAfterOnlyOneSlashInTarget()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_internal_ref2.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void testParseCommentWithSlashChar()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.structure_test2.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public StructureTest()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.structure_test1.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
//org.openehr.am.archetype.Archetype archetype = parser.parse();
definition = parser.parse().getDefinition();
}
public void testParse()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_identification.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.AreEqual("1.4", archetype.getAdlVersion(), "adl_version wrong");
}
public void TestMethod1()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.most_minimal.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.AreEqual("en",archetype.getOriginalLanguage().getCodeString(),"originalLanguage wrong");
}
public void testParse()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_identification.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.AreEqual("1.4", archetype.getAdlVersion(), "adl_version wrong");
}
public void TestMethod1()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.most_minimal.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.AreEqual("en", archetype.getOriginalLanguage().getCodeString(), "originalLanguage wrong");
}
public void TestMethod1()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.empty_other_contributors.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.IsNull(archetype.getDescription().getOtherContributors());
}
public void setUp()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-car.paths.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
CComplexObject definition = archetype.getDefinition();
}
public void TestMethod1()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.empty_other_contributors.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.IsNull(archetype.getDescription().getOtherContributors());
}
public void setUp()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-car.paths.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
CComplexObject definition = archetype.getDefinition();
}
public void TestParseRegularExpressions()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.regular_expression.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.IsNotNull(archetype.getDefinition());
}
public void TestParseRegularExpressions()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.regular_expression.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.IsNotNull(archetype.getDefinition());
}
public void testParseCommentWithSlashCharAfterSlot()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\openEHR-EHR-CLUSTER.auscultation.v1.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void testParseCommentWithSlashChar()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.structure_test2.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
public void TestMethod1()
{
bool missingLanguageCompatible = true;
bool emptyPurposeCompatible = false;
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.missing_language.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl, missingLanguageCompatible, emptyPurposeCompatible);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.AreEqual("zh",archetype.getOriginalLanguage().getCodeString(),"originalLanguage wrong");
}
public void TestMethod1()
{
bool missingLanguageCompatible = true;
bool emptyPurposeCompatible = false;
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.missing_language.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl, missingLanguageCompatible, emptyPurposeCompatible);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
Assert.AreEqual("zh", archetype.getOriginalLanguage().getCodeString(), "originalLanguage wrong");
}
public void TestMethod1()
{
bool missingLanguageCompatible = false;
bool emptyPurposeCompatible = true;
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_desc_missing_purpose.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl, missingLanguageCompatible, emptyPurposeCompatible);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ResourceDescriptionItem c = (ResourceDescriptionItem)archetype.getDescription().getDetails().get(0);
Assert.IsNotNull(c.getPurpose(),"purpose null");
}
public void testArchetypeUncommonTerm()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_uncommonkeys.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
org.openehr.am.archetype.ontology.ArchetypeTerm aterm = archetype.getOntology().termDefinition("at0000");
Assert.AreEqual("another key value", aterm.getItem("anotherkey").ToString(), "key value wrong");
Assert.AreEqual("test text", aterm.getItem("text").ToString(), "key value wrong");
Assert.AreEqual("test description", aterm.getItem("description").ToString(), "key value wrong");
}
public void testParseTermDefinition()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_ontology.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
org.openehr.am.archetype.ontology.ArchetypeOntology ontology = archetype.getOntology();
org.openehr.am.archetype.ontology.ArchetypeTerm term = ontology.termDefinition("en", "at0000");
Assert.AreEqual("some text", term.getItem("text"), "text wrong");
Assert.AreEqual("some comment", term.getItem("comment"), "comment wrong");
Assert.AreEqual("some description", term.getItem("description"), "description wrong");
}
public void TestMethod1()
{
bool missingLanguageCompatible = false;
bool emptyPurposeCompatible = true;
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_desc_missing_purpose.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl, missingLanguageCompatible, emptyPurposeCompatible);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ResourceDescriptionItem c = (ResourceDescriptionItem)archetype.getDescription().getDetails().get(0);
Assert.IsNotNull(c.getPurpose(), "purpose null");
}
public void testParseTermDefinition()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_ontology.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
org.openehr.am.archetype.ontology.ArchetypeOntology ontology = archetype.getOntology();
org.openehr.am.archetype.ontology.ArchetypeTerm term = ontology.termDefinition("en", "at0000");
Assert.AreEqual("some text", term.getItem("text"), "text wrong");
Assert.AreEqual("some comment", term.getItem("comment"), "comment wrong");
Assert.AreEqual("some description", term.getItem("description"), "description wrong");
}
public void testParseEmptyCDvQuantity()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.c_dv_quantity_empty.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
archetype = parser.parse();
node = archetype.node("/types[at0001]/items[at10005]/value");
Assert.IsTrue(node is org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantity, "CDvQuantity expected");
org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantity cdvquantity = (org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantity)node;
Assert.IsNull(cdvquantity.getList());
Assert.IsNull(cdvquantity.getProperty());
Assert.IsNull(cdvquantity.getAssumedValue());
Assert.IsTrue(cdvquantity.isAnyAllowed());
}
public void testParseIncludesExcludes()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_slot.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ArchetypeConstraint node = archetype.node("/content[at0001]");
// Type e = typeof(node);
ArchetypeSlot slot = (ArchetypeSlot)node;
Assert.AreEqual("at0001", slot.getNodeId(), "nodeId wrong");
Assert.AreEqual("SECTION", slot.getRmTypeName(), "rmTypeName wrong");
Interval a = new Interval(0, 1);
// Assert.AreEqual( a, slot.getOccurrences());//错误？？？
Assert.AreEqual("/content[at0001]", slot.path(), "path wrong");
Assert.AreEqual(1, slot.getIncludes().size(), "includes total wrong");
Assert.AreEqual(2, slot.getExcludes().size(), "Excludes total wrong");
object b = slot.getIncludes().iterator().next();
Assertion assertion = (Assertion)b;
ExpressionItem item = assertion.getExpression();
Assert.IsInstanceOfType(item, typeof(ExpressionBinaryOperator));
//assertTrue("expressionItem type wrong",
// item instanceof ExpressionBinaryOperator);
ExpressionBinaryOperator bo = (ExpressionBinaryOperator)item;
ExpressionItem leftOp = bo.getLeftOperand();
ExpressionItem rightOp = bo.getRightOperand();
Assert.IsInstanceOfType(leftOp, typeof(ExpressionLeaf));
//assertTrue("left operator type wrong",
// leftOp instanceof ExpressionLeaf);
ExpressionLeaf left = (ExpressionLeaf)leftOp;
Assert.AreEqual("domain_concept", left.getItem(), "left value wrong");
Assert.IsInstanceOfType(rightOp, typeof(ExpressionLeaf));
// assertTrue("right operator type wrong", rightOp instanceof ExpressionLeaf);
ExpressionLeaf right = (ExpressionLeaf)rightOp;
Assert.IsInstanceOfType(right.getItem(), typeof(CString));
// assertTrue("right item type wrong", right.getItem() instanceof CString);
CString cstring = (CString)right.getItem();
Assert.AreEqual("blood_pressure.v1", cstring.getPattern(), "right value wrong");
}
public void testParseSingleInclude()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_slot.test2.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ArchetypeConstraint node = archetype.node("/content[at0001]");
ArchetypeSlot slot = (ArchetypeSlot)node;
Assert.AreEqual("at0001", slot.getNodeId(), "nodeId wrong");
Assert.AreEqual("SECTION", slot.getRmTypeName(), "rmTypeName wrong");
// Assert.AreEqual("occurrences wrong", new Interval<Integer>(0, 1),slot.getOccurrences());
Assert.AreEqual("/content[at0001]", slot.path(), "path wrong");
Assert.AreEqual(1, slot.getIncludes().size(), "includes total wrong");
Assertion assertion = (Assertion)slot.getIncludes().iterator().next();
ExpressionItem item = assertion.getExpression();
//assertTrue("expressionItem type wrong",
// item instanceof ExpressionBinaryOperator);
ExpressionBinaryOperator bo = (ExpressionBinaryOperator)item;
ExpressionItem leftOp = bo.getLeftOperand();
ExpressionItem rightOp = bo.getRightOperand();
//assertTrue("left operator type wrong",
// leftOp instanceof ExpressionLeaf);
ExpressionLeaf left = (ExpressionLeaf)leftOp;
Assert.AreEqual("archetype_id/value", left.getItem(), "left value wrong");
//assertTrue("right operator type wrong",
// rightOp instanceof ExpressionLeaf);
ExpressionLeaf right = (ExpressionLeaf)rightOp;
//assertTrue("right item type wrong", right.getItem() instanceof CString);
string cstring = Convert.ToString(right.getItem());
//Assert.AreEqual("right value wrong", "openEHR-EHR-CLUSTER\\.device\\.v1",
// cstring.getPattern());
Assert.IsNotNull("stringExpression missing", assertion.getStringExpression());
String expectedStringExpression =
"archetype_id/value matches {/openEHR-EHR-CLUSTER\\.device\\.v1/}";
Assert.AreEqual(expectedStringExpression, assertion.getStringExpression(), "stringExpression wrong, got: " + assertion.getStringExpression());
}
public void testParseEmptyCDvQuantity()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.c_dv_quantity_empty.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
archetype = parser.parse();
node = archetype.node("/types[at0001]/items[at10005]/value");
Assert.IsTrue(node is org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantity, "CDvQuantity expected");
org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantity cdvquantity = (org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantity)node;
Assert.IsNull(cdvquantity.getList());
Assert.IsNull(cdvquantity.getProperty());
Assert.IsNull(cdvquantity.getAssumedValue());
Assert.IsTrue(cdvquantity.isAnyAllowed());
}
public void testParseInternalRefWithGenerics()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-SOME_TYPE.generic_type_use_node.draft.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ArchetypeConstraint node = archetype.node("/interval_attr2");
//assertTrue("ArchetypeInternalRef expected, actual: " + node.getClass(),
// node instanceof ArchetypeInternalRef);
Assert.IsInstanceOfType(node, typeof(ArchetypeInternalRef));
ArchetypeInternalRef refe = (ArchetypeInternalRef)node;
Assert.AreEqual("INTERVAL<QUANTITY>", refe.getRmTypeName());
Assert.AreEqual("/interval_attr[at0001]", refe.getTargetPath());
}
public void TestMethod1()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-composition.dv_coded_text.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
org.openehr.am.archetype.constraintmodel.ArchetypeConstraint node = archetype.node("/category/defining_code");
//assertTrue("CCodePhrase expected, but got " + node.getClass(),
// node instanceof CCodePhrase);
Assert.IsInstanceOfType(node, typeof(CCodePhrase));
CCodePhrase ccp = (CCodePhrase)node;
Assert.AreEqual( ccp.getTerminologyId().toString(), "openehr","terminologyId wrong");
Assert.AreEqual(ccp.getCodeList().get(0), "431", "codeString wrong");
}
public void TestMethod1()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-composition.dv_coded_text.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
org.openehr.am.archetype.constraintmodel.ArchetypeConstraint node = archetype.node("/category/defining_code");
//assertTrue("CCodePhrase expected, but got " + node.getClass(),
// node instanceof CCodePhrase);
Assert.IsInstanceOfType(node, typeof(CCodePhrase));
CCodePhrase ccp = (CCodePhrase)node;
Assert.AreEqual(ccp.getTerminologyId().toString(), "openehr", "terminologyId wrong");
Assert.AreEqual(ccp.getCodeList().get(0), "431", "codeString wrong");
}
public void testPathBasedBinding()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.term_binding2.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(0);
Assert.AreEqual("LNC205", binding.getTerminology(), "wrong binding terminology");
org.openehr.am.archetype.ontology.TermBindingItem item = (org.openehr.am.archetype.ontology.TermBindingItem) binding.getBindingList().get(0);
Assert.AreEqual("/data[at0002]/events[at0003]/data[at0001]/item[at0004]",
item.getCode(), "wrong local code path");
Assert.AreEqual(1, item.getTerms().size(), "wrong terms size");
Assert.AreEqual("[LNC205::8310-5]", item.getTerms().get(0), "wrong term");
}
public void testTranslationDetails()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.testtranslations.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
java.util.Map translations = archetype.getTranslations();
TranslationDetails transDet = (TranslationDetails)translations.get("de");
Assert.AreEqual("test Accreditation!", transDet.getAccreditation());
Assert.AreEqual( "test organisation", transDet.getAuthor().get("organisation"));
TranslationDetails transDet2 = (TranslationDetails)translations.get("es");
Assert.AreEqual(null, transDet2.getAccreditation());
Assert.AreEqual(null, transDet2.getAuthor().get("organisation"));
}
public void testPath()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-car.paths.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
CComplexObject definition = archetype.getDefinition();
// root path CAR
Assert.AreEqual("/", definition.path());
// wheels attribute
CAttribute wheels = (CAttribute)definition.getAttributes().get(0);
Assert.AreEqual("/wheels", wheels.path());
// first WHEEL node
CObject firstWheel = (CObject)wheels.getChildren().get(0);
Assert.AreEqual("/wheels[at0001]", firstWheel.path());
// description and parts of first WHEEL
CComplexObject firstWheelObj = (CComplexObject)firstWheel;
CAttribute description = (CAttribute)firstWheelObj.getAttributes().get(0);
Assert.AreEqual("/wheels[at0001]/description", description.path());
CAttribute parts = (CAttribute)firstWheelObj.getAttributes().get(1);
Assert.AreEqual("/wheels[at0001]/parts", parts.path());
// WHEEL_PART node
CObject wheelParts = (CObject)parts.getChildren().get(0);
Assert.AreEqual("/wheels[at0001]/parts[at0002]",
wheelParts.path());
// something and something_else of WHEEL_PART node
//CComplexObject wheelPartsObj = (CComplexObject)wheelParts;
//Assert.AreEqual("something of WHEEL_PART",
// "/wheels[at0001]/parts[at0002]/something",
// wheelPartsObj.getAttributes().get(0).path());
//Assert.AreEqual("something_else of WHEEL_PART",
// "/wheels[at0001]/parts[at0002]/something_else",
// wheelPartsObj.getAttributes().get(1).path());
}
public void testPathBasedBinding()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.term_binding2.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
org.openehr.am.archetype.ontology.OntologyBinding binding = (org.openehr.am.archetype.ontology.OntologyBinding)archetype.getOntology().getTermBindingList().get(0);
Assert.AreEqual("LNC205", binding.getTerminology(), "wrong binding terminology");
org.openehr.am.archetype.ontology.TermBindingItem item = (org.openehr.am.archetype.ontology.TermBindingItem)binding.getBindingList().get(0);
Assert.AreEqual("/data[at0002]/events[at0003]/data[at0001]/item[at0004]",
item.getCode(), "wrong local code path");
Assert.AreEqual(1, item.getTerms().size(), "wrong terms size");
Assert.AreEqual("[LNC205::8310-5]", item.getTerms().get(0), "wrong term");
}
public void testParseInternalRefWithGenerics()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-SOME_TYPE.generic_type_use_node.draft.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ArchetypeConstraint node = archetype.node("/interval_attr2");
//assertTrue("ArchetypeInternalRef expected, actual: " + node.getClass(),
// node instanceof ArchetypeInternalRef);
Assert.IsInstanceOfType(node, typeof(ArchetypeInternalRef));
ArchetypeInternalRef refe = (ArchetypeInternalRef)node;
Assert.AreEqual("INTERVAL<QUANTITY>", refe.getRmTypeName());
Assert.AreEqual("/interval_attr[at0001]", refe.getTargetPath());
}
public void testMultiLanguageConstraintDefinitions()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.multi_language.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
//List<OntologyDefinitions> list =
//archetype.getOntology().getConstraintDefinitionsList();
Assert.AreEqual( 2, archetype.getOntology().getConstraintDefinitionsList().size());
OntologyDefinitions defs = (OntologyDefinitions)archetype.getOntology().getConstraintDefinitionsList().get(0);
Assert.AreEqual("en", defs.getLanguage());
defs = (OntologyDefinitions)archetype.getOntology().getConstraintDefinitionsList().get(1);
Assert.AreEqual( "sv", defs.getLanguage());
}
public void testParseSingleInclude()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_slot.test2.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ArchetypeConstraint node = archetype.node("/content[at0001]");
ArchetypeSlot slot = (ArchetypeSlot)node;
Assert.AreEqual("at0001", slot.getNodeId(), "nodeId wrong");
Assert.AreEqual("SECTION", slot.getRmTypeName(), "rmTypeName wrong");
// Assert.AreEqual("occurrences wrong", new Interval<Integer>(0, 1),slot.getOccurrences());
Assert.AreEqual("/content[at0001]", slot.path(), "path wrong");
Assert.AreEqual(1, slot.getIncludes().size(), "includes total wrong");
Assertion assertion = (Assertion)slot.getIncludes().iterator().next();
ExpressionItem item = assertion.getExpression();
//assertTrue("expressionItem type wrong",
// item instanceof ExpressionBinaryOperator);
ExpressionBinaryOperator bo = (ExpressionBinaryOperator)item;
ExpressionItem leftOp = bo.getLeftOperand();
ExpressionItem rightOp = bo.getRightOperand();
//assertTrue("left operator type wrong",
// leftOp instanceof ExpressionLeaf);
ExpressionLeaf left = (ExpressionLeaf)leftOp;
Assert.AreEqual("archetype_id/value", left.getItem(), "left value wrong");
//assertTrue("right operator type wrong",
// rightOp instanceof ExpressionLeaf);
ExpressionLeaf right = (ExpressionLeaf)rightOp;
//assertTrue("right item type wrong", right.getItem() instanceof CString);
string cstring = Convert.ToString(right.getItem());
//Assert.AreEqual("right value wrong", "openEHR-EHR-CLUSTER\\.device\\.v1",
// cstring.getPattern());
Assert.IsNotNull("stringExpression missing", assertion.getStringExpression());
String expectedStringExpression =
"archetype_id/value matches {/openEHR-EHR-CLUSTER\\.device\\.v1/}";
Assert.AreEqual(expectedStringExpression, assertion.getStringExpression(), "stringExpression wrong, got: " + assertion.getStringExpression());
}
public void TestMethod1()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.mixed_node_types.draft.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
try
{
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
}
catch (Exception e)
{
string a= e.Message;
Console.Write(a);
// fail("failed to parse mixed node types");
}
}
public void testParseInternalRefWithOverwrittingOccurrences()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_internal_ref.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ArchetypeConstraint node = archetype.node("/attribute2");
Assert.IsInstanceOfType(node, typeof(ArchetypeInternalRef));
ArchetypeInternalRef refff = (ArchetypeInternalRef)node;
Assert.AreEqual("SECTION", refff.getRmTypeName(), "rmType wrong");
Assert.AreEqual("/attribute1", refff.getTargetPath(), "path wrong");
Interval occurrences = new Interval(1, 2);
//Assert.AreEqual( occurrences, refff.getOccurrences());//错误？？？
}
public void testCheckInternalReferences()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-car.use_node.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
se.acode.openehr.parser.ArchetypeValidator validator = new se.acode.openehr.parser.ArchetypeValidator(archetype);
java.util.Map expected = new java.util.HashMap();
// wrong target path
expected.put("/wheels[at0005]/parts",
"/engine[at0001]/parts[at0002]");
// wrong type
expected.put("/wheels[at0006]/parts",
"/wheels[at0001]/parts[at0002]");
//Assert.AreEqual(expected, validator.checkInternalReferences());
}
public void testParseIncludesExcludes()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_slot.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
ArchetypeConstraint node = archetype.node("/content[at0001]");
// Type e = typeof(node);
ArchetypeSlot slot = (ArchetypeSlot)node;
Assert.AreEqual("at0001", slot.getNodeId(), "nodeId wrong");
Assert.AreEqual("SECTION", slot.getRmTypeName(), "rmTypeName wrong");
Interval a = new Interval(0, 1);
// Assert.AreEqual( a, slot.getOccurrences());//错误？？？
Assert.AreEqual("/content[at0001]", slot.path(), "path wrong");
Assert.AreEqual(1, slot.getIncludes().size(), "includes total wrong");
Assert.AreEqual(2, slot.getExcludes().size(), "Excludes total wrong");
object b = slot.getIncludes().iterator().next();
Assertion assertion = (Assertion)b;
ExpressionItem item = assertion.getExpression();
Assert.IsInstanceOfType(item, typeof(ExpressionBinaryOperator));
//assertTrue("expressionItem type wrong",
// item instanceof ExpressionBinaryOperator);
ExpressionBinaryOperator bo = (ExpressionBinaryOperator)item;
ExpressionItem leftOp = bo.getLeftOperand();
ExpressionItem rightOp = bo.getRightOperand();
Assert.IsInstanceOfType(leftOp, typeof(ExpressionLeaf));
//assertTrue("left operator type wrong",
// leftOp instanceof ExpressionLeaf);
ExpressionLeaf left = (ExpressionLeaf)leftOp;
Assert.AreEqual("domain_concept", left.getItem(), "left value wrong");
Assert.IsInstanceOfType(rightOp, typeof(ExpressionLeaf));
// assertTrue("right operator type wrong", rightOp instanceof ExpressionLeaf);
ExpressionLeaf right = (ExpressionLeaf)rightOp;
Assert.IsInstanceOfType(right.getItem(), typeof(CString));
// assertTrue("right item type wrong", right.getItem() instanceof CString);
CString cstring = (CString)right.getItem();
Assert.AreEqual("blood_pressure.v1", cstring.getPattern(), "right value wrong");
}
public void testParseLanguageSection()
{
string adl = System.IO.File.ReadAllText(@"..\..\..\..\java-libs\adl-parser\src\test\resources\adl-test-entry.archetype_language.test.adl");
se.acode.openehr.parser.ADLParser parser = new se.acode.openehr.parser.ADLParser(adl);
org.openehr.am.archetype.Archetype archetype = parser.parse();
Assert.IsNotNull(archetype);
java.util.Map translations = archetype.getTranslations();
Assert.IsNotNull(translations);
TranslationDetails td = (TranslationDetails)translations.get("de");
Assert.IsNotNull( td,"translation de missing");
java.util.Map map = td.getAuthor();
Assert.IsNotNull( map);
Assert.AreEqual( "Harry Potter", map.get("name"));
Assert.AreEqual("*****@*****.**", map.get("email"));
Assert.AreEqual( "British Medical Translator id 00400595", td.getAccreditation());
map = td.getOtherDetails();
Assert.AreEqual( "Ron Weasley", map.get("review 1"));
Assert.AreEqual( "Rubeus Hagrid", map.get("review 2"));
}