import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
import javassist.ClassPool;
import org.junit.Before;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
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.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder;
-public class NormalizedNodeSerializeDeserializeTest extends AbstractBindingRuntimeTest{
+public class NormalizedNodeSerializeDeserializeTest extends AbstractBindingRuntimeTest {
public static final String TOP_LEVEL_LIST_FOO_KEY_VALUE = "foo";
public static final TopLevelListKey TOP_LEVEL_LIST_FOO_KEY = new TopLevelListKey(TOP_LEVEL_LIST_FOO_KEY_VALUE);
public static final QName TOP_LEVEL_LIST_QNAME = QName.create(TOP_QNAME, "top-level-list");
public static final QName TOP_LEVEL_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
public static final QName TOP_LEVEL_LEAF_LIST_QNAME = QName.create(TOP_QNAME, "top-level-leaf-list");
- public static final QName TOP_LEVEL_ORDERED_LEAF_LIST_QNAME = QName.create(TOP_QNAME, "top-level-ordered-leaf-list");
+ public static final QName TOP_LEVEL_ORDERED_LEAF_LIST_QNAME = QName.create(TOP_QNAME,
+ "top-level-ordered-leaf-list");
public static final QName NESTED_LIST_QNAME = QName.create(TOP_QNAME, "nested-list");
public static final QName NESTED_LIST_KEY_QNAME = QName.create(TOP_QNAME, "name");
public static final QName CHOICE_CONTAINER_QNAME = ChoiceContainer.QNAME;
public static final YangInstanceIdentifier BI_TOP_PATH = YangInstanceIdentifier.of(TOP_QNAME);
public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_PATH = BI_TOP_PATH.node(TOP_LEVEL_LIST_QNAME);
public static final YangInstanceIdentifier BI_TOP_LEVEL_LIST_FOO_PATH = BI_TOP_LEVEL_LIST_PATH
- .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE));
- public static final YangInstanceIdentifier BI_CHOICE_CONTAINER_PATH = YangInstanceIdentifier.of(CHOICE_CONTAINER_QNAME);
+ .node(new YangInstanceIdentifier.NodeIdentifierWithPredicates(TOP_LEVEL_LIST_QNAME,
+ TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE));
+ public static final YangInstanceIdentifier BI_CHOICE_CONTAINER_PATH = YangInstanceIdentifier.of(
+ CHOICE_CONTAINER_QNAME);
private BindingNormalizedNodeCodecRegistry registry;
@Test
public void containerToNormalized() {
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry =
- registry.toNormalizedNode(InstanceIdentifier.create(Top.class), top());
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ InstanceIdentifier.create(Top.class), top());
final ContainerNode topNormalized = getEmptyTop();
assertEquals(topNormalized, entry.getValue());
}
@Test
public void containerFromNormalized() {
final ContainerNode topNormalized = getEmptyTop();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
assertEquals(top(), entry.getValue());
}
private static ContainerNode getEmptyTop() {
return ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
.withChild(mapNodeBuilder(TOP_LEVEL_LIST_QNAME).build()).build();
}
public void equalsWithAugment() {
final ContainerNode topNormalizedWithAugments = getNormalizedTopWithAugments(
augmentationBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
+ .withNodeIdentifier(new AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
.withChild(ImmutableNodes.leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE))
.build());
final ContainerNode topNormalized = getEmptyTop();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
- final Map.Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH, topNormalizedWithAugments);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
+ final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH,
+ topNormalizedWithAugments);
// Equals on other with no augmentation should be false
assertNotEquals(top(), entryWithAugments.getValue());
// Equals on self should be true
assertEquals(entryWithAugments.getValue(), entryWithAugments.getValue());
- final Top topWithAugmentsDiffValue = topWithAugments(Collections.<Class<? extends Augmentation<Top>>, Augmentation<Top>>
- singletonMap(Top1.class, new Top1Builder().setAugmentedString("differentValue").build()));
+ final Top topWithAugmentsDiffValue = topWithAugments(
+ Collections.<Class<? extends Augmentation<Top>>, Augmentation<Top>>singletonMap(Top1.class,
+ new Top1Builder().setAugmentedString("differentValue").build()));
assertNotEquals(topWithAugmentsDiffValue, entryWithAugments.getValue());
assertNotEquals(entryWithAugments.getValue(), topWithAugmentsDiffValue);
}
public void equalsWithMultipleAugments() {
final ContainerNode topNormalizedWithAugments = getNormalizedTopWithAugments(
augmentationBuilder()
- .withNodeIdentifier(
- new YangInstanceIdentifier.AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
+ .withNodeIdentifier(new AugmentationIdentifier(singleton(AGUMENT_STRING_Q)))
.withChild(ImmutableNodes.leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE))
.build(),
augmentationBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.AugmentationIdentifier(singleton(AUGMENT_INT_Q)))
+ .withNodeIdentifier(new AugmentationIdentifier(singleton(AUGMENT_INT_Q)))
.withChild(ImmutableNodes.leafNode(AUGMENT_INT_Q, AUGMENT_INT_VALUE))
.build());
- final Map.Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH, topNormalizedWithAugments);
+ final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = registry.fromNormalizedNode(BI_TOP_PATH,
+ topNormalizedWithAugments);
Map<Class<? extends Augmentation<Top>>, Augmentation<Top>> augments = Maps.newHashMap();
augments.put(Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build());
augments.put(Top2.class, new Top2Builder().setAugmentedInt(AUGMENT_INT_VALUE).build());
}
private static ContainerNode getNormalizedTopWithAugments(final AugmentationNode... augChild) {
- final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode>
- builder = ImmutableContainerNodeBuilder.create();
+ final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder =
+ ImmutableContainerNodeBuilder.create();
for (AugmentationNode augmentationNode : augChild) {
builder.withChild(augmentationNode);
}
- return builder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_QNAME))
+ return builder.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
.withChild(mapNodeBuilder(TOP_LEVEL_LIST_QNAME).build()).build();
}
- private static Top topWithAugments(final Map<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augments) {
+ private static Top topWithAugments(
+ final Map<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augments) {
final TopBuilder topBuilder = new TopBuilder();
- for (Map.Entry<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augment : augments.entrySet()) {
+ for (Entry<Class<? extends Augmentation<Top>>, ? extends Augmentation<Top>> augment : augments.entrySet()) {
topBuilder.addAugmentation(augment.getKey(), augment.getValue());
}
return topBuilder.setTopLevelList(Collections.<TopLevelList>emptyList()).build();
@Test
public void listWithKeysToNormalized() {
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry =
- registry.toNormalizedNode(BA_TOP_LEVEL_LIST, topLevelList(TOP_LEVEL_LIST_FOO_KEY));
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(BA_TOP_LEVEL_LIST,
+ topLevelList(TOP_LEVEL_LIST_FOO_KEY));
final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
- .withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
+ .withNodeIdentifier(new NodeIdentifierWithPredicates(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
+ TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.build();
assertEquals(topLevelListNormalized, entry.getValue());
@Test
public void listWithKeysFromNormalized() {
final MapEntryNode topLevelListNormalized = ImmutableMapEntryNodeBuilder.create()
- .withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifierWithPredicates(
- TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
+ .withNodeIdentifier(new NodeIdentifierWithPredicates(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
+ TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.build();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entry =
- registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH, topLevelListNormalized);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH,
+ topLevelListNormalized);
assertEquals(topLevelList(TOP_LEVEL_LIST_FOO_KEY), entry.getValue());
}
@Test
public void leafOnlyAugmentationToNormalized() {
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry =
- registry.toNormalizedNode(BA_TREE_LEAF_ONLY, new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build());
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(BA_TREE_LEAF_ONLY,
+ new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build());
final Set<QName> augmentationChildren = new HashSet<>();
augmentationChildren.add(SIMPLE_VALUE_QNAME);
final AugmentationNode augmentationNode = ImmutableAugmentationNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.AugmentationIdentifier(augmentationChildren))
+ .withNodeIdentifier(new AugmentationIdentifier(augmentationChildren))
.withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue"))
.build();
assertEquals(augmentationNode, entry.getValue());
final Set<QName> augmentationChildren = new HashSet<>();
augmentationChildren.add(SIMPLE_VALUE_QNAME);
final AugmentationNode augmentationNode = ImmutableAugmentationNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.AugmentationIdentifier(augmentationChildren))
+ .withNodeIdentifier(new AugmentationIdentifier(augmentationChildren))
.withChild(leafNode(SIMPLE_VALUE_QNAME, "simpleValue"))
.build();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH.node(
- new YangInstanceIdentifier.AugmentationIdentifier(augmentationChildren)), augmentationNode);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(
+ BI_TOP_LEVEL_LIST_FOO_PATH.node(new AugmentationIdentifier(augmentationChildren)),
+ augmentationNode);
assertEquals(new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build(), entry.getValue());
}
topLevelLeafList.add("foo");
Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
- Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry =
- registry.toNormalizedNode(InstanceIdentifier.create(Top.class), top);
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ InstanceIdentifier.create(Top.class), top);
ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
.withChild(ImmutableOrderedLeafSetNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
.withChild(
ImmutableLeafSetEntryNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo"))
+ .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME,
+ "foo"))
.withValue("foo")
.build())
.build())
topLevelLeafList.add("foo");
final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry =
- registry.toNormalizedNode(InstanceIdentifier.create(Top.class), top);
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ InstanceIdentifier.create(Top.class), top);
final ContainerNode containerNode = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
.withChild(ImmutableLeafSetNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_LEVEL_LEAF_LIST_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TOP_LEVEL_LEAF_LIST_QNAME))
.withChild(
ImmutableLeafSetEntryNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
+ .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
.withValue("foo")
.build())
.build())
@Test
public void leafListFromNormalized() {
final ContainerNode topWithLeafList = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_QNAME))
- .withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_LEVEL_LEAF_LIST_QNAME))
- .withChild(ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new YangInstanceIdentifier.NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo")).withValue("foo").build()).build())
+ .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
+ .withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
+ TOP_LEVEL_LEAF_LIST_QNAME))
+ .withChild(ImmutableLeafSetEntryNodeBuilder.create()
+ .withNodeIdentifier(new NodeWithValue<>(TOP_LEVEL_LEAF_LIST_QNAME, "foo"))
+ .withValue("foo").build()).build())
.build();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topWithLeafList);
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH,
+ topWithLeafList);
final List<String> topLevelLeafList = new ArrayList<>();
topLevelLeafList.add("foo");
final Top top = new TopBuilder().setTopLevelLeafList(topLevelLeafList).build();
@Test
public void orderedLeafListFromNormalized() {
ContainerNode topWithLeafList = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_QNAME))
- .withChild(ImmutableOrderedLeafSetNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier
- (TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
- .withChild(ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new YangInstanceIdentifier.NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo")).withValue("foo").build()).build())
+ .withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
+ .withChild(ImmutableOrderedLeafSetNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(
+ TOP_LEVEL_ORDERED_LEAF_LIST_QNAME))
+ .withChild(ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
+ new NodeWithValue<>(TOP_LEVEL_ORDERED_LEAF_LIST_QNAME, "foo")).withValue("foo").build())
+ .build())
.build();
- Map.Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topWithLeafList);
+ Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_PATH, topWithLeafList);
List<String> topLevelLeafList = new ArrayList<>();
topLevelLeafList.add("foo");
Top top = new TopBuilder().setTopLevelOrderedLeafList(topLevelLeafList).build();
@Test
public void choiceToNormalized() {
- final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder().setExtendedId(
- new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry =
- registry.toNormalizedNode(InstanceIdentifier.create(ChoiceContainer.class), choiceContainerBA);
+ final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
+ .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(
+ InstanceIdentifier.create(ChoiceContainer.class), choiceContainerBA);
final ContainerNode choiceContainer = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(CHOICE_CONTAINER_QNAME))
- .withChild(ImmutableChoiceNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
- .withChild(ImmutableContainerNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(EXTENDED_ID_QNAME))
- .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
+ .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
+ .withChild(ImmutableChoiceNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
+ .withChild(ImmutableContainerNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
+ .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
.build();
assertEquals(choiceContainer, entry.getValue());
}
final QName nestedContainerLeafOuterQname = QName.create(containerIdentifierQname4798,
"leaf-in-outer-container");
- final YangInstanceIdentifier yangInstanceIdentifierOuter = YangInstanceIdentifier.of(containerIdentifierQname4798);
+ final YangInstanceIdentifier yangInstanceIdentifierOuter = YangInstanceIdentifier.of(
+ containerIdentifierQname4798);
final ContainerNode containerNodeOuter = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerIdentifierQname4798))
+ .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
.withChild(ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(nestedContainerOuterQname))
+ .withNodeIdentifier(new NodeIdentifier(nestedContainerOuterQname))
.withChild(leafNode(nestedContainerLeafOuterQname, "bar"))
.build())
.build();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entryContainer = registry.fromNormalizedNode
- (yangInstanceIdentifierOuter, containerNodeOuter);
+ final Entry<InstanceIdentifier<?>, DataObject> entryContainer = registry.fromNormalizedNode(
+ yangInstanceIdentifierOuter, containerNodeOuter);
assertNotNull(entryContainer.getValue());
assertNotNull(entryContainer.getKey());
- final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates4798 = new YangInstanceIdentifier
- .NodeIdentifierWithPredicates(nestedListQname4798, nestedListKeyQname4798, "foo");
- final YangInstanceIdentifier yangInstanceIdentifier4798 = YangInstanceIdentifier.of(containerIdentifierQname4798)
+ final NodeIdentifierWithPredicates nodeIdentifierWithPredicates4798 =
+ new NodeIdentifierWithPredicates(nestedListQname4798, nestedListKeyQname4798, "foo");
+ final YangInstanceIdentifier yangInstanceIdentifier4798 = YangInstanceIdentifier.of(
+ containerIdentifierQname4798)
.node(choiceIdentifierQname4798)
.node(nestedListQname4798)
.node(nodeIdentifierWithPredicates4798);
- final YangInstanceIdentifier yangInstanceIdentifierValid = YangInstanceIdentifier.of(containerIdentifierQname4798)
+ final YangInstanceIdentifier yangInstanceIdentifierValid = YangInstanceIdentifier.of(
+ containerIdentifierQname4798)
.node(choiceIdentifierQname4798)
.node(nestedContainerValidQname)
.node(nestedListQname4798)
.node(nodeIdentifierWithPredicates4798);
final ContainerNode containerNodeValid = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerIdentifierQname4798))
+ .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
.withChild(ImmutableChoiceNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(choiceIdentifierQname4798))
+ .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
.withChild(ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(nestedContainerValidQname))
- .withChild(ImmutableMapNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier
- .NodeIdentifier(nestedListQname4798))
+ .withNodeIdentifier(new NodeIdentifier(nestedContainerValidQname))
+ .withChild(ImmutableMapNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
.withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
.withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
.build())
.build())
.build();
try {
- registry.fromNormalizedNode
- (yangInstanceIdentifierValid, containerNodeValid);
+ registry.fromNormalizedNode(yangInstanceIdentifierValid, containerNodeValid);
fail("Incorect YangInstanceIdentifier should fail");
} catch (IllegalStateException e) {
+ // Expected
}
final ContainerNode containerNode4798 = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(containerIdentifierQname4798))
+ .withNodeIdentifier(new NodeIdentifier(containerIdentifierQname4798))
.withChild(ImmutableChoiceNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(choiceIdentifierQname4798))
- .withChild(ImmutableMapNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier
- .NodeIdentifier(nestedListQname4798))
- .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
- .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
- .build())
+ .withNodeIdentifier(new NodeIdentifier(choiceIdentifierQname4798))
+ .withChild(ImmutableMapNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(nestedListQname4798))
+ .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "foo"))
+ .withChild(mapEntry(nestedListQname4798, nestedListKeyQname4798, "bar"))
+ .build())
.build())
.build();
try {
- registry.fromNormalizedNode
- (yangInstanceIdentifier4798, containerNode4798);
+ registry.fromNormalizedNode(yangInstanceIdentifier4798, containerNode4798);
fail("Incorect YangInstanceIdentifier should fail");
} catch (IllegalStateException e) {
+ // Expected
}
}
@Test
public void choiceFromNormalized() {
final ContainerNode choiceContainerBI = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(CHOICE_CONTAINER_QNAME))
- .withChild(ImmutableChoiceNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
- .withChild(ImmutableContainerNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(EXTENDED_ID_QNAME))
- .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
+ .withNodeIdentifier(new NodeIdentifier(CHOICE_CONTAINER_QNAME))
+ .withChild(ImmutableChoiceNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(CHOICE_IDENTIFIER_QNAME))
+ .withChild(ImmutableContainerNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(EXTENDED_ID_QNAME))
+ .withChild(leafNode(CHOICE_IDENTIFIER_ID_QNAME, "identifier_value")).build()).build())
.build();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_CHOICE_CONTAINER_PATH, choiceContainerBI);
- final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder().setExtendedId(
- new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_CHOICE_CONTAINER_PATH,
+ choiceContainerBI);
+ final ChoiceContainer choiceContainerBA = new ChoiceContainerBuilder().setIdentifier(new ExtendedBuilder()
+ .setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build()).build()).build();
assertEquals(choiceContainerBA, entry.getValue());
}
final List<NestedList> nestedLists = new ArrayList<>();
nestedLists.add(new NestedListBuilder().setKey(new NestedListKey("foo")).build());
nestedLists.add(new NestedListBuilder().setKey(new NestedListKey("bar")).build());
- final TopLevelList topLevelList = new TopLevelListBuilder().setKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(nestedLists).build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(ii, topLevelList);
- final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+ final TopLevelList topLevelList = new TopLevelListBuilder().setKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
+ nestedLists).build();
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> entry = registry.toNormalizedNode(ii, topLevelList);
+ final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(new NodeIdentifierWithPredicates(
TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
- .withChild(
- ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(NESTED_LIST_QNAME))
- .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
- .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
+ .withChild(ImmutableOrderedMapNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
+ .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
+ .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
assertEquals(foo, entry.getValue());
}
@Test
public void orderedLisFromNormalized() {
- final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifierWithPredicates(
+ final MapEntryNode foo = mapEntryBuilder().withNodeIdentifier(new NodeIdentifierWithPredicates(
TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
.withChild(leafNode(TOP_LEVEL_LIST_KEY_QNAME, TOP_LEVEL_LIST_FOO_KEY_VALUE))
- .withChild(
- ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(NESTED_LIST_QNAME))
- .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
- .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
- final Map.Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH, foo);
+ .withChild(ImmutableOrderedMapNodeBuilder.create()
+ .withNodeIdentifier(new NodeIdentifier(NESTED_LIST_QNAME))
+ .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "foo"))
+ .withChild(mapEntry(NESTED_LIST_QNAME, NESTED_LIST_KEY_QNAME, "bar")).build()).build();
+ final Entry<InstanceIdentifier<?>, DataObject> entry = registry.fromNormalizedNode(BI_TOP_LEVEL_LIST_FOO_PATH,
+ foo);
final List<NestedList> nestedLists = new ArrayList<>();
nestedLists.add(new NestedListBuilder().setKey(new NestedListKey("foo")).build());
nestedLists.add(new NestedListBuilder().setKey(new NestedListKey("bar")).build());
- final TopLevelList topLevelList = new TopLevelListBuilder().setKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(nestedLists).build();
+ final TopLevelList topLevelList = new TopLevelListBuilder().setKey(TOP_LEVEL_LIST_FOO_KEY).setNestedList(
+ nestedLists).build();
assertEquals(topLevelList, entry.getValue());
}
final QName containerQName = QName.create(augmentChoice1QName, "case11-choice-case-container");
final QName leafQName = QName.create(augmentChoice1QName, "case11-choice-case-leaf");
- final YangInstanceIdentifier.AugmentationIdentifier aug1Id =
- new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(augmentChoice1QName));
- final YangInstanceIdentifier.AugmentationIdentifier aug2Id =
- new YangInstanceIdentifier.AugmentationIdentifier(Sets.newHashSet(augmentChoice2QName));
- final YangInstanceIdentifier.NodeIdentifier augmentChoice1Id =
- new YangInstanceIdentifier.NodeIdentifier(augmentChoice1QName);
- final YangInstanceIdentifier.NodeIdentifier augmentChoice2Id =
- new YangInstanceIdentifier.NodeIdentifier(augmentChoice2QName);
- final YangInstanceIdentifier.NodeIdentifier containerId =
- new YangInstanceIdentifier.NodeIdentifier(containerQName);
+ final AugmentationIdentifier aug1Id = new AugmentationIdentifier(Collections.singleton(augmentChoice1QName));
+ final AugmentationIdentifier aug2Id = new AugmentationIdentifier(Collections.singleton(augmentChoice2QName));
+ final NodeIdentifier augmentChoice1Id = new NodeIdentifier(augmentChoice1QName);
+ final NodeIdentifier augmentChoice2Id = new NodeIdentifier(augmentChoice2QName);
+ final NodeIdentifier containerId = new NodeIdentifier(containerQName);
final TopBuilder tBuilder = new TopBuilder();
final TopChoiceAugment1Builder tca1Builder = new TopChoiceAugment1Builder();
tBuilder.addAugmentation(TopChoiceAugment1.class, tca1Builder.build());
final Top top = tBuilder.build();
- final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> biResult =
- registry.toNormalizedNode(InstanceIdentifier.create(Top.class), top);
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> biResult = registry.toNormalizedNode(
+ InstanceIdentifier.create(Top.class), top);
final NormalizedNode<?, ?> topNormalized =
- containerBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TOP_QNAME))
+ containerBuilder().withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
.withChild(augmentationBuilder().withNodeIdentifier(aug1Id)
.withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id)
.withChild(augmentationBuilder().withNodeIdentifier(aug2Id)
assertEquals(BI_TOP_PATH, biResult.getKey());
assertEquals(topNormalized, biResult.getValue());
- final Map.Entry<InstanceIdentifier<?>, DataObject> baResult = registry.fromNormalizedNode(BI_TOP_PATH, topNormalized);
+ final Entry<InstanceIdentifier<?>, DataObject> baResult = registry.fromNormalizedNode(BI_TOP_PATH,
+ topNormalized);
assertEquals(InstanceIdentifier.create(Top.class), baResult.getKey());
assertEquals(top, baResult.getValue());
Code Review / mdsal.git / blobdiff