Beispiel #1
0
        private void verifyCDvQuantityValue(org.openehr.am.archetype.constraintmodel.ArchetypeConstraint node)
        {
            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;

            // verify property
            org.openehr.rm.datatypes.text.CodePhrase property = cdvquantity.getProperty();
            Assert.IsNotNull(property, "property is null");
            Assert.AreEqual("openehr", property.getTerminologyId().name());
            Assert.AreEqual("128", property.getCodeString());

            // verify item list
            java.util.List list = cdvquantity.getList();
            Assert.AreEqual(2, list.size(), "unexpected size of list");
            java.lang.Double  temp1 = new java.lang.Double(0.0);
            java.lang.Double  temp2 = new java.lang.Double(200.0);
            java.lang.Integer temp3 = new java.lang.Integer(2);
            assertCDvQuantityItem((org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantityItem)list.get(0), "yr", new org.openehr.rm.support.basic.Interval(temp1, temp2), new org.openehr.rm.support.basic.Interval(temp3, temp3));
            temp1 = new java.lang.Double(1.0);
            temp2 = new java.lang.Double(36.0);
            assertCDvQuantityItem((org.openehr.am.openehrprofile.datatypes.quantity.CDvQuantityItem)list.get(1), "mth", new org.openehr.rm.support.basic.Interval(temp1, temp2), new org.openehr.rm.support.basic.Interval(temp3, temp3));

            org.openehr.rm.support.measurement.MeasurementService ms       = org.openehr.rm.support.measurement.SimpleMeasurementService.getInstance();
            org.openehr.rm.datatypes.quantity.DvQuantity          expected = new org.openehr.rm.datatypes.quantity.DvQuantity("yr", new java.lang.Double(8.0), new java.lang.Integer(2), ms);
            Assert.AreEqual(expected,
                            cdvquantity.getAssumedValue(), "assumed value wrong");
        }
 public void testEmptyCDvOrdinal()
 {
     node = archetype.node("/types[at0001]/items[at10003]/value");
     Assert.IsTrue(node is org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal, "CDvOrdinal expected");
     org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal cordinal = (org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal)node;
     Assert.IsTrue(cordinal.isAnyAllowed());
 }
        public void testCDvOrdinalWithoutAssumedValue()
        {
            node = archetype.node("/types[at0001]/items[at10001]/value");
            String[] codes = {
                "at0003.0", "at0003.1", "at0003.2", "at0003.3", "at0003.4"
            };
            String terminology = "local";

            Assert.IsFalse(((org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal) node).hasAssumedValue(), "unexpected assumed value");

            assertCDvOrdinal(node, terminology, codes, null);
        }
        public void testCDvOrdinalWithAssumedValue()
        {
            node = archetype.node("/types[at0001]/items[at10002]/value");
            String[] codes = {
                "at0003.0", "at0003.1", "at0003.2", "at0003.3", "at0003.4"
            };
            String terminology = "local";
            org.openehr.am.openehrprofile.datatypes.quantity.Ordinal assumed = new org.openehr.am.openehrprofile.datatypes.quantity.Ordinal(0, new org.openehr.rm.datatypes.text.CodePhrase(terminology, codes[0]));

            Assert.IsTrue(((org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal) node).hasAssumedValue(), "expected to have assumed value");

            assertCDvOrdinal(node, terminology, codes, assumed);
        }
        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());
        }
Beispiel #6
0
        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");
        }
Beispiel #7
0
        private void assertCDvOrdinal(org.openehr.am.archetype.constraintmodel.ArchetypeConstraint node, String terminoloy,
                                      String[] codes, org.openehr.am.openehrprofile.datatypes.quantity.Ordinal assumedValue)
        {
            Assert.IsTrue(node is org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal, "CDvOrdinal expected");
            org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal cordinal = (org.openehr.am.openehrprofile.datatypes.quantity.CDvOrdinal)node;

            java.util.List codeList = java.util.Arrays.asList(codes);
            java.util.Set  list     = cordinal.getList();
            Assert.AreEqual(codes.Length, list.size(), "codes.size");
            for (java.util.Iterator it = list.iterator(); it.hasNext();)
            {
                org.openehr.am.openehrprofile.datatypes.quantity.Ordinal ordinal = (org.openehr.am.openehrprofile.datatypes.quantity.Ordinal)it.next();

                Assert.AreEqual("local", ordinal.getSymbol().getTerminologyId().getValue(), "terminology");
                Assert.IsTrue(codeList.contains(ordinal.getSymbol().getCodeString()), "code missing");
            }
            Assert.AreEqual(assumedValue, cordinal.getAssumedValue(), "assumedValue wrong");
        }
Beispiel #8
0
        private void assertCCodePhrase(org.openehr.am.archetype.constraintmodel.ArchetypeConstraint actual,
                                       String terminologyId, String[] codes, String assumedValue)
        {
            // check type
            Assert.IsTrue(actual is org.openehr.am.openehrprofile.datatypes.text.CCodePhrase, "CCodePhrase expected, got " + actual.getClass());
            org.openehr.am.openehrprofile.datatypes.text.CCodePhrase cCodePhrase = (org.openehr.am.openehrprofile.datatypes.text.CCodePhrase)actual;

            // check terminology
            Assert.AreEqual(terminologyId,
                            cCodePhrase.getTerminologyId().getValue(), "terminology");

            // check code list
            if (codes == null)
            {
                Assert.AreEqual(null, cCodePhrase.getCodeList(), "codeList expected null");
            }
            else
            {
                java.util.List codeList = cCodePhrase.getCodeList();
                Assert.AreEqual(codes.Length, codeList.size(), "codes.size wrong");
                for (int i = 0; i < codes.Length; i++)
                {
                    Object c = codeList.get(i);
                    Assert.AreEqual(codes[i], c, "code wrong, got: " + c);
                }
            }

            // check assumed value
            if (assumedValue == null)
            {
                Assert.IsFalse(cCodePhrase.hasAssumedValue());
            }
            else
            {
                Assert.IsTrue(cCodePhrase.hasAssumedValue(), "expected assumedValue");
                org.openehr.rm.datatypes.text.CodePhrase temp = (org.openehr.rm.datatypes.text.CodePhrase)(cCodePhrase.getAssumedValue());
                Assert.AreEqual(assumedValue, temp.getCodeString(), "assumed value wrong");
            }
        }
 public void testParseFullCDvQuantityStartsWithList()
 {
     node = archetype.node("/types[at0001]/items[at10005]/value");
     verifyCDvQuantityValue(node);
 }
 public void testParseLocalCodes()
 {
     node = archetype.node("/types[at0001]/items[at10003]/value");
     String[] codeList = { "at1311","at1312", "at1313", "at1314","at1315" };
     assertCCodePhrase(node, "local", codeList, null);
 }
 public void testParseExternalCodesWithAssumedValue()
 {
     node = archetype.node("/types[at0001]/items[at10005]/value");
     String[] codes = { "F43.00", "F43.01", "F32.02" };
     assertCCodePhrase(node, "icd10", codes, "F43.00");
 }
 public void testParseEmptyCodeList()
 {
     node = archetype.node("/types[at0001]/items[at10004]/value");
     String[] codeList = null;
     assertCCodePhrase(node, "icd10", codeList, null);
 }