X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fimpl%2FUsesAugmentTest.java;h=48ce134171e557d0571b6e689460b1de731dba07;hb=63391074baa84256f2e66fcef0ce02a686a960ea;hp=47edbc2c87bfb63e2e282dc961e2fe6fe3e09963;hpb=1380de45de623d7bbce26cc7dd2ed28131a72067;p=yangtools.git diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java index 47edbc2c87..48ce134171 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/impl/UsesAugmentTest.java @@ -7,20 +7,27 @@ */ package org.opendaylight.yangtools.yang.parser.impl; -import static org.junit.Assert.*; - +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import com.google.common.collect.Lists; import java.io.FileNotFoundException; +import java.io.IOException; import java.net.URI; +import java.net.URISyntaxException; +import java.text.DateFormat; import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Collection; import java.util.Date; import java.util.LinkedList; import java.util.List; import java.util.Set; - import org.junit.Before; import org.junit.Test; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.ChoiceNode; +import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; @@ -36,22 +43,19 @@ import org.opendaylight.yangtools.yang.model.util.Uint32; import org.opendaylight.yangtools.yang.model.util.Uint8; import org.opendaylight.yangtools.yang.model.util.UnionType; -import com.google.common.collect.Lists; - public class UsesAugmentTest { private static final URI UG_NS = URI.create("urn:opendaylight:params:xml:ns:yang:uses-grouping"); private static final URI GD_NS = URI.create("urn:opendaylight:params:xml:ns:yang:grouping-definitions"); private Date UG_REV; private Date GD_REV; - private static final String UG_PREF = "ug"; - private static final String GD_PREF = "gd"; private Set modules; @Before public void init() throws FileNotFoundException, ParseException { - UG_REV = TestUtils.simpleDateFormat.parse("2013-07-30"); - GD_REV = TestUtils.simpleDateFormat.parse("2013-09-04"); + DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); + UG_REV = simpleDateFormat.parse("2013-07-30"); + GD_REV = simpleDateFormat.parse("2013-09-04"); } /** @@ -107,10 +111,12 @@ public class UsesAugmentTest { * |-- |-- leaf ignore (U) * * U = added by uses A = added by augment + * + * @throws Exception if exception occurs */ @Test public void testAugmentInUses() throws Exception { - modules = TestUtils.loadModules(getClass().getResource("/grouping-test").getPath()); + modules = TestUtils.loadModules(getClass().getResource("/grouping-test").toURI()); Module testModule = TestUtils.findModule(modules, "uses-grouping"); LinkedList path = new LinkedList<>(); @@ -120,51 +126,51 @@ public class UsesAugmentTest { assertEquals(1, notifications.size()); NotificationDefinition pcreq = notifications.iterator().next(); assertNotNull(pcreq); - QName expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "pcreq"); + QName expectedQName = QName.create(UG_NS, UG_REV, "pcreq"); path.offer(expectedQName); - SchemaPath expectedPath = new SchemaPath(path, true); + SchemaPath expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, pcreq.getPath()); - Set childNodes = pcreq.getChildNodes(); + Collection childNodes = pcreq.getChildNodes(); assertEquals(4, childNodes.size()); // * |-- leaf version LeafSchemaNode version = (LeafSchemaNode) pcreq.getDataChildByName("version"); assertNotNull(version); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "version"); + expectedQName = QName.create(UG_NS, UG_REV, "version"); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, version.getPath()); - expectedQName = new QName(GD_NS, GD_REV, GD_PREF, "protocol-version"); + expectedQName = QName.create(GD_NS, GD_REV, "protocol-version"); path.offer(expectedQName); - expectedPath = new SchemaPath(Lists.newArrayList(expectedQName), true); + expectedPath = SchemaPath.create(Lists.newArrayList(expectedQName), true); assertEquals(expectedPath, version.getType().getPath()); assertEquals(Uint8.getInstance(), version.getType().getBaseType()); assertTrue(version.isAddedByUses()); // * |-- leaf type LeafSchemaNode type = (LeafSchemaNode) pcreq.getDataChildByName("type"); assertNotNull(type); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "type"); + expectedQName = QName.create(UG_NS, UG_REV, "type"); assertTrue(type.isAddedByUses()); path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, type.getPath()); - expectedQName = new QName(GD_NS, GD_REV, GD_PREF, "int-ext"); + expectedQName = QName.create(GD_NS, GD_REV, "int-ext"); path.offer(expectedQName); - expectedPath = new SchemaPath(Lists.newArrayList(expectedQName), true); + expectedPath = SchemaPath.create(Lists.newArrayList(expectedQName), true); assertEquals(expectedPath, type.getType().getPath()); UnionType union = (UnionType)type.getType().getBaseType(); - assertEquals(BaseTypes.schemaPath(BaseTypes.constructQName("union")), union.getPath()); + assertEquals(SchemaPath.create(true, BaseTypes.constructQName("union")), union.getPath()); assertEquals(2, union.getTypes().size()); // * |-- list requests ListSchemaNode requests = (ListSchemaNode) pcreq.getDataChildByName("requests"); assertNotNull(requests); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "requests"); + expectedQName = QName.create(UG_NS, UG_REV, "requests"); assertEquals(expectedQName, requests.getQName()); path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, requests.getPath()); assertFalse(requests.isAddedByUses()); childNodes = requests.getChildNodes(); @@ -172,9 +178,9 @@ public class UsesAugmentTest { // * |-- |-- container rp ContainerSchemaNode rp = (ContainerSchemaNode) requests.getDataChildByName("rp"); assertNotNull(rp); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "rp"); + expectedQName = QName.create(UG_NS, UG_REV, "rp"); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, rp.getPath()); assertFalse(rp.isAddedByUses()); childNodes = rp.getChildNodes(); @@ -182,36 +188,36 @@ public class UsesAugmentTest { // * |-- |-- |-- leaf processing-rule LeafSchemaNode processingRule = (LeafSchemaNode) rp.getDataChildByName("processing-rule"); assertNotNull(processingRule); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "processing-rule"); + expectedQName = QName.create(UG_NS, UG_REV, "processing-rule"); assertEquals(expectedQName, processingRule.getQName()); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, processingRule.getPath()); assertEquals(BooleanType.getInstance(), processingRule.getType()); assertTrue(processingRule.isAddedByUses()); // * |-- |-- |-- leaf ignore LeafSchemaNode ignore = (LeafSchemaNode) rp.getDataChildByName("ignore"); assertNotNull(ignore); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "ignore"); + expectedQName = QName.create(UG_NS, UG_REV, "ignore"); assertEquals(expectedQName, ignore.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, ignore.getPath()); assertEquals(BooleanType.getInstance(), ignore.getType()); assertTrue(ignore.isAddedByUses()); // * |-- |-- |-- leaf priority LeafSchemaNode priority = (LeafSchemaNode) rp.getDataChildByName("priority"); assertNotNull(priority); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "priority"); + expectedQName = QName.create(UG_NS, UG_REV, "priority"); assertEquals(expectedQName, priority.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, priority.getPath()); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "uint8"); + expectedQName = QName.create(UG_NS, UG_REV, "uint8"); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); // TODO //assertEquals(expectedPath, priority.getType().getPath()); assertEquals(Uint8.getInstance(), priority.getType().getBaseType()); @@ -219,98 +225,98 @@ public class UsesAugmentTest { // * |-- |-- |-- container box ContainerSchemaNode box = (ContainerSchemaNode) rp.getDataChildByName("box"); assertNotNull(box); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "box"); + expectedQName = QName.create(UG_NS, UG_REV, "box"); assertEquals(expectedQName, box.getQName()); path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, box.getPath()); assertTrue(box.isAddedByUses()); // * |-- |-- |-- |-- container order ContainerSchemaNode order = (ContainerSchemaNode) box.getDataChildByName("order"); assertNotNull(order); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "order"); + expectedQName = QName.create(UG_NS, UG_REV, "order"); assertEquals(expectedQName, order.getQName()); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, order.getPath()); - assertFalse(order.isAddedByUses()); + assertTrue(order.isAddedByUses()); assertTrue(order.isAugmenting()); assertEquals(2, order.getChildNodes().size()); // * |-- |-- |-- |-- |-- leaf delete LeafSchemaNode delete = (LeafSchemaNode) order.getDataChildByName("delete"); assertNotNull(delete); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "delete"); + expectedQName = QName.create(UG_NS, UG_REV, "delete"); assertEquals(expectedQName, delete.getQName()); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, delete.getPath()); assertEquals(Uint32.getInstance(), delete.getType()); assertTrue(delete.isAddedByUses()); // * |-- |-- |-- |-- |-- leaf setup LeafSchemaNode setup = (LeafSchemaNode) order.getDataChildByName("setup"); assertNotNull(setup); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "setup"); + expectedQName = QName.create(UG_NS, UG_REV, "setup"); assertEquals(expectedQName, setup.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, setup.getPath()); assertEquals(Uint32.getInstance(), setup.getType()); assertTrue(setup.isAddedByUses()); // * |-- |-- path-key-expansion ContainerSchemaNode pke = (ContainerSchemaNode) requests.getDataChildByName("path-key-expansion"); assertNotNull(pke); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "path-key-expansion"); + expectedQName = QName.create(UG_NS, UG_REV, "path-key-expansion"); assertEquals(expectedQName, pke.getQName()); path.pollLast(); path.pollLast(); path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath = new SchemaPath(path, true); + expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, pke.getPath()); assertFalse(pke.isAddedByUses()); // * |-- |-- |-- path-key ContainerSchemaNode pathKey = (ContainerSchemaNode) pke.getDataChildByName("path-key"); assertNotNull(pathKey); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "path-key"); + expectedQName = QName.create(UG_NS, UG_REV, "path-key"); assertEquals(expectedQName, pathKey.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, pathKey.getPath()); assertFalse(pathKey.isAddedByUses()); assertEquals(3, pathKey.getChildNodes().size()); // * |-- |-- |-- |-- leaf processing-rule processingRule = (LeafSchemaNode) pathKey.getDataChildByName("processing-rule"); assertNotNull(processingRule); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "processing-rule"); + expectedQName = QName.create(UG_NS, UG_REV, "processing-rule"); assertEquals(expectedQName, processingRule.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, processingRule.getPath()); assertEquals(BooleanType.getInstance(), processingRule.getType()); assertTrue(processingRule.isAddedByUses()); // * |-- |-- |-- |-- leaf ignore ignore = (LeafSchemaNode) pathKey.getDataChildByName("ignore"); assertNotNull(ignore); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "ignore"); + expectedQName = QName.create(UG_NS, UG_REV, "ignore"); assertEquals(expectedQName, ignore.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, ignore.getPath()); assertEquals(BooleanType.getInstance(), ignore.getType()); assertTrue(ignore.isAddedByUses()); // * |-- |-- |-- |-- list path-keys ListSchemaNode pathKeys = (ListSchemaNode) pathKey.getDataChildByName("path-keys"); assertNotNull(pathKeys); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "path-keys"); + expectedQName = QName.create(UG_NS, UG_REV, "path-keys"); assertEquals(expectedQName, pathKeys.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, pathKeys.getPath()); assertTrue(pathKeys.isAddedByUses()); childNodes = pathKeys.getChildNodes(); @@ -318,10 +324,10 @@ public class UsesAugmentTest { // * |-- |-- |-- |-- |-- leaf version version = (LeafSchemaNode) pathKeys.getDataChildByName("version"); assertNotNull(version); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "version"); + expectedQName = QName.create(UG_NS, UG_REV, "version"); assertEquals(expectedQName, version.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, version.getPath()); assertTrue(version.getType() instanceof ExtendedType); assertEquals(Uint8.getInstance(), version.getType().getBaseType()); @@ -330,11 +336,11 @@ public class UsesAugmentTest { // * |-- |-- |-- |-- |-- leaf type type = (LeafSchemaNode) pathKeys.getDataChildByName("type"); assertNotNull(type); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "type"); + expectedQName = QName.create(UG_NS, UG_REV, "type"); assertEquals(expectedQName, type.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, type.getPath()); assertTrue(type.getType() instanceof ExtendedType); assertTrue(type.isAddedByUses()); @@ -342,173 +348,173 @@ public class UsesAugmentTest { // * |-- |-- container segment-computation ContainerSchemaNode sc = (ContainerSchemaNode) requests.getDataChildByName("segment-computation"); assertNotNull(sc); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "segment-computation"); + expectedQName = QName.create(UG_NS, UG_REV, "segment-computation"); assertEquals(expectedQName, sc.getQName()); path.pollLast(); path.pollLast(); path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, sc.getPath()); assertFalse(sc.isAddedByUses()); // * |-- |-- |-- container p2p ContainerSchemaNode p2p = (ContainerSchemaNode) sc.getDataChildByName("p2p"); assertNotNull(p2p); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "p2p"); + expectedQName = QName.create(UG_NS, UG_REV, "p2p"); assertEquals(expectedQName, p2p.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, p2p.getPath()); assertFalse(p2p.isAddedByUses()); // * |-- |-- |-- |-- container endpoints ContainerSchemaNode endpoints = (ContainerSchemaNode) p2p.getDataChildByName("endpoints"); assertNotNull(endpoints); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "endpoints"); + expectedQName = QName.create(UG_NS, UG_REV, "endpoints"); assertEquals(expectedQName, endpoints.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, endpoints.getPath()); assertFalse(endpoints.isAddedByUses()); // * |-- |-- |-- |-- |-- leaf processing-rule processingRule = (LeafSchemaNode) endpoints.getDataChildByName("processing-rule"); assertNotNull(processingRule); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "processing-rule"); + expectedQName = QName.create(UG_NS, UG_REV, "processing-rule"); assertEquals(expectedQName, processingRule.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, processingRule.getPath()); assertEquals(BooleanType.getInstance(), processingRule.getType()); assertTrue(processingRule.isAddedByUses()); // * |-- |-- |-- |-- |-- leaf ignore ignore = (LeafSchemaNode) endpoints.getDataChildByName("ignore"); assertNotNull(ignore); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "ignore"); + expectedQName = QName.create(UG_NS, UG_REV, "ignore"); assertEquals(expectedQName, ignore.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, ignore.getPath()); assertEquals(BooleanType.getInstance(), ignore.getType()); assertTrue(ignore.isAddedByUses()); // * |-- |-- |-- |-- |-- container box box = (ContainerSchemaNode) endpoints.getDataChildByName("box"); assertNotNull(box); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "box"); + expectedQName = QName.create(UG_NS, UG_REV, "box"); assertEquals(expectedQName, box.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, box.getPath()); assertTrue(box.isAddedByUses()); // * |-- |-- |-- |-- |-- choice address-family - ChoiceNode af = (ChoiceNode) endpoints.getDataChildByName("address-family"); + ChoiceSchemaNode af = (ChoiceSchemaNode) endpoints.getDataChildByName("address-family"); assertNotNull(af); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "address-family"); + expectedQName = QName.create(UG_NS, UG_REV, "address-family"); assertEquals(expectedQName, af.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, af.getPath()); assertTrue(af.isAddedByUses()); // * |-- |-- |-- |-- container reported-route ContainerSchemaNode reportedRoute = (ContainerSchemaNode) p2p.getDataChildByName("reported-route"); assertNotNull(reportedRoute); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "reported-route"); + expectedQName = QName.create(UG_NS, UG_REV, "reported-route"); assertEquals(expectedQName, reportedRoute.getQName()); path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, reportedRoute.getPath()); assertFalse(reportedRoute.isAddedByUses()); // * |-- |-- |-- |-- |-- leaf processing-rule processingRule = (LeafSchemaNode) reportedRoute.getDataChildByName("processing-rule"); assertNotNull(processingRule); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "processing-rule"); + expectedQName = QName.create(UG_NS, UG_REV, "processing-rule"); assertEquals(expectedQName, processingRule.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, processingRule.getPath()); assertEquals(BooleanType.getInstance(), processingRule.getType()); assertTrue(processingRule.isAddedByUses()); // * |-- |-- |-- |-- |-- leaf ignore ignore = (LeafSchemaNode) reportedRoute.getDataChildByName("ignore"); assertNotNull(ignore); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "ignore"); + expectedQName = QName.create(UG_NS, UG_REV, "ignore"); assertEquals(expectedQName, ignore.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, ignore.getPath()); assertEquals(BooleanType.getInstance(), ignore.getType()); assertTrue(ignore.isAddedByUses()); // * |-- |-- |-- |-- |-- list subobjects ListSchemaNode subobjects = (ListSchemaNode) reportedRoute.getDataChildByName("subobjects"); assertNotNull(subobjects); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "subobjects"); + expectedQName = QName.create(UG_NS, UG_REV, "subobjects"); assertEquals(expectedQName, subobjects.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, subobjects.getPath()); assertTrue(subobjects.isAddedByUses()); // * |-- |-- |-- |-- |-- container bandwidth ContainerSchemaNode bandwidth = (ContainerSchemaNode) reportedRoute.getDataChildByName("bandwidth"); assertNotNull(bandwidth); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "bandwidth"); + expectedQName = QName.create(UG_NS, UG_REV, "bandwidth"); assertEquals(expectedQName, bandwidth.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, bandwidth.getPath()); assertFalse(bandwidth.isAddedByUses()); // * |-- |-- |-- |-- container bandwidth bandwidth = (ContainerSchemaNode) p2p.getDataChildByName("bandwidth"); assertNotNull(bandwidth); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "bandwidth"); + expectedQName = QName.create(UG_NS, UG_REV, "bandwidth"); assertEquals(expectedQName, bandwidth.getQName()); path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, bandwidth.getPath()); assertTrue(bandwidth.isAddedByUses()); // * |-- |-- |-- |-- |-- leaf processing-rule processingRule = (LeafSchemaNode) bandwidth.getDataChildByName("processing-rule"); assertNotNull(processingRule); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "processing-rule"); + expectedQName = QName.create(UG_NS, UG_REV, "processing-rule"); assertEquals(expectedQName, processingRule.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, processingRule.getPath()); assertEquals(BooleanType.getInstance(), processingRule.getType()); assertTrue(processingRule.isAddedByUses()); // * |-- |-- |-- |-- |-- leaf ignore ignore = (LeafSchemaNode) bandwidth.getDataChildByName("ignore"); assertNotNull(ignore); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "ignore"); + expectedQName = QName.create(UG_NS, UG_REV, "ignore"); assertEquals(expectedQName, ignore.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, ignore.getPath()); assertEquals(BooleanType.getInstance(), ignore.getType()); assertTrue(ignore.isAddedByUses()); // * |-- |-- |-- |-- |-- container bandwidth ContainerSchemaNode bandwidthInner = (ContainerSchemaNode) bandwidth.getDataChildByName("bandwidth"); assertNotNull(bandwidthInner); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "bandwidth"); + expectedQName = QName.create(UG_NS, UG_REV, "bandwidth"); assertEquals(expectedQName, bandwidth.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, bandwidthInner.getPath()); assertTrue(bandwidthInner.isAddedByUses()); // * |-- list svec ListSchemaNode svec = (ListSchemaNode) pcreq.getDataChildByName("svec"); assertNotNull(svec); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "svec"); + expectedQName = QName.create(UG_NS, UG_REV, "svec"); assertEquals(expectedQName, svec.getQName()); path.pollLast(); path.pollLast(); @@ -516,98 +522,98 @@ public class UsesAugmentTest { path.pollLast(); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, svec.getPath()); assertFalse(svec.isAddedByUses()); // * |-- |-- leaf link-diverse LeafSchemaNode linkDiverse = (LeafSchemaNode) svec.getDataChildByName("link-diverse"); assertNotNull(linkDiverse); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "link-diverse"); + expectedQName = QName.create(UG_NS, UG_REV, "link-diverse"); assertEquals(expectedQName, linkDiverse.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, linkDiverse.getPath()); assertEquals(BooleanType.getInstance(), linkDiverse.getType()); assertTrue(linkDiverse.isAddedByUses()); // * |-- |-- leaf processing-rule processingRule = (LeafSchemaNode) svec.getDataChildByName("processing-rule"); assertNotNull(processingRule); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "processing-rule"); + expectedQName = QName.create(UG_NS, UG_REV, "processing-rule"); assertEquals(expectedQName, processingRule.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, processingRule.getPath()); assertEquals(BooleanType.getInstance(), processingRule.getType()); assertTrue(processingRule.isAddedByUses()); // * |-- |-- leaf ignore ignore = (LeafSchemaNode) svec.getDataChildByName("ignore"); assertNotNull(ignore); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "ignore"); + expectedQName = QName.create(UG_NS, UG_REV, "ignore"); assertEquals(expectedQName, ignore.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, ignore.getPath()); assertEquals(BooleanType.getInstance(), ignore.getType()); assertTrue(ignore.isAddedByUses()); // * |-- |-- list metric ListSchemaNode metric = (ListSchemaNode) svec.getDataChildByName("metric"); assertNotNull(metric); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "metric"); + expectedQName = QName.create(UG_NS, UG_REV, "metric"); assertEquals(expectedQName, metric.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, metric.getPath()); assertFalse(metric.isAddedByUses()); // * |-- |-- |-- leaf metric-type LeafSchemaNode metricType = (LeafSchemaNode) metric.getDataChildByName("metric-type"); assertNotNull(metricType); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "metric-type"); + expectedQName = QName.create(UG_NS, UG_REV, "metric-type"); assertEquals(expectedQName, metricType.getQName()); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, metricType.getPath()); assertEquals(Uint8.getInstance(), metricType.getType()); assertTrue(metricType.isAddedByUses()); // * |-- |-- |-- box box = (ContainerSchemaNode) metric.getDataChildByName("box"); assertNotNull(box); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "box"); + expectedQName = QName.create(UG_NS, UG_REV, "box"); assertEquals(expectedQName, box.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, box.getPath()); assertTrue(box.isAddedByUses()); // * |-- |-- |-- leaf processing-rule processingRule = (LeafSchemaNode) metric.getDataChildByName("processing-rule"); assertNotNull(processingRule); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "processing-rule"); + expectedQName = QName.create(UG_NS, UG_REV, "processing-rule"); assertEquals(expectedQName, processingRule.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, processingRule.getPath()); assertEquals(BooleanType.getInstance(), processingRule.getType()); assertTrue(processingRule.isAddedByUses()); // * |-- |-- |-- leaf ignore ignore = (LeafSchemaNode) metric.getDataChildByName("ignore"); assertNotNull(ignore); - expectedQName = new QName(UG_NS, UG_REV, UG_PREF, "ignore"); + expectedQName = QName.create(UG_NS, UG_REV, "ignore"); assertEquals(expectedQName, ignore.getQName()); path.pollLast(); path.offer(expectedQName); - expectedPath= new SchemaPath(path, true); + expectedPath= SchemaPath.create(path, true); assertEquals(expectedPath, ignore.getPath()); assertEquals(BooleanType.getInstance(), ignore.getType()); assertTrue(ignore.isAddedByUses()); } @Test - public void testTypedefs() throws FileNotFoundException { - modules = TestUtils.loadModules(getClass().getResource("/grouping-test").getPath()); + public void testTypedefs() throws IOException, URISyntaxException { + modules = TestUtils.loadModules(getClass().getResource("/grouping-test").toURI()); Module testModule = TestUtils.findModule(modules, "grouping-definitions"); Set> types = testModule.getTypeDefinitions(); @@ -619,8 +625,8 @@ public class UsesAugmentTest { } assertNotNull(intExt); - List path = Lists.newArrayList(new QName(GD_NS, GD_REV, GD_PREF, "int-ext")); - SchemaPath expectedPath = new SchemaPath(path, true); + List path = Lists.newArrayList(QName.create(GD_NS, GD_REV, "int-ext")); + SchemaPath expectedPath = SchemaPath.create(path, true); assertEquals(expectedPath, intExt.getPath()); UnionType union = (UnionType)intExt.getBaseType(); @@ -638,7 +644,7 @@ public class UsesAugmentTest { assertNotNull(pv); QName q1 = BaseTypes.constructQName("union"); - expectedPath = new SchemaPath(Lists.newArrayList(q1), true); + expectedPath = SchemaPath.create(Lists.newArrayList(q1), true); assertEquals(expectedPath, union.getPath()); }