Java Code Examples for org.opendaylight.yangtools.yang.model.api.SchemaPath#create()

@Test
public void test() throws Exception {
    final SchemaContext schemaContext = YangParserTestUtils.parseYangResource("/bug7246/yang/rpc-test.yang");
    final JsonParser parser = new JsonParser();
    final JsonElement expextedJson = parser
            .parse(new FileReader(new File(getClass().getResource("/bug7246/json/expected-output.json").toURI())));

    final DataContainerChild<? extends PathArgument, ?> inputStructure = ImmutableContainerNodeBuilder.create()
            .withNodeIdentifier(new NodeIdentifier(qN("my-name")))
            .withChild(ImmutableNodes.leafNode(new NodeIdentifier(qN("my-name")), "my-value")).build();
    final SchemaPath rootPath = SchemaPath.create(true, qN("my-name"), qN("input"));
    final Writer writer = new StringWriter();
    final String jsonOutput = normalizedNodeToJsonStreamTransformation(schemaContext, rootPath, writer,
            inputStructure);
    final JsonElement serializedJson = parser.parse(jsonOutput);

    assertEquals(expextedJson, serializedJson);
}
 

@Test
public void testRestrictedTypeParentSchemaPathInDeviate() throws Exception {
    final SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug7440");
    assertNotNull(schemaContext);

    final Revision revision = Revision.of("2016-12-23");
    final Module foo = schemaContext.findModule("foo", revision).get();
    final Module bar = schemaContext.findModule("bar", revision).get();

    final Collection<? extends Deviation> deviations = foo.getDeviations();
    assertEquals(1, deviations.size());
    final Deviation deviation = deviations.iterator().next();

    final Collection<? extends DeviateDefinition> deviates = deviation.getDeviates();
    assertEquals(1, deviates.size());
    final DeviateDefinition deviateReplace = deviates.iterator().next();

    final SchemaPath deviatedTypePath = SchemaPath.create(true, QName.create(bar.getQNameModule(), "test-leaf"),
            QName.create(bar.getQNameModule(), "uint32"));

    final TypeDefinition<?> deviatedType = deviateReplace.getDeviatedType();
    assertEquals(deviatedTypePath, deviatedType.getPath());
}
 

@Test
public void testRequireInstanceSubstatement() {
    final SchemaPath schemaPath = SchemaPath.create(true, QName.create("test", "my-cont"),
        QName.create("test", "my-leafref"));
    final PathExpression path = new PathExpressionImpl("../my-leaf", false);
    final LeafrefTypeBuilder leafrefTypeBuilder = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(path);

    assertTrue(leafrefTypeBuilder.build().requireInstance());

    leafrefTypeBuilder.setRequireInstance(false);
    final LeafrefTypeDefinition falseLeafref = leafrefTypeBuilder.build();
    assertFalse(falseLeafref.requireInstance());

    leafrefTypeBuilder.setRequireInstance(true);
    final LeafrefTypeDefinition trueLeafref = leafrefTypeBuilder.build();
    assertTrue(trueLeafref.requireInstance());

    final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> falseBuilder =
            RestrictedTypes.newLeafrefBuilder(falseLeafref, schemaPath);
    assertFalse(falseBuilder.build().requireInstance());

    final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> trueBuilder =
            RestrictedTypes.newLeafrefBuilder(trueLeafref, schemaPath);
    assertTrue(trueBuilder.build().requireInstance());
}
 

@Test
public void findNodeInSchemaContextTheSameNameOfSiblingsTest() {
    final ChoiceSchemaNode choice = (ChoiceSchemaNode) getRpcByName(myModule, "my-name").getInput()
            .getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice"));
    final SchemaNode testNode = choice.findCaseNodes("case-two").iterator().next()
            .getDataChildByName(QName.create(myModule.getQNameModule(), "two"));

    final SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-name"),
            QName.create(myModule.getQNameModule(), "input"), QName.create(myModule.getQNameModule(), "my-choice"),
            QName.create(myModule.getQNameModule(), "case-two"), QName.create(myModule.getQNameModule(), "two"));
    final SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());

    assertNotNull(testNode);
    assertNotNull(foundNode);
    assertEquals(testNode, foundNode);
}
 

