@Test
public void negativeContains() {
final InstanceIdentifier<FooChild> fooChild =
InstanceIdentifier.builder(Nodes.class)
.child(InstantiatedFoo.class)
.child(FooChild.class)
.build();
final InstanceIdentifier<Node> nodeTen =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, new NodeKey(10))
.build();
final InstanceIdentifier<Node> nodeOne =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, new NodeKey(1))
.build();
final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
assertFalse(fooChild.contains(nodeTen));
assertFalse(nodeTen.contains(nodes));
assertFalse(nodeOne.contains(nodes));
assertTrue(nodes.contains(nodeOne));
assertTrue(nodes.containsWildcarded(nodeOne));
assertFalse(nodeOne.containsWildcarded(nodes));
}
@Test
public void fluentConstruction() {
final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
final InstanceIdentifier<Node> node =
InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
assertNotNull(node);
assertEquals(Node.class, node.getTargetType());
assertTrue(nodes.contains(node));
}
@Test
public void containsWildcarded() {
final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
final InstanceIdentifier<Node> wildcarded =
InstanceIdentifier.builder(Nodes.class).child(Node.class).build();
final InstanceIdentifier<NodeChild> wildcardedChildren =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class) //
.child(NodeChild.class)
.build();
assertTrue(wildcarded.isWildcarded());
assertTrue(wildcardedChildren.isWildcarded());
final InstanceIdentifier<Node> nodeTen =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, new NodeKey(10))
.build();
final InstanceIdentifier<Node> nodeOne =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, new NodeKey(1))
.build();
assertFalse(nodeTen.isWildcarded());
assertFalse(nodeOne.isWildcarded());
assertTrue(nodes.containsWildcarded(nodeOne));
assertTrue(wildcarded.containsWildcarded(nodeOne));
assertTrue(wildcarded.containsWildcarded(nodeTen));
assertFalse(
InstanceIdentifier.builder(Nodes.class)
.child(InstantiatedFoo.class)
.build()
.containsWildcarded(wildcarded));
final InstanceIdentifier<NodeChild> nodeTenChildWildcarded =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, new NodeKey(10))
.child(NodeChild.class)
.build();
assertTrue(nodeTenChildWildcarded.isWildcarded());
final InstanceIdentifier<NodeChild> nodeTenChild =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, new NodeKey(10))
.child(NodeChild.class, new NodeChildKey(10))
.build();
final InstanceIdentifier<NodeChild> nodeOneChild =
InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, new NodeKey(1))
.child(NodeChild.class, new NodeChildKey(1))
.build();
assertFalse(nodeTenChildWildcarded.containsWildcarded(nodeOneChild));
assertTrue(nodeTenChildWildcarded.containsWildcarded(nodeTenChild));
}
@Test
public void basicTests() throws Exception {
final InstanceIdentifier<DataObject> instanceIdentifier1 =
InstanceIdentifier.create(DataObject.class);
final InstanceIdentifier<DataObject> instanceIdentifier2 =
InstanceIdentifier.create(DataObject.class);
final InstanceIdentifier<DataObject> instanceIdentifier4 =
InstanceIdentifier.create(DataObject.class);
final InstanceIdentifier<NodeChild> instanceIdentifier3 =
InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(10))
.child(NodeChild.class)
.build();
final Object object = new Object();
assertTrue(instanceIdentifier1.equals(instanceIdentifier1));
assertFalse(instanceIdentifier1.equals(null));
assertFalse(instanceIdentifier1.equals(object));
assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
final Field pathArgumentsField = InstanceIdentifier.class.getDeclaredField("pathArguments");
final Field wildCardField = InstanceIdentifier.class.getDeclaredField("wildcarded");
pathArgumentsField.setAccessible(true);
wildCardField.setAccessible(true);
pathArgumentsField.set(instanceIdentifier2, instanceIdentifier1.pathArguments);
wildCardField.set(instanceIdentifier4, true);
assertTrue(instanceIdentifier1.equals(instanceIdentifier2));
assertFalse(instanceIdentifier1.equals(instanceIdentifier3));
assertFalse(instanceIdentifier1.equals(instanceIdentifier4));
final InstanceIdentifier instanceIdentifier5 = InstanceIdentifier.create(Node.class);
final Field hashField = InstanceIdentifier.class.getDeclaredField("hash");
hashField.setAccessible(true);
hashField.set(instanceIdentifier5, instanceIdentifier1.hashCode());
wildCardField.set(instanceIdentifier5, false);
assertFalse(instanceIdentifier1.equals(instanceIdentifier5));
assertNotNull(
InstanceIdentifier.create(ImmutableList.copyOf(instanceIdentifier1.getPathArguments())));
assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class));
assertNotNull(InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(5)));
assertNotNull(instanceIdentifier5.augmentation(DataObject.class));
assertNotNull(instanceIdentifier1.hashCode());
assertNotNull(instanceIdentifier1.toString());
final InstanceIdentifierBuilder instanceIdentifierBuilder = instanceIdentifier1.builder();
assertEquals(instanceIdentifier1.hashCode(), instanceIdentifierBuilder.hashCode());
assertNotNull(instanceIdentifierBuilder.augmentation(InstantiatedFoo.class));
assertNotNull(instanceIdentifierBuilder.toInstance());
}
@Test
public void constructWithPredicates() {
final InstanceIdentifier<Nodes> nodes = InstanceIdentifier.builder(Nodes.class).build();
assertNotNull(nodes);
assertEquals(Nodes.class, nodes.getTargetType());
final InstanceIdentifier<Node> node = nodes.builder().child(Node.class).build();
assertNotNull(node);
assertEquals(Node.class, node.getTargetType());
assertTrue(nodes.contains(node));
}
@Test
public void firstKeyOfTest() {
final InstanceIdentifier<Node> instanceIdentifier =
InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
final InstanceIdentifier<DataObject> instanceIdentifier1 =
InstanceIdentifier.create(DataObject.class);
assertNotNull(instanceIdentifier.firstKeyOf(Node.class, null));
assertNull(instanceIdentifier1.firstKeyOf(Node.class));
}
@Test
public void firstIdentifierOfTest() {
final InstanceIdentifier<Node> instanceIdentifier =
InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(10)).build();
final InstanceIdentifier<Nodes> nodesIdentifier =
instanceIdentifier.firstIdentifierOf(Nodes.class);
assertNotNull(nodesIdentifier);
final InstanceIdentifier<DataObject> dataObjectIdentifier =
instanceIdentifier.firstIdentifierOf(DataObject.class);
assertNull(dataObjectIdentifier);
}
