import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.io.FileNotFoundException;
-import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
-import java.util.Set;
import org.apache.log4j.BasicConfigurator;
+import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefDataValidationFailedException;
-import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefValidatation;
+import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefValidation;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DataTreeCandidateValidatorTest {
- private static SchemaContext context;
+ private static EffectiveModelContext context;
private static Module valModule;
private static QNameModule valModuleQname;
private static LeafRefContext rootLeafRefContext;
- public static TipProducingDataTree inMemoryDataTree;
+ public static DataTree inMemoryDataTree;
private static QName odl;
private static QName project;
}
@BeforeClass
- public static void init() throws FileNotFoundException, ReactorException,
- URISyntaxException {
- initSchemaContext();
-
- initLeafRefContext();
-
- initQnames();
-
- initDataTree();
-
- }
-
- private static void initSchemaContext() {
+ public static void init() throws DataValidationFailedException {
context = YangParserTestUtils.parseYangResourceDirectory("/leafref-validation");
- final Set<Module> modules = context.getModules();
- for (final Module module : modules) {
+ for (final Module module : context.getModules()) {
if (module.getName().equals("leafref-validation")) {
valModule = module;
}
}
valModuleQname = valModule.getQNameModule();
- }
-
- private static void initLeafRefContext() {
rootLeafRefContext = LeafRefContext.create(context);
- }
- private static void initQnames() {
odl = QName.create(valModuleQname, "odl-project");
project = QName.create(valModuleQname, "project");
name = QName.create(valModuleQname, "name");
leafrefLeafList = QName.create(valModuleQname, "leafref-leaf-list");
- }
-
- private static void initDataTree() {
- inMemoryDataTree = InMemoryDataTreeFactory.getInstance().create(DataTreeConfiguration.DEFAULT_OPERATIONAL);
- inMemoryDataTree.setSchemaContext(context);
+ inMemoryDataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL, context);
final DataTreeModification initialDataTreeModification = inMemoryDataTree
.takeSnapshot().newModification();
- final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule
- .getDataChildByName(odl);
+ final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule.findDataChildByName(odl)
+ .get();
final ContainerNode odlProjectContainer = createOdlContainer(odlProjContSchemaNode);
inMemoryDataTree.commit(writeContributorsCandidate);
}
+ @AfterClass
+ public static void cleanup() {
+ inMemoryDataTree = null;
+ rootLeafRefContext = null;
+ valModule = null;
+ context = null;
+ }
+
@Test
- public void dataTreeCanditateValidationTest() {
+ public void dataTreeCanditateValidationTest() throws DataValidationFailedException {
write();
write2();
writeIntoMapEntry();
}
- private static void writeContributors() {
+ private static void writeContributors() throws DataValidationFailedException {
final ContainerSchemaNode contributorContSchemaNode = (ContainerSchemaNode) valModule
- .getDataChildByName(odlContributor);
+ .findDataChildByName(odlContributor).get();
final ContainerNode contributorContainer = createBasicContributorContainer(contributorContSchemaNode);
boolean exception = false;
try {
- LeafRefValidatation.validate(writeContributorsCandidate,
+ LeafRefValidation.validate(writeContributorsCandidate,
rootLeafRefContext);
} catch (final LeafRefDataValidationFailedException e) {
- LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
+ LOG.debug("All validation errors:{}{}", NEW_LINE, e.getMessage());
assertEquals(3, e.getValidationsErrorsCount());
exception = true;
}
}
- private static void writeIntoMapEntry() {
+ private static void writeIntoMapEntry() throws DataValidationFailedException {
final Map<QName, Object> keys = new HashMap<>();
keys.put(name, "New Project");
- final NodeIdentifierWithPredicates mapEntryPath = new NodeIdentifierWithPredicates(
- project, keys);
+ final NodeIdentifierWithPredicates mapEntryPath = NodeIdentifierWithPredicates.of(project, keys);
final YangInstanceIdentifier leaderPath = YangInstanceIdentifier
.of(odl).node(project).node(mapEntryPath).node(lead);
boolean exception = false;
try {
- LeafRefValidatation.validate(writeContributorsCandidate,
+ LeafRefValidation.validate(writeContributorsCandidate,
rootLeafRefContext);
} catch (final LeafRefDataValidationFailedException e) {
- LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
+ LOG.debug("All validation errors:{}{}", NEW_LINE, e.getMessage());
assertEquals(1, e.getValidationsErrorsCount());
exception = true;
}
}
- private static void writeMapEntry() {
+ private static void writeMapEntry() throws DataValidationFailedException {
final Map<QName, Object> keys = new HashMap<>();
keys.put(name, "New Project");
- final NodeIdentifierWithPredicates mapEntryPath = new NodeIdentifierWithPredicates(
- project, keys);
+ final NodeIdentifierWithPredicates mapEntryPath = NodeIdentifierWithPredicates.of(project, keys);
final YangInstanceIdentifier newOdlProjectMapEntryPath = YangInstanceIdentifier
.of(odl).node(project).node(mapEntryPath);
- final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule
- .getDataChildByName(odl);
- final ListSchemaNode projListSchemaNode = (ListSchemaNode) odlProjContSchemaNode
- .getDataChildByName(project);
+ final ContainerSchemaNode odlProjContSchemaNode = (ContainerSchemaNode) valModule.findDataChildByName(odl)
+ .get();
+ final ListSchemaNode projListSchemaNode = (ListSchemaNode) odlProjContSchemaNode.findDataChildByName(project)
+ .get();
final MapEntryNode newProjectMapEntry = createProjectListEntry(
"New Project", "New Project description ...",
"Leader of New Project", "Owner of New Project",
boolean exception = false;
try {
- LeafRefValidatation.validate(writeContributorsCandidate,
+ LeafRefValidation.validate(writeContributorsCandidate,
rootLeafRefContext);
} catch (final LeafRefDataValidationFailedException e) {
- LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
+ LOG.debug("All validation errors:{}{}", NEW_LINE, e.getMessage());
assertEquals(2, e.getValidationsErrorsCount());
exception = true;
}
}
- private static void write() {
+ private static void write() throws DataValidationFailedException {
final ContainerSchemaNode contributorContSchemaNode = (ContainerSchemaNode) valModule
- .getDataChildByName(odlContributor);
+ .findDataChildByName(odlContributor).get();
final ContainerNode contributorContainer = createContributorContainer(contributorContSchemaNode);
boolean exception = false;
try {
- LeafRefValidatation.validate(writeContributorsCandidate,
+ LeafRefValidation.validate(writeContributorsCandidate,
rootLeafRefContext);
} catch (final LeafRefDataValidationFailedException e) {
- LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
+ LOG.debug("All validation errors:{}{}", NEW_LINE, e.getMessage());
assertEquals(12, e.getValidationsErrorsCount());
exception = true;
}
assertTrue(exception);
}
- private static void write2() {
+ private static void write2() throws DataValidationFailedException {
- final ContainerSchemaNode odlCon = (ContainerSchemaNode) valModule
- .getDataChildByName(odl);
- final ContainerSchemaNode con1Con = (ContainerSchemaNode) odlCon
- .getDataChildByName(con1);
+ final ContainerSchemaNode odlCon = (ContainerSchemaNode) valModule.findDataChildByName(odl).get();
+ final ContainerSchemaNode con1Con = (ContainerSchemaNode) odlCon.findDataChildByName(con1).get();
final LeafNode<String> l1Leaf = ImmutableNodes.leafNode(l1, "l1 value");
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
.containerBuilder(con1Con);
containerBuilder.addChild(l1Leaf);
final ContainerNode con1Node = containerBuilder.build();
boolean exception = false;
try {
- LeafRefValidatation.validate(writeContributorsCandidate,
+ LeafRefValidation.validate(writeContributorsCandidate,
rootLeafRefContext);
} catch (final LeafRefDataValidationFailedException e) {
- LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
+ LOG.debug("All validation errors:{}{}", NEW_LINE, e.getMessage());
assertEquals(6, e.getValidationsErrorsCount());
exception = true;
}
choiceBuilder.addChild(mapBuilder.build());
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders
.containerBuilder();
containerBuilder.withNodeIdentifier(new NodeIdentifier(con3));
private static MapEntryNode createList3Entry(final String keyVal,
final String l3Val1, final String l3Val2, final String l3Val3) {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
.mapEntryBuilder();
- mapEntryBuilder.withNodeIdentifier(new NodeIdentifierWithPredicates(
- list3InChoice, k, keyVal));
+ mapEntryBuilder.withNodeIdentifier(NodeIdentifierWithPredicates.of(list3InChoice, k, keyVal));
final ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafSetBuilder = Builders
.leafSetBuilder();
private static LeafSetEntryNode<Object> createLeafSetEntry(
final QName qname, final String val) {
- final NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder = Builders
+ final NormalizedNodeBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> leafSetEntryBuilder = Builders
.leafSetEntryBuilder();
leafSetEntryBuilder.withNodeIdentifier(new NodeWithValue<>(qname, val));
leafSetEntryBuilder.withValue(val);
final String leafrefInChoiceVal,
final String leafrefInChoiceToChoiceVal) {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder = Builders
.mapEntryBuilder();
- mapEntryBuilder.withNodeIdentifier(new NodeIdentifierWithPredicates(
+ mapEntryBuilder.withNodeIdentifier(NodeIdentifierWithPredicates.of(
listInChoice, listInChoiceKey, keyVal));
mapEntryBuilder.addChild(ImmutableNodes.leafNode(listInChoiceKey,
return mapEntryBuilder.build();
}
- private static void delete() {
+ private static void delete() throws DataValidationFailedException {
final YangInstanceIdentifier contributorPath = YangInstanceIdentifier
.of(odlContributor);
delete.delete(contributorPath);
delete.ready();
- final DataTreeCandidate deleteContributorsCanditate = inMemoryDataTree
- .prepare(delete);
+ final DataTreeCandidate deleteContributorsCanditate = inMemoryDataTree.prepare(delete);
LOG.debug("*************************");
LOG.debug("Before delete: ");
boolean exception = false;
try {
- LeafRefValidatation.validate(deleteContributorsCanditate,
+ LeafRefValidation.validate(deleteContributorsCanditate,
rootLeafRefContext);
} catch (final LeafRefDataValidationFailedException e) {
- LOG.debug("All validation errors:" + NEW_LINE + e.getMessage());
+ LOG.debug("All validation errors:{}{}", NEW_LINE, e.getMessage());
assertEquals(6, e.getValidationsErrorsCount());
exception = true;
}
final ContainerSchemaNode contributorContSchemaNode) {
final ListSchemaNode contributorListSchemaNode = (ListSchemaNode) contributorContSchemaNode
- .getDataChildByName(contributor);
+ .findDataChildByName(contributor).get();
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
.containerBuilder(contributorContSchemaNode);
final MapNode contributorMap = createContributorList(contributorListSchemaNode);
final String odlProjectNameVal, final String odlProjectDescVal,
final ListSchemaNode contributorListSchemaNode) {
- final LeafNode<String> loginLeaf = ImmutableNodes.leafNode(login,
- loginVal);
- final LeafNode<String> contributorNameLeaf = ImmutableNodes.leafNode(
- contributorName, contributorNameVal);
- final LeafNode<String> odlProjectNameLeafRef = ImmutableNodes.leafNode(
- odlProjectName, odlProjectNameVal);
- final LeafNode<String> odlProjectDescLeafRef = ImmutableNodes.leafNode(
- odlProjectDesc, odlProjectDescVal);
+ final LeafNode<String> loginLeaf = ImmutableNodes.leafNode(login, loginVal);
+ final LeafNode<String> contributorNameLeaf = ImmutableNodes.leafNode(contributorName, contributorNameVal);
+ final LeafNode<String> odlProjectNameLeafRef = ImmutableNodes.leafNode(odlProjectName, odlProjectNameVal);
+ final LeafNode<String> odlProjectDescLeafRef = ImmutableNodes.leafNode(odlProjectDesc, odlProjectDescVal);
return Builders.mapEntryBuilder(contributorListSchemaNode)
.addChild(loginLeaf)
private static ContainerNode createOdlContainer(
final ContainerSchemaNode container) {
- final ListSchemaNode projListSchemaNode = (ListSchemaNode) container
- .getDataChildByName(project);
+ final ListSchemaNode projListSchemaNode = (ListSchemaNode) container.findDataChildByName(project).get();
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> odlProjectContainerBldr = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> odlProjectContainerBldr = Builders
.containerBuilder(container);
final MapNode projectMap = createProjectList(projListSchemaNode);
final LeafNode<String> ownerLeafRef = ImmutableNodes.leafNode(owner,
ownerVal);
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> projMapEntryBldr = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> projMapEntryBldr = Builders
.mapEntryBuilder(projListSchemaNode);
projMapEntryBldr.addChild(nameLeaf);
final ContainerSchemaNode contributorContSchemaNode) {
final ListSchemaNode contributorListSchemaNode = (ListSchemaNode) contributorContSchemaNode
- .getDataChildByName(contributor);
+ .findDataChildByName(contributor).get();
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> contributorContainerBldr = Builders
.containerBuilder(contributorContSchemaNode);
final MapNode contributorMap = createBasicContributorList(contributorListSchemaNode);
return contributorMap;
}
-}
\ No newline at end of file
+}
Code Review / yangtools.git / blobdiff