@Test
public void test() throws Exception {
    final SchemaContext context = TestUtils.parseYangSources("/bugs/bug7865");
    assertNotNull(context);

    final DataSchemaNode root = context.getDataChildByName(foo("root"));
    assertTrue(root instanceof ContainerSchemaNode);
    final Collection<? extends UnknownSchemaNode> unknownSchemaNodes = root.getUnknownSchemaNodes();
    assertEquals(1, unknownSchemaNodes.size());

    final UnknownSchemaNode unknownNode = unknownSchemaNodes.iterator().next();
    final Collection<? extends UnknownSchemaNode> subUnknownSchemaNodes = unknownNode.getUnknownSchemaNodes();
    assertEquals(1, subUnknownSchemaNodes.size());

    final UnknownSchemaNode subUnknownNode = subUnknownSchemaNodes.iterator().next();
    final Collection<? extends UnknownSchemaNode> subSubUnknownSchemaNodes = subUnknownNode.getUnknownSchemaNodes();
    assertEquals(1, subSubUnknownSchemaNodes.size());

    final UnknownSchemaNode subSubUnknownNode = subSubUnknownSchemaNodes.iterator().next();
    final SchemaPath expectedPath = SchemaPath.create(true, foo("root"), foo("p"), foo("p"), foo("p"));
    assertEquals(expectedPath, subSubUnknownNode.getPath());
}
 

@Test
public void correctTest3() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5335/correct/case-3");
    assertNotNull(context);

    final SchemaPath schemaPath = SchemaPath.create(true, ROOT, PRESENCE_CONTAINER_B, NON_PRESENCE_CONTAINER_B,
            MANDATORY_LEAF_B);
    final SchemaNode mandatoryLeaf = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertTrue(mandatoryLeaf instanceof LeafSchemaNode);
}
 

@Override
@Before
public void setUp() throws Exception {
    super.setUp();
    final SchemaPath schemaPath = SchemaPath.create(true,
            NetworkInstances.QNAME, NetworkInstance.QNAME, Protocols.QNAME);
    doReturn(schemaPath).when(this.processor).getSchemaPath();
    doReturn("processor").when(this.processor).toString();
}
 

@Test
public void correctTest2() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5335/correct/case-2");
    assertNotNull(context);

    final SchemaPath schemaPath = SchemaPath.create(true, ROOT, PRESENCE_CONTAINER_B, NON_PRESENCE_CONTAINER_B,
            MANDATORY_LEAF_B);
    final SchemaNode mandatoryLeaf = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertTrue(mandatoryLeaf instanceof LeafSchemaNode);
}
 

@Test
public void correctTest1() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5335/correct/case-1");
    assertNotNull(context);

    final SchemaPath schemaPath = SchemaPath.create(true, ROOT, PRESENCE_CONTAINER_B, MANDATORY_LEAF_B);
    final SchemaNode mandatoryLeaf = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertTrue(mandatoryLeaf instanceof LeafSchemaNode);
}
 

@Test
public void incorrectTest2() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5335/incorrect/case-2");
    assertNotNull(context);

    final SchemaPath schemaPath = SchemaPath.create(true, ROOT, PRESENCE_CONTAINER_F, MANDATORY_LEAF_B);
    final SchemaNode mandatoryLeaf = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertNull(mandatoryLeaf);

    final String testLog = output.toString();
    assertTrue(testLog.contains(
        "An augment cannot add node 'mandatory-leaf' because it is mandatory and in module different than target"));
}
 

@Test
public void incorrectTest1() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5335/incorrect/case-1");
    assertNotNull(context);

    final SchemaPath schemaPath = SchemaPath.create(true, ROOT, NON_PRESENCE_CONTAINER_B, MANDATORY_LEAF_B);
    final SchemaNode mandatoryLeaf = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertNull(mandatoryLeaf);

    final String testLog = output.toString();
    assertTrue(testLog.contains(
        "An augment cannot add node 'mandatory-leaf' because it is mandatory and in module different than target"));
}
 

public static SchemaPath createPath(final boolean absolute, final QNameModule module, final String... names) {
    List<QName> path = new ArrayList<>(names.length);
    for (String name : names) {
        path.add(QName.create(module, name));
    }
    return SchemaPath.create(path, absolute);
}
 

