* @return A data tree instance.
*/
DataTree create();
+
+ /**
+ * Create a new data tree.
+ *
+ * @return A data tree instance.
+ */
+ DataTree create(TreeType type);
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.api.schema.tree;
+
+
+public enum TreeType {
+
+ CONFIGURATION,
+
+ OPERATIONAL
+}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
@Override
public ModificationApplyOperation load(final PathArgument key) {
if (key instanceof AugmentationIdentifier && schema instanceof AugmentationTarget) {
- return SchemaAwareApplyOperation.from(schema, (AugmentationTarget) schema, (AugmentationIdentifier) key);
+ return SchemaAwareApplyOperation.from(schema, (AugmentationTarget) schema, (AugmentationIdentifier) key, treeType);
}
final DataSchemaNode child = schema.getDataChildByName(key.getNodeType());
Preconditions.checkArgument(child != null, "Schema %s does not have a node for child %s", schema, key.getNodeType());
- return SchemaAwareApplyOperation.from(child);
+ return SchemaAwareApplyOperation.from(child, treeType);
}
});
private final T schema;
+ private final TreeType treeType;
- protected AbstractDataNodeContainerModificationStrategy(final T schema, final Class<? extends NormalizedNode<?, ?>> nodeClass) {
+ protected AbstractDataNodeContainerModificationStrategy(final T schema, final Class<? extends NormalizedNode<?, ?>> nodeClass, final TreeType treeType) {
super(nodeClass);
- this.schema = Preconditions.checkNotNull(schema);
+ this.schema = Preconditions.checkNotNull(schema,"schema");
+ this.treeType = Preconditions.checkNotNull(treeType,"treeType");
}
protected final T getSchema() {
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
private final Class<? extends NormalizedNode<?, ?>> nodeClass;
protected AbstractNodeContainerModificationStrategy(final Class<? extends NormalizedNode<?, ?>> nodeClass) {
- this.nodeClass = Preconditions.checkNotNull(nodeClass);
- }
-
- @Override
- void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
- for (ModifiedNode childModification : modification.getChildren()) {
- resolveChildOperation(childModification.getIdentifier()).verifyStructure(childModification);
- }
+ this.nodeClass = Preconditions.checkNotNull(nodeClass , "nodeClass");
}
@SuppressWarnings("rawtypes")
@Override
- protected void verifyWrittenStructure(final NormalizedNode<?, ?> writtenValue) {
+ void verifyStructure(final NormalizedNode<?, ?> writtenValue) {
checkArgument(nodeClass.isInstance(writtenValue), "Node %s is not of type %s", writtenValue, nodeClass);
checkArgument(writtenValue instanceof NormalizedNodeContainer);
- NormalizedNodeContainer container = (NormalizedNodeContainer) writtenValue;
- for (Object child : container.getValue()) {
+ final NormalizedNodeContainer container = (NormalizedNodeContainer) writtenValue;
+ for (final Object child : container.getValue()) {
checkArgument(child instanceof NormalizedNode);
-
- /*
- * FIXME: fail-fast semantics:
- *
- * We can validate the data structure here, aborting the commit
- * before it ever progresses to being committed.
- */
+ final NormalizedNode<?, ?> castedChild = (NormalizedNode<?, ?>) child;
+ final Optional<ModificationApplyOperation> childOp = getChild(castedChild.getIdentifier());
+ if(childOp.isPresent()) {
+ childOp.get().verifyStructure(castedChild);
+ } else {
+ throw new SchemaValidationFailedException(String.format("Child %s is not valid child according to schema.",
+ castedChild.getIdentifier()));
+ }
}
}
private TreeNode mutateChildren(final MutableTreeNode meta, final NormalizedNodeContainerBuilder data,
final Version nodeVersion, final Iterable<ModifiedNode> modifications) {
- for (ModifiedNode mod : modifications) {
+ for (final ModifiedNode mod : modifications) {
final YangInstanceIdentifier.PathArgument id = mod.getIdentifier();
final Optional<TreeNode> cm = meta.getChild(id);
- Optional<TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
+ final Optional<TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
if (result.isPresent()) {
final TreeNode tn = result.get();
meta.addChild(tn);
* In order to do that, though, we have to check all child operations are UNMODIFIED.
* Let's do precisely that, stopping as soon we find a different result.
*/
- for (ModifiedNode child : children) {
+ for (final ModifiedNode child : children) {
if (child.getModificationType() != ModificationType.UNMODIFIED) {
modification.resolveModificationType(ModificationType.SUBTREE_MODIFIED);
return ret;
* @param current Current data tree node.
*/
private void checkChildPreconditions(final YangInstanceIdentifier path, final NodeModification modification, final TreeNode current) throws DataValidationFailedException {
- for (NodeModification childMod : modification.getChildren()) {
+ for (final NodeModification childMod : modification.getChildren()) {
final YangInstanceIdentifier.PathArgument childId = childMod.getIdentifier();
final Optional<TreeNode> childMeta = current.getChild(childId);
- YangInstanceIdentifier childPath = path.node(childId);
+ final YangInstanceIdentifier childPath = path.node(childId);
resolveChildOperation(childId).checkApplicable(childPath, childMod, childMeta);
}
}
}
@Override
- protected final void verifyWrittenStructure(final NormalizedNode<?, ?> writtenValue) {
+ protected final void verifyStructure(final NormalizedNode<?, ?> writtenValue) {
checkArgument(nodeClass.isInstance(writtenValue), "Node should must be of type %s", nodeClass);
}
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
}
@Override
- void verifyStructure(final ModifiedNode modification) {
+ void verifyStructure(final NormalizedNode<?, ?> modification) {
throw new IllegalStateException("Schema Context is not available.");
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import java.util.HashSet;
import java.util.Set;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
final class AugmentationModificationStrategy extends AbstractDataNodeContainerModificationStrategy<AugmentationSchema> {
- AugmentationModificationStrategy(final AugmentationSchema schema, final DataNodeContainer resolved) {
- super(createAugmentProxy(schema,resolved), AugmentationNode.class);
+ AugmentationModificationStrategy(final AugmentationSchema schema, final DataNodeContainer resolved, final TreeType treeType) {
+ super(createAugmentProxy(schema,resolved), AugmentationNode.class, treeType);
}
@Override
}
private static AugmentationSchema createAugmentProxy(final AugmentationSchema schema, final DataNodeContainer resolved) {
- Set<DataSchemaNode> realChildSchemas = new HashSet<>();
- for(DataSchemaNode augChild : schema.getChildNodes()) {
+ final Set<DataSchemaNode> realChildSchemas = new HashSet<>();
+ for(final DataSchemaNode augChild : schema.getChildNodes()) {
realChildSchemas.add(resolved.getDataChildByName(augChild.getQName()));
}
return new EffectiveAugmentationSchema(schema, realChildSchemas);
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
final class ChoiceModificationStrategy extends AbstractNodeContainerModificationStrategy {
private final Map<YangInstanceIdentifier.PathArgument, ModificationApplyOperation> childNodes;
- ChoiceModificationStrategy(final ChoiceSchemaNode schemaNode) {
+ ChoiceModificationStrategy(final ChoiceSchemaNode schemaNode, final TreeType treeType) {
super(ChoiceNode.class);
- ImmutableMap.Builder<YangInstanceIdentifier.PathArgument, ModificationApplyOperation> child = ImmutableMap.builder();
+ final ImmutableMap.Builder<YangInstanceIdentifier.PathArgument, ModificationApplyOperation> child = ImmutableMap.builder();
- for (ChoiceCaseNode caze : schemaNode.getCases()) {
- for (DataSchemaNode cazeChild : caze.getChildNodes()) {
- SchemaAwareApplyOperation childNode = SchemaAwareApplyOperation.from(cazeChild);
- child.put(new YangInstanceIdentifier.NodeIdentifier(cazeChild.getQName()), childNode);
+ for (final ChoiceCaseNode caze : schemaNode.getCases()) {
+ if(SchemaAwareApplyOperation.belongsToTree(treeType,caze)) {
+ for (final DataSchemaNode cazeChild : caze.getChildNodes()) {
+ if(SchemaAwareApplyOperation.belongsToTree(treeType,cazeChild)) {
+ final SchemaAwareApplyOperation childNode = SchemaAwareApplyOperation.from(cazeChild,treeType);
+ child.put(new YangInstanceIdentifier.NodeIdentifier(cazeChild.getQName()), childNode);
+ }
+ }
}
}
childNodes = child.build();
/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final class ContainerModificationStrategy extends AbstractDataNodeContainerModificationStrategy<ContainerSchemaNode> {
- ContainerModificationStrategy(final ContainerSchemaNode schemaNode) {
- super(schemaNode, ContainerNode.class);
+ ContainerModificationStrategy(final ContainerSchemaNode schemaNode, final TreeType treeType) {
+ super(schemaNode, ContainerNode.class, treeType);
}
@Override
checkArgument(original instanceof ContainerNode);
return ImmutableContainerNodeBuilder.create((ContainerNode) original);
}
-}
\ No newline at end of file
+}
import com.google.common.base.Preconditions;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
* Current data store state generation.
*/
private volatile DataTreeState state;
+ private final TreeType treeType;
- public InMemoryDataTree(final TreeNode rootNode, final SchemaContext schemaContext) {
+ public InMemoryDataTree(final TreeNode rootNode, final TreeType treeType, final SchemaContext schemaContext) {
+ this.treeType = Preconditions.checkNotNull(treeType,treeType);
state = DataTreeState.createInitial(rootNode);
if (schemaContext != null) {
setSchemaContext(schemaContext);
LOG.debug("Following schema contexts will be attempted {}", newSchemaContext);
- final SchemaAwareApplyOperation operation = SchemaAwareApplyOperation.from(newSchemaContext);
+ final SchemaAwareApplyOperation operation = SchemaAwareApplyOperation.from(newSchemaContext,treeType);
DataTreeState currentState, newState;
do {
if (candidate instanceof NoopDataTreeCandidate) {
return;
}
-
Preconditions.checkArgument(candidate instanceof InMemoryDataTreeCandidate, "Invalid candidate class %s", candidate.getClass());
final InMemoryDataTreeCandidate c = (InMemoryDataTreeCandidate)candidate;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeFactory;
import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
@Override
public TipProducingDataTree create() {
- return new InMemoryDataTree(TreeNodeFactory.createTreeNode(root, Version.initial()), null);
+ return create(TreeType.OPERATIONAL);
+ }
+
+ @Override
+ public TipProducingDataTree create(TreeType treeType) {
+ return new InMemoryDataTree(TreeNodeFactory.createTreeNode(root, Version.initial()), treeType, null);
}
/**
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
final class LeafModificationStrategy extends AbstractValueNodeModificationStrategy<LeafSchemaNode> {
@SuppressWarnings({ "unchecked", "rawtypes" })
- LeafModificationStrategy(final LeafSchemaNode schema) {
+ LeafModificationStrategy(final LeafSchemaNode schema, final TreeType treeType) {
super(schema, (Class) LeafNode.class);
}
}
\ No newline at end of file
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
final class ListEntryModificationStrategy extends AbstractDataNodeContainerModificationStrategy<ListSchemaNode> {
- ListEntryModificationStrategy(final ListSchemaNode schema) {
- super(schema, MapEntryNode.class);
+ ListEntryModificationStrategy(final ListSchemaNode schema, final TreeType treeType) {
+ super(schema, MapEntryNode.class, treeType);
}
@Override
}
@Override
- void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
+ protected void verifyStructure(final NormalizedNode<?, ?> modification) {
delegate.verifyStructure(modification);
}
return delegate.applyWrite(modification, currentMeta, version);
}
- @Override
- protected void verifyWrittenStructure(final NormalizedNode<?, ?> writtenValue) {
- delegate.verifyWrittenStructure(writtenValue);
- }
-
@Override
protected ChildTrackingPolicy getChildPolicy() {
return delegate.getChildPolicy();
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
* @param modification to be verified.
* @throws IllegalArgumentException If provided NodeModification does not adhere to the structure.
*/
- abstract void verifyStructure(ModifiedNode modification) throws IllegalArgumentException;
+ abstract void verifyStructure(NormalizedNode<?, ?> modification) throws IllegalArgumentException;
/**
* Return the tracking policy for this node's children.
void write(final NormalizedNode<?, ?> value) {
modification.write(value);
- applyOperation.verifyStructure(modification);
+ applyOperation.verifyStructure(value);
}
private void recursiveMerge(final NormalizedNode<?,?> data) {
if (data instanceof NormalizedNodeContainer<?,?,?>) {
@SuppressWarnings({ "rawtypes", "unchecked" })
+ final
NormalizedNodeContainer<?,?,NormalizedNode<PathArgument, ?>> dataContainer = (NormalizedNodeContainer) data;
/*
*/
if (modification.getOperation().equals(LogicalOperation.WRITE)) {
@SuppressWarnings({ "rawtypes", "unchecked" })
+ final
NormalizedNodeContainer<?,?,NormalizedNode<PathArgument, ?>> odlDataContainer =
(NormalizedNodeContainer) modification.getWrittenValue();
- for (NormalizedNode<PathArgument, ?> child : odlDataContainer.getValue()) {
- PathArgument childId = child.getIdentifier();
+ for (
final NormalizedNode<PathArgument, ?> child : odlDataContainer.getValue()) {
+ final PathArgument childId = child.getIdentifier();
forChild(childId).write(child);
}
}
- for (NormalizedNode<PathArgument, ?> child : dataContainer.getValue()) {
- PathArgument childId = child.getIdentifier();
+ for (
final NormalizedNode<PathArgument, ?> child : dataContainer.getValue()) {
+ final PathArgument childId = child.getIdentifier();
forChild(childId).recursiveMerge(child);
}
}
* assumption that adding the newly-validated data with the previously-validated
* data will not result in invalid data.
*/
- applyOperation.verifyStructure(modification.asNewlyWritten(data));
+ applyOperation.verifyStructure(data);
recursiveMerge(data);
}
final Optional<ModificationApplyOperation> maybeChildOp = applyOperation.getChild(childId);
Preconditions.checkArgument(maybeChildOp.isPresent(), "Attempted to apply operation to non-existent child %s", childId);
- ModificationApplyOperation childOp = maybeChildOp.get();
- ModifiedNode childMod = modification.modifyChild(childId, childOp.getChildPolicy());
+ final ModificationApplyOperation childOp = maybeChildOp.get();
+ final ModifiedNode childMod = modification.modifyChild(childId, childOp.getChildPolicy());
return from(childOp, childMod);
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedLeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
private final Optional<ModificationApplyOperation> entryStrategy;
@SuppressWarnings({ "unchecked", "rawtypes" })
- OrderedLeafSetModificationStrategy(final LeafListSchemaNode schema) {
+ OrderedLeafSetModificationStrategy(final LeafListSchemaNode schema, final TreeType treeType) {
super((Class) LeafSetNode.class);
entryStrategy = Optional.<ModificationApplyOperation> of(new LeafSetEntryModificationStrategy(schema));
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
final class OrderedMapModificationStrategy extends AbstractNodeContainerModificationStrategy {
private final Optional<ModificationApplyOperation> entryStrategy;
- OrderedMapModificationStrategy(final ListSchemaNode schema) {
+ OrderedMapModificationStrategy(final ListSchemaNode schema, final TreeType treeType) {
super(OrderedMapNode.class);
- entryStrategy = Optional.<ModificationApplyOperation> of(new ListEntryModificationStrategy(schema));
+ entryStrategy = Optional.<ModificationApplyOperation> of(new ListEntryModificationStrategy(schema, treeType));
}
@Override
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
}
@Override
- final void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
+ final void verifyStructure(final NormalizedNode<?, ?> modification) throws IllegalArgumentException {
getDelegate().verifyStructure(modification);
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.IncorrectDataStructureException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
abstract class SchemaAwareApplyOperation extends ModificationApplyOperation {
private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class);
- public static SchemaAwareApplyOperation from(final DataSchemaNode schemaNode) {
+ static SchemaAwareApplyOperation from(final SchemaContext schemaNode, final TreeType treeType) {
+ return new ContainerModificationStrategy(schemaNode, treeType);
+ }
+
+ public static SchemaAwareApplyOperation from(final DataSchemaNode schemaNode, final TreeType treeType) {
+ if(treeType == TreeType.CONFIGURATION) {
+ Preconditions.checkArgument(schemaNode.isConfiguration(), "Supplied %s does not belongs to configuration tree.", schemaNode.getPath());
+ }
if (schemaNode instanceof ContainerSchemaNode) {
- return new ContainerModificationStrategy((ContainerSchemaNode) schemaNode);
+ return new ContainerModificationStrategy((ContainerSchemaNode) schemaNode, treeType);
} else if (schemaNode instanceof ListSchemaNode) {
- return fromListSchemaNode((ListSchemaNode) schemaNode);
+ return fromListSchemaNode((ListSchemaNode) schemaNode, treeType);
} else if (schemaNode instanceof ChoiceSchemaNode) {
- return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode);
+ return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode, treeType);
} else if (schemaNode instanceof LeafListSchemaNode) {
- return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode);
+ return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode, treeType);
} else if (schemaNode instanceof LeafSchemaNode) {
- return new LeafModificationStrategy((LeafSchemaNode) schemaNode);
+ return new LeafModificationStrategy((LeafSchemaNode) schemaNode, treeType);
}
throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass());
}
public static SchemaAwareApplyOperation from(final DataNodeContainer resolvedTree,
- final AugmentationTarget augSchemas, final AugmentationIdentifier identifier) {
+ final AugmentationTarget augSchemas, final AugmentationIdentifier identifier, final TreeType treeType) {
for (final AugmentationSchema potential : augSchemas.getAvailableAugmentations()) {
for (final DataSchemaNode child : potential.getChildNodes()) {
if (identifier.getPossibleChildNames().contains(child.getQName())) {
- return new AugmentationModificationStrategy(potential, resolvedTree);
+ return new AugmentationModificationStrategy(potential, resolvedTree, treeType);
}
}
}
return condition;
}
- private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode) {
+ private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, final TreeType treeType) {
final List<QName> keyDefinition = schemaNode.getKeyDefinition();
final SchemaAwareApplyOperation op;
if (keyDefinition == null || keyDefinition.isEmpty()) {
- op = new UnkeyedListModificationStrategy(schemaNode);
+ op = new UnkeyedListModificationStrategy(schemaNode, treeType);
} else if (schemaNode.isUserOrdered()) {
- op = new OrderedMapModificationStrategy(schemaNode);
+ op = new OrderedMapModificationStrategy(schemaNode, treeType);
} else {
- op = new UnorderedMapModificationStrategy(schemaNode);
+ op = new UnorderedMapModificationStrategy(schemaNode, treeType);
}
return MinMaxElementsValidation.from(op, schemaNode);
}
- private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode) {
+ private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode, final TreeType treeType) {
final SchemaAwareApplyOperation op;
if(schemaNode.isUserOrdered()) {
- op = new OrderedLeafSetModificationStrategy(schemaNode);
+ op = new OrderedLeafSetModificationStrategy(schemaNode, treeType);
} else {
- op = new UnorderedLeafSetModificationStrategy(schemaNode);
+ op = new UnorderedLeafSetModificationStrategy(schemaNode, treeType);
}
return MinMaxElementsValidation.from(op, schemaNode);
}
return potential.get();
}
- @Override
- void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
- if (modification.getOperation() == LogicalOperation.WRITE) {
- verifyWrittenStructure(modification.getWrittenValue());
- }
- }
-
@Override
final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
switch (modification.getOperation()) {
protected abstract void checkTouchApplicable(YangInstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws DataValidationFailedException;
- protected abstract void verifyWrittenStructure(NormalizedNode<?, ?> writtenValue);
+ /**
+ * Checks if supplied schema node belong to specified Data Tree type.
+ *
+ * @param treeType Tree Type
+ * @param node Schema node
+ * @return
+ */
+ static boolean belongsToTree(final TreeType treeType, final DataSchemaNode node) {
+ if(treeType == TreeType.CONFIGURATION) {
+ return node.isConfiguration();
+ }
+ return true;
+ }
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListEntryNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
final class UnkeyedListItemModificationStrategy extends AbstractDataNodeContainerModificationStrategy<ListSchemaNode> {
- UnkeyedListItemModificationStrategy(final ListSchemaNode schemaNode) {
- super(schemaNode, UnkeyedListEntryNode.class);
+ UnkeyedListItemModificationStrategy(final ListSchemaNode schemaNode, final TreeType treeType) {
+ super(schemaNode, UnkeyedListEntryNode.class, treeType);
}
@Override
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.IncorrectDataStructureException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.MutableTreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory;
private final Optional<ModificationApplyOperation> entryStrategy;
- UnkeyedListModificationStrategy(final ListSchemaNode schema) {
- entryStrategy = Optional.<ModificationApplyOperation> of(new UnkeyedListItemModificationStrategy(schema));
+ UnkeyedListModificationStrategy(final ListSchemaNode schema, final TreeType treeType) {
+ entryStrategy = Optional.<ModificationApplyOperation> of(new UnkeyedListItemModificationStrategy(schema, treeType));
}
@Override
private TreeNode mutateChildren(final MutableTreeNode meta, final NormalizedNodeContainerBuilder data,
final Version nodeVersion, final Iterable<ModifiedNode> modifications) {
- for (ModifiedNode mod : modifications) {
+ for (final ModifiedNode mod : modifications) {
final PathArgument id = mod.getIdentifier();
final Optional<TreeNode> cm = meta.getChild(id);
- Optional<TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
+ final Optional<TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
if (result.isPresent()) {
final TreeNode tn = result.get();
meta.addChild(tn);
}
@Override
- protected void verifyWrittenStructure(final NormalizedNode<?, ?> writtenValue) {
+ protected void verifyStructure(final NormalizedNode<?, ?> writtenValue) {
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
private final Optional<ModificationApplyOperation> entryStrategy;
@SuppressWarnings({ "unchecked", "rawtypes" })
- UnorderedLeafSetModificationStrategy(final LeafListSchemaNode schema) {
+ UnorderedLeafSetModificationStrategy(final LeafListSchemaNode schema, final TreeType treeType) {
super((Class) LeafSetNode.class);
entryStrategy = Optional.<ModificationApplyOperation> of(new LeafSetEntryModificationStrategy(schema));
}
/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
+ * This program and the accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
final class UnorderedMapModificationStrategy extends AbstractNodeContainerModificationStrategy {
private final Optional<ModificationApplyOperation> entryStrategy;
- UnorderedMapModificationStrategy(final ListSchemaNode schema) {
+ UnorderedMapModificationStrategy(final ListSchemaNode schema, final TreeType treeType) {
super(MapNode.class);
- entryStrategy = Optional.<ModificationApplyOperation> of(new ListEntryModificationStrategy(schema));
+ entryStrategy = Optional.<ModificationApplyOperation>of(new ListEntryModificationStrategy(schema, treeType));
}
@SuppressWarnings("rawtypes")
public String toString() {
return "UnorderedMapModificationStrategy [entry=" + entryStrategy + "]";
}
-}
\ No newline at end of file
+}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+
import com.google.common.base.Optional;
import java.io.InputStream;
import java.util.Collections;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.Module;
public void prepare() {
schemaContext = createTestContext();
assertNotNull("Schema context must not be null.", schemaContext);
- rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext));
+ rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext, TreeType.OPERATIONAL));
inMemoryDataTree = (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create();
inMemoryDataTree.setSchemaContext(schemaContext);
}
import static org.junit.Assert.fail;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
+
import com.google.common.base.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public void prepare() {
schemaContext = TestModel.createTestContext();
assertNotNull("Schema context must not be null.", schemaContext);
- rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext));
+ rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext,TreeType.OPERATIONAL));
inMemoryDataTree = (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create();
inMemoryDataTree.setSchemaContext(schemaContext);
}
@Test
public void writeWrite1stLevelEmptyTreeTest() throws DataValidationFailedException {
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
modificationTree2.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
fail("Exception should have been thrown.");
- } catch (ConflictingModificationAppliedException ex) {
+ } catch (final ConflictingModificationAppliedException ex) {
LOG.debug("ConflictingModificationAppliedException - '{}' was thrown as expected.");
}
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- Optional<NormalizedNode<?, ?>> testNodeAfterCommits = modificationTree1.readNode(TestModel.TEST_PATH);
+ final Optional<NormalizedNode<?, ?>> testNodeAfterCommits = modificationTree1.readNode(TestModel.TEST_PATH);
assertPresentAndType(testNodeAfterCommits, ContainerNode.class);
}
@Test
public void writeMerge1stLevelEmptyTreeTest() throws DataValidationFailedException {
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
modificationTree2.merge(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- Optional<NormalizedNode<?, ?>> testNodeAfterCommits = modificationTree1.readNode(TestModel.TEST_PATH);
+ final Optional<NormalizedNode<?, ?>> testNodeAfterCommits = modificationTree1.readNode(TestModel.TEST_PATH);
assertPresentAndType(testNodeAfterCommits, ContainerNode.class);
}
@Test
public void writeWriteFooBar1stLevelEmptyTreeTest() throws DataValidationFailedException {
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.write(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
fail("Exception should have been thrown.");
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- } catch (ConflictingModificationAppliedException ex) {
+ } catch (final ConflictingModificationAppliedException ex) {
LOG.debug("ConflictingModificationAppliedException - '{}' was thrown as expected.");
}
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertFalse(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH).isPresent());
}
@Test
public void writeMergeFooBar1stLevelEmptyTreeTest() throws DataValidationFailedException {
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.merge(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void mergeWriteFooBar1stLevelEmptyTreeTest() throws DataValidationFailedException {
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.merge(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.write(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
fail("Exception should have been thrown.");
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- } catch (ConflictingModificationAppliedException ex) {
+ } catch (final ConflictingModificationAppliedException ex) {
LOG.debug("ConflictingModificationAppliedException - '{}' was thrown as expected.");
}
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertFalse(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH).isPresent());
}
@Test
public void mergeMergeFooBar1stLevelEmptyTreeTest() throws DataValidationFailedException {
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.merge(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.merge(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void writeWriteFooBar1stLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.write(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
fail("Exception should have been thrown.");
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- } catch (ConflictingModificationAppliedException ex) {
+ } catch (final ConflictingModificationAppliedException ex) {
LOG.debug("ConflictingModificationAppliedException - '{}' was thrown as expected.");
}
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertFalse(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH).isPresent());
}
@Test
public void writeMergeFooBar1stLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.merge(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void mergeWriteFooBar1stLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.merge(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.write(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
fail("Exception should have been thrown.");
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- } catch (ConflictingModificationAppliedException ex) {
+ } catch (final ConflictingModificationAppliedException ex) {
LOG.debug("ConflictingModificationAppliedException - '{}' was thrown as expected.");
}
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertFalse(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH).isPresent());
}
@Test
public void mergeMergeFooBar1stLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.merge(TestModel.TEST_PATH, createFooTestContainerNode());
modificationTree2.merge(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void deleteWriteFooBar1stLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.delete(TestModel.TEST_PATH);
modificationTree2.write(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
fail("Exception should have been thrown.");
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- } catch (ConflictingModificationAppliedException ex) {
+ } catch (final ConflictingModificationAppliedException ex) {
LOG.debug("ConflictingModificationAppliedException - '{}' was thrown as expected.");
}
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertFalse(snapshotAfterCommits.readNode(TestModel.TEST_PATH).isPresent());
}
@Test
public void deleteMergeFooBar1stLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.delete(TestModel.TEST_PATH);
modificationTree2.merge(TestModel.TEST_PATH, createBarTestContainerNode());
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void writeWriteFooBar2ndLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
initialDataTreeModification.write(TestModel.OUTER_LIST_PATH, mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build());
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(OUTER_LIST_1_PATH, FOO_NODE);
modificationTree2.write(OUTER_LIST_2_PATH, BAR_NODE);
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void writeMergeFooBar2ndLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
initialDataTreeModification.write(TestModel.OUTER_LIST_PATH, mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build());
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.write(OUTER_LIST_1_PATH, FOO_NODE);
modificationTree2.merge(OUTER_LIST_2_PATH, BAR_NODE);
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void mergeWriteFooBar2ndLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
initialDataTreeModification.write(TestModel.OUTER_LIST_PATH, mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build());
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.merge(OUTER_LIST_1_PATH, FOO_NODE);
modificationTree2.write(OUTER_LIST_2_PATH, BAR_NODE);
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void mergeMergeFooBar2ndLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
initialDataTreeModification.write(TestModel.OUTER_LIST_PATH, mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build());
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.merge(OUTER_LIST_1_PATH, FOO_NODE);
modificationTree2.merge(OUTER_LIST_2_PATH, BAR_NODE);
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_1_PATH), MapEntryNode.class);
assertPresentAndType(snapshotAfterCommits.readNode(OUTER_LIST_2_PATH), MapEntryNode.class);
}
@Test
public void deleteWriteFooBar2ndLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
initialDataTreeModification.write(TestModel.OUTER_LIST_PATH, mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build());
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.delete(TestModel.TEST_PATH);
modificationTree2.merge(OUTER_LIST_2_PATH, BAR_NODE);
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
fail("Exception should have been thrown");
- } catch (Exception e) {
+ } catch (final Exception e) {
LOG.debug("Exception was thrown because path no longer exist in tree");
}
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertFalse(snapshotAfterCommits.readNode(TestModel.TEST_PATH).isPresent());
}
@Test
public void deleteMergeFooBar2ndLevelEmptyContainerTest() throws DataValidationFailedException {
- DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
+ final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
initialDataTreeModification.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
initialDataTreeModification.write(TestModel.OUTER_LIST_PATH, mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build());
inMemoryDataTree.commit(inMemoryDataTree.prepare(initialDataTreeModification));
- InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
- DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree1 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
- DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
+ final DataTreeModification modificationTree2 = new InMemoryDataTreeModification(initialDataTreeSnapshot,
rootOper);
modificationTree1.delete(TestModel.TEST_PATH);
modificationTree2.merge(OUTER_LIST_2_PATH, BAR_NODE);
inMemoryDataTree.validate(modificationTree1);
- DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
+ final DataTreeCandidate prepare1 = inMemoryDataTree.prepare(modificationTree1);
inMemoryDataTree.commit(prepare1);
try {
inMemoryDataTree.validate(modificationTree2);
- DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
+ final DataTreeCandidate prepare2 = inMemoryDataTree.prepare(modificationTree2);
inMemoryDataTree.commit(prepare2);
fail("Exception should have been thrown");
- } catch (Exception e) {
+ } catch (final Exception e) {
LOG.debug("Exception was thrown because path no longer exist in tree");
}
- InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
+ final InMemoryDataTreeSnapshot snapshotAfterCommits = inMemoryDataTree.takeSnapshot();
assertFalse(snapshotAfterCommits.readNode(TestModel.TEST_PATH).isPresent());
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.schema.tree;
+
+import static org.junit.Assert.assertNotNull;
+import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
+import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
+import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
+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.impl.ImmutableContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+// TODO: expand these tests to catch some more obscure cases
+public class ConfigStatementValidationTest {
+ private static final Logger LOG = LoggerFactory.getLogger(ConfigStatementValidationTest.class);
+
+ private static final Short ONE_ID = 1;
+ private static final Short TWO_ID = 2;
+
+ private static final YangInstanceIdentifier OUTER_LIST_1_PATH = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ .nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, ONE_ID) //
+ .build();
+
+ private static final YangInstanceIdentifier OUTER_LIST_2_PATH = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ .nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, TWO_ID) //
+ .build();
+
+ private static final MapEntryNode INNER_FOO_ENTRY_NODE =
+ ImmutableNodes.mapEntry(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "foo");
+
+ private static final MapEntryNode INNER_BAR_ENTRY_NODE =
+ ImmutableNodes.mapEntryBuilder(QName.create(TestModel.TEST_QNAME, "inner-list2"), TestModel.NAME_QNAME, "foo")
+ .withChild(ImmutableNodes.leafNode(TestModel.VALUE_QNAME, "value")).build();
+
+ private static final MapEntryNode FOO_NODE = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, ONE_ID) //
+ .withChild(mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(INNER_FOO_ENTRY_NODE) //
+ .build()) //
+ .build();
+
+ private static final MapEntryNode BAR_NODE = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, TWO_ID) //
+ .withChild(mapNodeBuilder(TestModel.INNER_LIST_QNAME).withChild(INNER_BAR_ENTRY_NODE) //
+ .build()) //
+ .build();
+
+ private SchemaContext schemaContext;
+
+ private ContainerNode createFooTestContainerNode() {
+ return ImmutableContainerNodeBuilder
+ .create()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(
+ mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(FOO_NODE).build()).build();
+ }
+
+ private ContainerNode createBarTestContainerNode() {
+ return ImmutableContainerNodeBuilder
+ .create()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(
+ mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(BAR_NODE).build()).build();
+ }
+
+ @Before
+ public void prepare() {
+ schemaContext = TestModel.createTestContext();
+ assertNotNull("Schema context must not be null.", schemaContext);
+ }
+
+ @Test(expected=SchemaValidationFailedException.class)
+ public void testOnPathFail() throws DataValidationFailedException {
+ final InMemoryDataTree inMemoryDataTree =
+ (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
+ inMemoryDataTree.setSchemaContext(schemaContext);
+ final InMemoryDataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
+ final YangInstanceIdentifier ii = OUTER_LIST_1_PATH.node(new YangInstanceIdentifier.NodeIdentifier(TestModel.INNER_LIST_QNAME))
+ .node(INNER_FOO_ENTRY_NODE.getIdentifier());
+ modificationTree.write(ii, INNER_FOO_ENTRY_NODE);
+
+ inMemoryDataTree.validate(modificationTree);
+ final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
+ inMemoryDataTree.commit(prepare);
+ }
+
+ @Test(expected=SchemaValidationFailedException.class)
+ public void testOnDataFail() throws DataValidationFailedException {
+ final InMemoryDataTree inMemoryDataTree =
+ (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
+ inMemoryDataTree.setSchemaContext(schemaContext);
+ final InMemoryDataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
+ modificationTree.write(TestModel.TEST_PATH, createFooTestContainerNode());
+
+ inMemoryDataTree.validate(modificationTree);
+ final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
+ inMemoryDataTree.commit(prepare);
+ }
+
+ @Test(expected=SchemaValidationFailedException.class)
+ public void testOnDataLeafFail() throws DataValidationFailedException {
+ final InMemoryDataTree inMemoryDataTree =
+ (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
+ inMemoryDataTree.setSchemaContext(schemaContext);
+ final InMemoryDataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
+ modificationTree.write(TestModel.TEST_PATH, createBarTestContainerNode());
+
+ inMemoryDataTree.validate(modificationTree);
+ final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
+ inMemoryDataTree.commit(prepare);
+ }
+
+ @Test(expected=SchemaValidationFailedException.class)
+ public void testOnPathCaseLeafFail() throws DataValidationFailedException {
+ final InMemoryDataTree inMemoryDataTree =
+ (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
+ inMemoryDataTree.setSchemaContext(schemaContext);
+ final YangInstanceIdentifier.NodeIdentifier choice1Id = new YangInstanceIdentifier.NodeIdentifier(
+ QName.create(TestModel.TEST_QNAME, "choice1"));
+ final YangInstanceIdentifier.NodeIdentifier case2ContId = new YangInstanceIdentifier.NodeIdentifier(
+ QName.create(TestModel.TEST_QNAME, "case2-cont"));
+ final YangInstanceIdentifier ii = TestModel.TEST_PATH.node(choice1Id).node(case2ContId);
+ final ContainerNode case2Cont = Builders.containerBuilder().withNodeIdentifier(case2ContId)
+ .withChild(leafNode(QName.create(TestModel.TEST_QNAME, "case2-leaf1"), "leaf-value")).build();
+
+ final InMemoryDataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
+ modificationTree.write(ii, case2Cont);
+
+ inMemoryDataTree.validate(modificationTree);
+ final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
+ inMemoryDataTree.commit(prepare);
+ }
+
+ @Test(expected=SchemaValidationFailedException.class)
+ public void testOnDataCaseLeafFail() throws DataValidationFailedException {
+ final InMemoryDataTree inMemoryDataTree =
+ (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
+ inMemoryDataTree.setSchemaContext(schemaContext);
+ final YangInstanceIdentifier.NodeIdentifier choice1Id = new YangInstanceIdentifier.NodeIdentifier(
+ QName.create(TestModel.TEST_QNAME, "choice1"));
+ final YangInstanceIdentifier ii = TestModel.TEST_PATH.node(choice1Id);
+ final ChoiceNode choice1 = Builders.choiceBuilder().withNodeIdentifier(choice1Id)
+ .withChild(leafNode(QName.create(TestModel.TEST_QNAME, "case1-leaf1"), "leaf-value")).build();
+
+ final InMemoryDataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
+ modificationTree.write(ii, choice1);
+
+ inMemoryDataTree.validate(modificationTree);
+ final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
+ inMemoryDataTree.commit(prepare);
+ }
+}
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
public void prepare() {
schemaContext = createTestContext();
assertNotNull("Schema context must not be null.", schemaContext);
- rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext));
+ rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext, TreeType.OPERATIONAL));
inMemoryDataTree = (InMemoryDataTree) InMemoryDataTreeFactory.getInstance().create();
inMemoryDataTree.setSchemaContext(schemaContext);
final InMemoryDataTreeSnapshot initialDataTreeSnapshot = inMemoryDataTree.takeSnapshot();
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
+import com.google.common.base.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import com.google.common.base.Optional;
-
public void prepare() {
schemaContext = TestModel.createTestContext();
assertNotNull("Schema context must not be null.", schemaContext);
- rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext));
+ rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext, TreeType.OPERATIONAL));
}
/**
@Test
public void basicReadWrites() {
- DataTreeModification modificationTree = new InMemoryDataTreeModification(new InMemoryDataTreeSnapshot(schemaContext,
+ final DataTreeModification modificationTree = new InMemoryDataTreeModification(new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper),
rootOper);
- Optional<NormalizedNode<?, ?>> originalBarNode = modificationTree.readNode(OUTER_LIST_2_PATH);
+ final Optional<NormalizedNode<?, ?>> originalBarNode = modificationTree.readNode(OUTER_LIST_2_PATH);
assertTrue(originalBarNode.isPresent());
assertSame(BAR_NODE, originalBarNode.get());
// reads node to /outer-list/1/inner_list/two/value
// and checks if node is already present
- Optional<NormalizedNode<?, ?>> barTwoCModified = modificationTree.readNode(TWO_TWO_VALUE_PATH);
+ final Optional<NormalizedNode<?, ?>> barTwoCModified = modificationTree.readNode(TWO_TWO_VALUE_PATH);
assertTrue(barTwoCModified.isPresent());
assertEquals(ImmutableNodes.leafNode(TestModel.VALUE_QNAME, "test"), barTwoCModified.get());
// delete node to /outer-list/1/inner_list/two/value
modificationTree.delete(TWO_TWO_VALUE_PATH);
- Optional<NormalizedNode<?, ?>> barTwoCAfterDelete = modificationTree.readNode(TWO_TWO_VALUE_PATH);
+ final Optional<NormalizedNode<?, ?>> barTwoCAfterDelete = modificationTree.readNode(TWO_TWO_VALUE_PATH);
assertFalse(barTwoCAfterDelete.isPresent());
}
/**
* Creates empty Snapshot with associated schema context.
*/
- DataTree t = InMemoryDataTreeFactory.getInstance().create();
+ final DataTree t = InMemoryDataTreeFactory.getInstance().create();
t.setSchemaContext(schemaContext);
/**
@Test
public void createFromEmptyState() {
- DataTreeModification modificationTree = createEmptyModificationTree();
+ final DataTreeModification modificationTree = createEmptyModificationTree();
/**
* Writes empty container node to /test
*
/**
* Reads list node from /test/outer-list
*/
- Optional<NormalizedNode<?, ?>> potentialOuterList = modificationTree.readNode(TestModel.OUTER_LIST_PATH);
+ final Optional<NormalizedNode<?, ?>> potentialOuterList = modificationTree.readNode(TestModel.OUTER_LIST_PATH);
assertTrue(potentialOuterList.isPresent());
/**
* Reads container node from /test and verifies that it contains test
* node
*/
- Optional<NormalizedNode<?, ?>> potentialTest = modificationTree.readNode(TestModel.TEST_PATH);
- ContainerNode containerTest = assertPresentAndType(potentialTest, ContainerNode.class);
+ final Optional<NormalizedNode<?, ?>> potentialTest = modificationTree.readNode(TestModel.TEST_PATH);
+ final ContainerNode containerTest = assertPresentAndType(potentialTest, ContainerNode.class);
/**
*
@Test
public void writeSubtreeReadChildren() {
- DataTreeModification modificationTree = createEmptyModificationTree();
+ final DataTreeModification modificationTree = createEmptyModificationTree();
modificationTree.write(TestModel.TEST_PATH, createTestContainer());
- Optional<NormalizedNode<?, ?>> potential = modificationTree.readNode(TWO_TWO_PATH);
+ final Optional<NormalizedNode<?, ?>> potential = modificationTree.readNode(TWO_TWO_PATH);
assertPresentAndType(potential, MapEntryNode.class);
}
@Test
public void writeSubtreeDeleteChildren() {
- DataTreeModification modificationTree = createEmptyModificationTree();
+ final DataTreeModification modificationTree = createEmptyModificationTree();
modificationTree.write(TestModel.TEST_PATH, createTestContainer());
// We verify data are present
- Optional<NormalizedNode<?, ?>> potentialBeforeDelete = modificationTree.readNode(TWO_TWO_PATH);
+ final Optional<NormalizedNode<?, ?>> potentialBeforeDelete = modificationTree.readNode(TWO_TWO_PATH);
assertPresentAndType(potentialBeforeDelete, MapEntryNode.class);
modificationTree.delete(TWO_TWO_PATH);
- Optional<NormalizedNode<?, ?>> potentialAfterDelete = modificationTree.readNode(TWO_TWO_PATH);
+ final Optional<NormalizedNode<?, ?>> potentialAfterDelete = modificationTree.readNode(TWO_TWO_PATH);
assertFalse(potentialAfterDelete.isPresent());
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-
-
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-
-public class SchemaAwareApplyOperationRoot extends AbstractDataNodeContainerModificationStrategy<ContainerSchemaNode> {
- private final SchemaContext context;
-
- public SchemaAwareApplyOperationRoot(final SchemaContext context) {
- super(context,ContainerNode.class);
- this.context = context;
- }
-
- public SchemaContext getContext() {
- return context;
- }
-
- @Override
- public String toString() {
- return "SchemaAwareApplyOperationRoot [context=" + context + "]";
- }
-
- @Override
- @SuppressWarnings("rawtypes")
- protected DataContainerNodeBuilder createBuilder(NormalizedNode<?, ?> original) {
- return ImmutableContainerNodeBuilder.create((ContainerNode) original);
- }
-}
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
+
import com.google.common.base.Optional;
import java.util.Map;
import org.junit.Before;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNodes;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
public void prepare() {
schemaContext = TestModel.createTestContext();
assertNotNull("Schema context must not be null.", schemaContext);
- rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext));
+ rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext, TreeType.OPERATIONAL));
}
public NormalizedNode<?, ?> createDocumentOne() {
@Test
public void findNodeTestNodeFound() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- Optional<TreeNode> node = StoreTreeNodes.findNode(rootNode, OUTER_LIST_1_PATH);
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final Optional<TreeNode> node = StoreTreeNodes.findNode(rootNode, OUTER_LIST_1_PATH);
assertPresentAndType(node, TreeNode.class);
}
@Test
public void findNodeTestNodeNotFound() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
final YangInstanceIdentifier outerList1InvalidPath = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 3) //
.build();
- Optional<TreeNode> node = StoreTreeNodes.findNode(rootNode, outerList1InvalidPath);
+ final Optional<TreeNode> node = StoreTreeNodes.findNode(rootNode, outerList1InvalidPath);
assertFalse(node.isPresent());
}
@Test
public void findNodeCheckedTestNodeFound() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
TreeNode foundNode = null;
try {
foundNode = StoreTreeNodes.findNodeChecked(rootNode, OUTER_LIST_1_PATH);
- } catch (IllegalArgumentException e) {
+ } catch (final IllegalArgumentException e) {
fail("Illegal argument exception was thrown and should not have been" + e.getMessage());
}
assertNotNull(foundNode);
@Test
public void findNodeCheckedTestNodeNotFound() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
final YangInstanceIdentifier outerList1InvalidPath = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 3) //
.build();
try {
StoreTreeNodes.findNodeChecked(rootNode, outerList1InvalidPath);
fail("Illegal argument exception should have been thrown");
- } catch (IllegalArgumentException e) {
+ } catch (final IllegalArgumentException e) {
LOG.debug("Illegal argument exception was thrown as expected: '{}' - '{}'", e.getClass(), e.getMessage());
}
}
@Test
public void findClosestOrFirstMatchTestNodeExists() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- Optional<TreeNode> expectedNode = StoreTreeNodes.findNode(rootNode, TWO_TWO_PATH);
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final Optional<TreeNode> expectedNode = StoreTreeNodes.findNode(rootNode, TWO_TWO_PATH);
assertPresentAndType(expectedNode, TreeNode.class);
- Map.Entry<YangInstanceIdentifier, TreeNode> actualNode = StoreTreeNodes.findClosest(rootNode, TWO_TWO_PATH);
+ final Map.Entry<YangInstanceIdentifier, TreeNode> actualNode = StoreTreeNodes.findClosest(rootNode, TWO_TWO_PATH);
assertEquals("Expected node and actual node are not the same", expectedNode.get(), actualNode.getValue());
}
@Test
public void findClosestOrFirstMatchTestNodeDoesNotExist() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
final YangInstanceIdentifier outerListInnerListPath = YangInstanceIdentifier.builder(OUTER_LIST_2_PATH)
.node(TestModel.INNER_LIST_QNAME)
.build();
.node(TestModel.INNER_LIST_QNAME) //
.nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "three") //
.build();
- Optional<TreeNode> expectedNode = StoreTreeNodes.findNode(rootNode, outerListInnerListPath);
+ final Optional<TreeNode> expectedNode = StoreTreeNodes.findNode(rootNode, outerListInnerListPath);
assertPresentAndType(expectedNode, TreeNode.class);
- Map.Entry<YangInstanceIdentifier, TreeNode> actualNode = StoreTreeNodes.findClosest(rootNode, twoTwoInvalidPath);
+ final Map.Entry<YangInstanceIdentifier, TreeNode> actualNode = StoreTreeNodes.findClosest(rootNode, twoTwoInvalidPath);
assertEquals("Expected node and actual node are not the same", expectedNode.get(), actualNode.getValue());
}
@Test
public void getChildTestChildFound() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.fromNullable(rootNode),
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.fromNullable(rootNode),
TestModel.TEST_PATH.getLastPathArgument());
assertPresentAndType(node, TreeNode.class);
}
@Test
public void getChildTestChildNotFound() {
- InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ final InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
TreeNodeFactory.createTreeNodeRecursively(createDocumentOne(), Version.initial()), rootOper);
- TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
- Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.fromNullable(rootNode),
+ final TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final Optional<TreeNode> node = StoreTreeNodes.getChild(Optional.fromNullable(rootNode),
TestModel.OUTER_LIST_PATH.getLastPathArgument());
assertFalse(node.isPresent());
}
yang-version 1;
namespace "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test";
prefix "store-test";
-
+
revision "2014-03-13" {
description "Initial revision.";
}
container test {
+ choice choice1 {
+ case case1 {
+ leaf case1-leaf1 {
+ type string;
+ config false;
+ }
+ }
+ case case2 {
+ container case2-cont {
+ leaf case2-leaf1 {
+ type string;
+ config false;
+ }
+ }
+ }
+ }
+
list outer-list {
+
key id;
leaf id {
type uint16;
}
}
list inner-list {
+ config false;
key name;
leaf name {
type string;
type string;
}
}
+
+ list inner-list2 {
+ key name;
+ leaf name {
+ type string;
+ }
+ leaf value {
+ type string;
+ config false;
+ }
+ }
+ }
}
}
-}
\ No newline at end of file
+}
Code Review / yangtools.git / commitdiff