@Test
public void canCreateBitsType() {
    doReturn("test").when(bit).getName();
    doReturn(Uint32.ZERO).when(bit).getPosition();
    doReturn("toString").when(bit).toString();

    QName qname = QName.create("namespace", "localname");
    SchemaPath schemaPath = SchemaPath.create(true, qname);

    BitsTypeDefinition bitsType = BaseTypes.bitsTypeBuilder(schemaPath).addBit(bit).build();

    assertFalse(bitsType.getDescription().isPresent());
    assertEquals("QName", qname, bitsType.getQName());
    assertEquals(Optional.empty(), bitsType.getUnits());
    assertNotEquals("Description should not be null", null, bitsType.toString());
    assertFalse(bitsType.getReference().isPresent());
    assertNull("BaseType should be null", bitsType.getBaseType());
    assertEquals(Optional.empty(), bitsType.getDefaultValue());
    assertEquals("getPath should equal schemaPath", schemaPath, bitsType.getPath());
    assertEquals("Status should be CURRENT", Status.CURRENT, bitsType.getStatus());
    assertEquals("Should be empty list", Collections.emptyList(), bitsType.getUnknownSchemaNodes());
    assertEquals("Values should be [enumPair]", Collections.singletonList(bit), bitsType.getBits());

    assertEquals("Hash code of bitsType should be equal",
            bitsType.hashCode(), bitsType.hashCode());
    assertNotEquals("bitsType shouldn't equal to null", null, bitsType);
    assertEquals("bitsType should equals to itself", bitsType, bitsType);
    assertNotEquals("bitsType shouldn't equal to object of other type", "str", bitsType);
}
 

@Test
public void testMethodsOfLeafrefTest() {
    final SchemaPath schemaPath = SchemaPath.create(false, QName.create("test", "Cont1"),
        QName.create("test", "List1"));
    final PathExpression revision = new PathExpressionImpl("/test:Cont1/test:List1", false);
    final PathExpression revision2 = new PathExpressionImpl("/test:Cont1/test:List2", false);

    final LeafrefTypeDefinition leafref = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(revision)
        .build();
    final LeafrefTypeDefinition leafref2 = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(revision2)
        .build();
    final LeafrefTypeDefinition leafref3 = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(revision)
        .build();
    final LeafrefTypeDefinition leafref4 = leafref;

    assertNotNull("Object 'leafref' shouldn't be null.", leafref);
    assertNull("Base type of 'leafref' should be null.", leafref.getBaseType());
    assertEquals(Optional.empty(), leafref.getUnits());
    assertEquals(Optional.empty(), leafref.getDefaultValue());
    assertEquals(QName.create("test", "List1"), leafref.getQName());
    assertEquals("SchemaPath of 'leafref' is '/Cont1/List1'.", schemaPath, leafref.getPath());
    assertFalse(leafref.getDescription().isPresent());
    assertFalse(leafref.getReference().isPresent());
    assertEquals("Status of 'leafref' is current.", Status.CURRENT, leafref.getStatus());
    assertTrue("Object 'leafref' shouldn't have any unknown schema nodes.",
            leafref.getUnknownSchemaNodes().isEmpty());
    assertEquals("Revision aware XPath of 'leafref' should be '/test:Cont1/test:List1'.", revision,
            leafref.getPathStatement());
    assertNotNull("String representation of 'leafref' shouldn't be null.", leafref.toString());
    assertNotEquals("Hash codes of two different object of type Leafref shouldn't be equal.", leafref.hashCode(),
            leafref2.hashCode());
    assertTrue("Objects of type Leafref should be equal.", leafref.equals(leafref3));
    assertTrue("Objects of type Leafref should be equal.", leafref.equals(leafref4));
    assertFalse("Objects of type Leafref shouldn't be equal.", leafref.equals(leafref2));
    assertFalse("Objects shouldn't be equal.", leafref.equals(null));
    assertFalse("Objects shouldn't be equal.", leafref.equals("test"));
}
 

@Test
public void testNotification() {
    final Collection<? extends NotificationDefinition> notifications = baz.getNotifications();
    assertEquals(1, notifications.size());

    final NotificationDefinition notification = notifications.iterator().next();
    // test SchemaNode args
    assertEquals(QName.create(BAZ, "event"), notification.getQName());
    final SchemaPath expectedPath = SchemaPath.create(true,  QName.create(BAZ, "event"));
    assertEquals(expectedPath, notification.getPath());
    assertFalse(notification.getDescription().isPresent());
    assertFalse(notification.getReference().isPresent());
    assertEquals(Status.CURRENT, notification.getStatus());
    assertEquals(0, notification.getUnknownSchemaNodes().size());
    // test DataNodeContainer args
    assertEquals(0, notification.getTypeDefinitions().size());
    assertEquals(3, notification.getChildNodes().size());
    assertEquals(0, notification.getGroupings().size());
    assertEquals(0, notification.getUses().size());

    final LeafSchemaNode eventClass = (LeafSchemaNode) notification.getDataChildByName(
        QName.create(baz.getQNameModule(), "event-class"));
    assertTrue(eventClass.getType() instanceof StringTypeDefinition);
    final LeafSchemaNode severity = (LeafSchemaNode) notification.getDataChildByName(
        QName.create(baz.getQNameModule(), "severity"));
    assertTrue(severity.getType() instanceof StringTypeDefinition);
}
 

@Test
public void correctTest4() throws Exception {
    final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5335/correct/case-4");
    assertNotNull(context);

    final SchemaPath schemaPath = SchemaPath.create(true, ROOT, NON_PRESENCE_CONTAINER_F, MANDATORY_LEAF_F);
    final SchemaNode mandatoryLeaf = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertTrue(mandatoryLeaf instanceof LeafSchemaNode);
}
 

private static SchemaPath createPath(final String... names) {
    final Revision rev = Revision.of("2013-07-30");
    final List<QName> path = new ArrayList<>();
    for (final String name : names) {
        path.add(QName.create(NS, rev, name));
    }
    return SchemaPath.create(path, true);
}
 

@Test
public void refineTest() throws ReactorException {
    SchemaContext result = RFC7950Reactors.defaultReactor().newBuild()
            .addSource(sourceForResource("/stmt-test/uses/refine-test.yang"))
            .buildEffective();
    assertNotNull(result);

    Collection<? extends Module> modules = result.getModules();
    assertNotNull(modules);
    assertEquals(1, modules.size());

    Module module = modules.iterator().next();

    final QNameModule qnameModule = module.getQNameModule();
    final QName rootContainer = QName.create(qnameModule, "root-container");
    final QName grp1 = QName.create(qnameModule, "grp-1");

    final QName containerFromGrouping = QName.create(qnameModule, "container-from-grouping");
    final QName listInContainer = QName.create(qnameModule, "list-in-container");
    final QName choiceFromGrp = QName.create(qnameModule, "choice-from-grp");

    final QName containerFromGrouping2 = QName.create(qnameModule, "container-from-grouping2");
    final QName presenceContainer = QName.create(qnameModule, "presence-container");

    SchemaPath listInContainerPath = SchemaPath.create(true, rootContainer, containerFromGrouping, listInContainer);
    SchemaPath choiceFromGrpPath = SchemaPath.create(true, rootContainer, containerFromGrouping, choiceFromGrp);
    SchemaPath presenceContainerPath = SchemaPath.create(true, rootContainer, containerFromGrouping2,
        presenceContainer);

    checkRefinedList(result, listInContainerPath);
    checkRefinedChoice(result, choiceFromGrpPath);
    checkRefinedContainer(result, presenceContainerPath);

    SchemaPath originalListInContainerPath = SchemaPath.create(true, grp1, containerFromGrouping, listInContainer);
    SchemaPath originalChoiceFromGrpPath = SchemaPath.create(true, grp1, containerFromGrouping, choiceFromGrp);
    SchemaPath originalPresenceContainerPath = SchemaPath.create(true, grp1, containerFromGrouping2,
        presenceContainer);

    checkOriginalList(result, originalListInContainerPath);
    checkOriginalChoice(result, originalChoiceFromGrpPath);
    checkOriginalContainer(result, originalPresenceContainerPath);
}
 

@Test
public void test() throws Exception {
    SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug5396");
    assertNotNull(context);

    QName root = QName.create("foo", "root");
    QName myLeaf2 = QName.create("foo", "my-leaf2");

    SchemaPath schemaPath = SchemaPath.create(true, root, myLeaf2);
    SchemaNode findDataSchemaNode = SchemaContextUtil.findDataSchemaNode(context, schemaPath);
    assertTrue(findDataSchemaNode instanceof LeafSchemaNode);

    LeafSchemaNode leaf2 = (LeafSchemaNode) findDataSchemaNode;
    TypeDefinition<?> type = leaf2.getType();
    assertTrue(type instanceof UnionTypeDefinition);

    UnionTypeDefinition union = (UnionTypeDefinition) type;
    List<TypeDefinition<?>> types = union.getTypes();

    assertEquals(4, types.size());

    TypeDefinition<?> type0 = types.get(0);
    TypeDefinition<?> type1 = types.get(1);
    TypeDefinition<?> type2 = types.get(2);
    TypeDefinition<?> type3 = types.get(3);

    assertFalse(type0.equals(type1));
    assertFalse(type0.equals(type2));
    assertFalse(type0.equals(type3));

    assertTrue(type0 instanceof StringTypeDefinition);
    assertTrue(type1 instanceof StringTypeDefinition);
    assertTrue(type2 instanceof StringTypeDefinition);
    assertTrue(type3 instanceof StringTypeDefinition);

    StringTypeDefinition stringType0 = (StringTypeDefinition) type0;
    StringTypeDefinition stringType1 = (StringTypeDefinition) type1;
    StringTypeDefinition stringType2 = (StringTypeDefinition) type2;
    StringTypeDefinition stringType3 = (StringTypeDefinition) type3;

    final List<PatternConstraint> patternConstraints0 = stringType0.getPatternConstraints();
    final List<PatternConstraint> patternConstraints1 = stringType1.getPatternConstraints();
    final List<PatternConstraint> patternConstraints2 = stringType2.getPatternConstraints();
    final List<PatternConstraint> patternConstraints3 = stringType3.getPatternConstraints();

    assertEquals(1, patternConstraints0.size());
    assertEquals(1, patternConstraints1.size());
    assertEquals(1, patternConstraints2.size());
    assertEquals(1, patternConstraints3.size());

    final PatternConstraint patternConstraint0 = patternConstraints0.get(0);
    final PatternConstraint patternConstraint1 = patternConstraints1.get(0);
    final PatternConstraint patternConstraint2 = patternConstraints2.get(0);
    final PatternConstraint patternConstraint3 = patternConstraints3.get(0);

    assertEquals("^(?:dp[0-9]+o[0-9]+(d[0-9]+)?)$", patternConstraint0.getJavaPatternString());
    assertEquals("^(?:dp[0-9]+s[0-9]+(f[0-9]+)?(d[0-9]+)?)$", patternConstraint1.getJavaPatternString());
    assertEquals("^(?:dp[0-9]+(P[0-9]+)?p[0-9]{1,3}s[0-9]{1,3}(f[0-9]+)?(d[0-9]+)?)$",
            patternConstraint2.getJavaPatternString());
    assertEquals("^(?:dp[0-9]+p[0-9]+p[0-9]+)$", patternConstraint3.getJavaPatternString());
}
 

@Test
public void findNodeInSchemaContextTest3() {
    SchemaNode testNode = myModule.getDataChildByName(QName.create(myModule.getQNameModule(), "my-container"));

    SchemaPath path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"));
    SchemaNode foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());

    assertNotNull(testNode);
    assertNotNull(foundNode);
    assertEquals(testNode, foundNode);

    testNode = getRpcByName(myModule, "my-rpc");

    path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-rpc"));
    foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());

    assertNotNull(testNode);
    assertNotNull(foundNode);
    assertEquals(testNode, foundNode);

    testNode = myModule.getNotifications().iterator().next();

    path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-notification"));
    foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());

    assertNotNull(testNode);
    assertNotNull(foundNode);
    assertEquals(testNode, foundNode);

    testNode = getGroupingByName(myModule, "my-grouping");

    path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-grouping"));
    foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());

    assertNotNull(testNode);
    assertNotNull(foundNode);
    assertEquals(testNode, foundNode);

    testNode = myModule.getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice"));

    path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-choice"));
    foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());

    assertNotNull(testNode);
    assertNotNull(foundNode);
    assertEquals(testNode, foundNode);

    testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(myModule.getQNameModule(),
            "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(), "my-list"));

    path = SchemaPath.create(true, QName.create(myModule.getQNameModule(), "my-container"),
            QName.create(myModule.getQNameModule(), "my-list"));
    foundNode = SchemaContextUtil.findNodeInSchemaContext(context, path.getPathFromRoot());

    assertNotNull(testNode);
    assertNotNull(foundNode);
    assertEquals(testNode, foundNode);
}