private static final QName TEST_QNAME = QName.create(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", "2014-03-13", "test").intern();
static final NodeIdentifier TEST = NodeIdentifier.create(TEST_QNAME);
- static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.create(TEST);
+ static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST);
static final QName OUTER_LIST_QNAME = QName.create(TEST_QNAME, "outer-list").intern();
static final NodeIdentifier OUTER_LIST = NodeIdentifier.create(OUTER_LIST_QNAME);
- static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.create(TEST, OUTER_LIST);
+ static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.of(TEST, OUTER_LIST);
static final QName INNER_LIST_QNAME = QName.create(TEST_QNAME, "inner-list").intern();
static final NodeIdentifier INNER_LIST = NodeIdentifier.create(INNER_LIST_QNAME);
for (int i = 0; i < size; i++) {
pathArguments.add(readPathArgument());
}
- return YangInstanceIdentifier.create(pathArguments.build());
+ return YangInstanceIdentifier.of(pathArguments.build());
}
private Set<String> readObjSet() throws IOException {
for (int i = 0; i < size; ++i) {
builder.add(readPathArgument());
}
- return YangInstanceIdentifier.create(builder.build());
+ return YangInstanceIdentifier.of(builder.build());
} else if (size == 0) {
- return YangInstanceIdentifier.empty();
+ return YangInstanceIdentifier.of();
} else {
throw new InvalidNormalizedNodeStreamException("Invalid YangInstanceIdentifier size " + size);
}
case MagnesiumValue.BINARY_4B:
return readBinary(input.readInt());
case MagnesiumValue.YIID_0:
- return YangInstanceIdentifier.empty();
+ return YangInstanceIdentifier.of();
case MagnesiumValue.YIID:
return readYangInstanceIdentifier(input.readInt());
case MagnesiumValue.QNAME:
for (int i = 0; i < size; ++i) {
builder.add(readPathArgument());
}
- return YangInstanceIdentifier.create(builder.build());
+ return YangInstanceIdentifier.of(builder.build());
} else if (size == 0) {
- return YangInstanceIdentifier.empty();
+ return YangInstanceIdentifier.of();
} else {
throw new InvalidNormalizedNodeStreamException("Invalid YangInstanceIdentifier size " + size);
}
case PotassiumValue.BINARY_4B:
return readBinary(input.readInt());
case PotassiumValue.YIID_0:
- return YangInstanceIdentifier.empty();
+ return YangInstanceIdentifier.of();
case PotassiumValue.YIID:
return readYangInstanceIdentifier(input.readInt());
case PotassiumValue.QNAME:
private static final NodeIdentifier FOO_NODEID = new NodeIdentifier(FOO);
private static final NodeIdentifier BAR_NODEID = new NodeIdentifier(BAR);
private static final NodeIdentifier BAZ_NODEID = new NodeIdentifier(BAZ);
- private static final YangInstanceIdentifier FOO_BAR_PATH = YangInstanceIdentifier.create(FOO_NODEID, BAR_NODEID);
- private static final YangInstanceIdentifier BAR_PATH = YangInstanceIdentifier.create(BAR_NODEID);
+ private static final YangInstanceIdentifier FOO_BAR_PATH = YangInstanceIdentifier.of(FOO_NODEID, BAR_NODEID);
+ private static final YangInstanceIdentifier BAR_PATH = YangInstanceIdentifier.of(BAR_NODEID);
private static final YangInstanceIdentifier BAR_BAZ_PATH = BAR_PATH.node(BAZ_NODEID);
private static EffectiveModelContext CONTEXT;
@Test
public void testWriteRoot() throws IOException {
- assertSerialization(createCandidate(mod -> mod.write(YangInstanceIdentifier.empty(),
+ assertSerialization(createCandidate(mod -> mod.write(YangInstanceIdentifier.of(),
ImmutableNodes.containerNode(SchemaContext.NAME))));
}
@Test
public void testUnmodifiedRoot() throws IOException {
- assertSerialization(createCandidate(mod -> mod.merge(YangInstanceIdentifier.empty(),
+ assertSerialization(createCandidate(mod -> mod.merge(YangInstanceIdentifier.of(),
ImmutableNodes.containerNode(SchemaContext.NAME))));
}
final Collection<DataTreeCandidateNode> actualChildren = actual.getChildNodes();
assertEquals(expectedChildren.size(), actualChildren.size());
- final Iterator<DataTreeCandidateNode> eit = expectedChildren.iterator();
final Iterator<DataTreeCandidateNode> ait = actualChildren.iterator();
- while (eit.hasNext()) {
- assertEqualNodes(eit.next(), ait.next());
+ for (DataTreeCandidateNode expectedChild : expectedChildren) {
+ assertEqualNodes(expectedChild, ait.next());
}
}
}
.withChild(leafNode(TestModel.BIGDECIMAL_LEAF_QNAME, Decimal64.valueOf("1.2")))
.withChild(leafNode(SOME_REF_QNAME,
// Create YangInstanceIdentifier with all path arg types.
- YangInstanceIdentifier.create(new NodeIdentifier(QName.create(TEST_QNAME, "qname")),
+ YangInstanceIdentifier.of(new NodeIdentifier(QName.create(TEST_QNAME, "qname")),
NodeIdentifierWithPredicates.of(QName.create(TEST_QNAME, "list-entry"),
QName.create(TEST_QNAME, "key"), 10),
new NodeWithValue<>(QName.create(TEST_QNAME, "leaf-list-entry"), "foo"))))
@Test
public void testEmptyIdentifier() {
- assertSame(YangInstanceIdentifier.empty(), emptySize);
+ assertSame(YangInstanceIdentifier.of(), emptySize);
}
@Test
}
private static Object lf112Value() {
- return YangInstanceIdentifier.create(
- new NodeIdentifier(QName.create(COMPLEX_JSON, "cont1")),
- new NodeIdentifier(QName.create(COMPLEX_JSON, "lflst11")),
- new NodeWithValue<>(QName.create(COMPLEX_JSON, "lflst11"),"foo")
- );
+ return YangInstanceIdentifier.of(
+ new NodeIdentifier(QName.create(COMPLEX_JSON, "cont1")),
+ new NodeIdentifier(QName.create(COMPLEX_JSON, "lflst11")),
+ new NodeWithValue<>(QName.create(COMPLEX_JSON, "lflst11"), "foo"));
}
private static SystemLeafSetNode<?> childLflst11() {
assertThat(lf112, instanceOf(LeafNode.class));
final QName augmentChoice1 = QName.create(CONT_1, "augment-choice1");
- assertEquals(YangInstanceIdentifier.create(
- CONT_1_NODEID,
- new NodeIdentifier(augmentChoice1),
- new NodeIdentifier(QName.create(CONT_1, "augment-choice2")),
- new NodeIdentifier(QName.create(CONT_1, "case11-choice-case-container"))),
+ assertEquals(YangInstanceIdentifier.of(
+ CONT_1, augmentChoice1, QName.create(CONT_1, "augment-choice2"),
+ QName.create(CONT_1, "case11-choice-case-container")),
((LeafNode<?>) lf112).body());
}
}
private static YangInstanceIdentifier buildYangInstanceIdentifier(final QName node, final QName key,
final Object value) {
- return YangInstanceIdentifier.create(
- new NodeIdentifier(node), NodeIdentifierWithPredicates.of(node, key, value));
+ return YangInstanceIdentifier.of(new NodeIdentifier(node), NodeIdentifierWithPredicates.of(node, key, value));
}
private static YangInstanceIdentifier buildYangInstanceIdentifier(final QName node, final Object value) {
- return YangInstanceIdentifier.create(new NodeIdentifier(node), new NodeWithValue<>(node, value));
+ return YangInstanceIdentifier.of(new NodeIdentifier(node), new NodeWithValue<>(node, value));
}
}
private static YangInstanceIdentifier buildYangInstanceIdentifier(final QName node, final QName key,
final Object value) {
- return YangInstanceIdentifier.create(
- new NodeIdentifier(node), NodeIdentifierWithPredicates.of(node, key, value));
+ return YangInstanceIdentifier.of(new NodeIdentifier(node), NodeIdentifierWithPredicates.of(node, key, value));
}
private static YangInstanceIdentifier buildYangInstanceIdentifier(final QName node, final Object value) {
- return YangInstanceIdentifier.create(new NodeIdentifier(node), new NodeWithValue<>(node, value));
+ return YangInstanceIdentifier.of(new NodeIdentifier(node), new NodeWithValue<>(node, value));
}
}
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
-import java.io.Serial;
-import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.HashCodeBuilder;
final class FixedYangInstanceIdentifier extends YangInstanceIdentifier implements Cloneable {
static final @NonNull FixedYangInstanceIdentifier EMPTY_INSTANCE = new FixedYangInstanceIdentifier(
ImmutableList.of());
- @Serial
+ @java.io.Serial
private static final long serialVersionUID = 1L;
- private final ImmutableList<PathArgument> path;
+ private final
@NonNull ImmutableList<PathArgument> path;
private transient volatile YangInstanceIdentifier parent = null;
this.path = requireNonNull(path, "path must not be null.");
}
- static @NonNull FixedYangInstanceIdentifier of(final ImmutableList<PathArgument> path) {
- return path.isEmpty() ? EMPTY_INSTANCE : new FixedYangInstanceIdentifier(path);
- }
-
- static @NonNull FixedYangInstanceIdentifier of(final List<PathArgument> path) {
- return path.isEmpty() ? EMPTY_INSTANCE : new FixedYangInstanceIdentifier(ImmutableList.copyOf(path));
- }
-
@Override
public boolean isEmpty() {
return path.isEmpty();
YangInstanceIdentifier ret = parent;
if (ret == null) {
- ret = YangInstanceIdentifier.create(path.subList(0, path.size() - 1));
+ ret = YangInstanceIdentifier.of(path.subList(0, path.size() - 1));
parent = ret;
}
// Use the parent cache
return verifyNotNull(getParent());
}
- return YangInstanceIdentifier.create(path.subList(0, depth));
+ return YangInstanceIdentifier.of(path.subList(0, depth));
}
@Override
- public List<PathArgument> getPathArguments() {
+ public
ImmutableList<PathArgument> getPathArguments() {
return path;
}
@Override
- public List<PathArgument> getReversePathArguments() {
+ public
ImmutableList<PathArgument> getReversePathArguments() {
return path.reverse();
}
@Override
- @NonNull List<PathArgument> tryPathArguments() {
+ @NonNull
ImmutableList<PathArgument> tryPathArguments() {
return path;
}
@Override
- @NonNull List<PathArgument> tryReversePathArguments() {
- return path.reverse();
+ @NonNull
ImmutableList<PathArgument> tryReversePathArguments() {
+ return getReversePathArguments();
}
@Override
@Override
YangInstanceIdentifier createRelativeIdentifier(final int skipFromRoot) {
// TODO: can we optimize this one?
- return YangInstanceIdentifier.create(Iterables.skip(getPathArguments(), skipFromRoot));
+ return YangInstanceIdentifier.of(Iterables.skip(getPathArguments(), skipFromRoot));
}
@Override
@Override
public YangInstanceIdentifier toOptimized() {
- return FixedYangInstanceIdentifier.create(getPathArguments());
+ return FixedYangInstanceIdentifier.of(getPathArguments());
}
}
import static java.util.Objects.requireNonNull;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableList.Builder;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Serial;
-import java.util.List;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
/**
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
- final List<PathArgument> args = yid.getPathArguments();
+ final var args = yid.getPathArguments();
out.writeInt(args.size());
for (PathArgument arg : args) {
// Unfortunately PathArgument is an interface and we do not have control over all its implementations,
@Override
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
final int size = in.readInt();
- final Builder<PathArgument> builder = ImmutableList.builderWithExpectedSize(size);
+ final var builder = ImmutableList.<PathArgument>builderWithExpectedSize(size);
for (int i = 0; i < size; ++i) {
builder.add((PathArgument) in.readObject());
}
- yid = YangInstanceIdentifier.create(builder.build());
+ yid = YangInstanceIdentifier.of(builder.build());
}
@Serial
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.lang.reflect.Array;
* namespace.
*
* @return An empty YangInstanceIdentifier
+ * @deprecated Use {@link #of()} instead.
*/
- public static @NonNull YangInstanceIdentifier empty() {
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ public static final @NonNull YangInstanceIdentifier empty() {
+ return of();
+ }
+
+ /**
+ * Return an empty {@link YangInstanceIdentifier}. It corresponds to the path of the conceptual root of the YANG
+ * namespace.
+ *
+ * @return An empty YangInstanceIdentifier
+ */
+ public static final @NonNull YangInstanceIdentifier of() {
return FixedYangInstanceIdentifier.EMPTY_INSTANCE;
}
+ /**
+ * Returns a new InstanceIdentifier with only one path argument of type {@link PathArgument}.
+ *
+ * @param name QName of first node identifier
+ * @return A YangInstanceIdentifier
+ * @throws NullPointerException if {@code name} is {@code null}
+ */
+ public static final @NonNull YangInstanceIdentifier of(final PathArgument name) {
+ return new FixedYangInstanceIdentifier(ImmutableList.of(name));
+ }
+
+ /**
+ * Returns a new InstanceIdentifier composed of supplied {@link PathArgument}s.
+ *
+ * @param path Path arguments
+ * @return A YangInstanceIdentifier
+ * @throws NullPointerException if {@code path} or any of its components is {@code null}
+ */
+ public static final @NonNull YangInstanceIdentifier of(final PathArgument... path) {
+ // We are forcing a copy, since we cannot trust the user
+ return of(ImmutableList.copyOf(path));
+ }
+
+ /**
+ * Returns a new InstanceIdentifier composed of supplied {@link PathArgument}s.
+ *
+ * @param path Path arguments
+ * @return A YangInstanceIdentifier
+ * @throws NullPointerException if {@code path} is {@code null}
+ */
+ public static final @NonNull YangInstanceIdentifier of(final ImmutableList<PathArgument> path) {
+ return path.isEmpty() ? of() : new FixedYangInstanceIdentifier(path);
+ }
+
+ /**
+ * Returns a new InstanceIdentifier composed of supplied {@link PathArgument}s.
+ *
+ * @param path Path arguments
+ * @return A YangInstanceIdentifier
+ * @throws NullPointerException if {@code path} or any of its components is {@code null}
+ */
+ public static final @NonNull YangInstanceIdentifier of(final Collection<? extends PathArgument> path) {
+ return path.isEmpty() ? of() : of(ImmutableList.copyOf(path));
+ }
+
+ /**
+ * Returns a new InstanceIdentifier composed of supplied {@link PathArgument}s.
+ *
+ * @param path Path arguments
+ * @return A YangInstanceIdentifier
+ * @throws NullPointerException if {@code path} or any of its components is {@code null}
+ */
+ public static final @NonNull YangInstanceIdentifier of(final Iterable<? extends PathArgument> path) {
+ return of(ImmutableList.copyOf(path));
+ }
+
+ /**
+ * Returns a new {@link YangInstanceIdentifier} with only one path argument of type {@link NodeIdentifier} with
+ * supplied {@link QName}. Note this is a convenience method aimed at test code. Production code should consider
+ * using {@link #of(PathArgument)} instead.
+ *
+ * @param name QName of first {@link NodeIdentifier}
+ * @return A YangInstanceIdentifier
+ * @throws NullPointerException if {@code name} is {@code null}
+ */
+ public static final @NonNull YangInstanceIdentifier of(final QName name) {
+ return of(new NodeIdentifier(name));
+ }
+
+ /**
+ * Returns a new {@link YangInstanceIdentifier} with path arguments of type {@link NodeIdentifier} with
+ * supplied {@link QName}s. Note this is a convenience method aimed at test code. Production code should consider
+ * using {@link #of(PathArgument...)} instead.
+ *
+ * @param path QNames of {@link NodeIdentifier}s
+ * @return A YangInstanceIdentifier
+ * @throws NullPointerException if {@code path} or any of its components is {@code null}
+ */
+ public static final @NonNull YangInstanceIdentifier of(final QName... path) {
+ return of(Arrays.stream(path).map(NodeIdentifier::new).collect(ImmutableList.toImmutableList()));
+ }
+
+ /**
+ * Create a YangInstanceIdentifier composed of a single {@link PathArgument}.
+ *
+ * @param pathArgument Path argument
+ * @return A {@link YangInstanceIdentifier}
+ * @throws NullPointerException if {@code pathArgument} is null
+ * @deprecated Use {@link #of(NodeIdentifier)} instead.
+ */
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ public static @NonNull YangInstanceIdentifier create(final PathArgument pathArgument) {
+ return of(pathArgument);
+ }
+
+ /**
+ * Create a YangInstanceIdentifier composed of specified {@link PathArgument}s.
+ *
+ * @param path Path arguments
+ * @return A {@link YangInstanceIdentifier}
+ * @throws NullPointerException if {@code path} or any of its components is {@code null}
+ * @deprecated Use {@link #of(PathArgument...)} instead.
+ */
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ public static @NonNull YangInstanceIdentifier create(final PathArgument... path) {
+ return of(path);
+ }
+
+ /**
+ * Create a YangInstanceIdentifier composed of specified {@link PathArgument}s.
+ *
+ * @param path Path arguments
+ * @return A {@link YangInstanceIdentifier}
+ * @throws NullPointerException if {@code path} or any of its components is {@code null}
+ * @deprecated Use {@link #of(Iterable)} instead.
+ */
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ public static @NonNull YangInstanceIdentifier create(final Iterable<? extends PathArgument> path) {
+ return of(path);
+ }
+
abstract @NonNull YangInstanceIdentifier createRelativeIdentifier(int skipFromRoot);
abstract @Nullable List<PathArgument> tryPathArguments();
abstract @Nullable List<PathArgument> tryReversePathArguments();
/**
- * Check if this instance identifier has empty path arguments, e.g. it is
- * empty and corresponds to {@link #empty()}.
+ * Check if this instance identifier has empty path arguments, e.g. it is empty and corresponds to {@link #of()}.
*
* @return True if this instance identifier is empty, false otherwise.
*/
* Return the conceptual parent {@link YangInstanceIdentifier}, which has
* one item less in {@link #getPathArguments()}.
*
- * @return Parent {@link YangInstanceIdentifier}, or null if this object is {@link #empty()}.
+ * @return Parent {@link YangInstanceIdentifier}, or null if this object is {@link #of()}.
*/
public abstract @Nullable YangInstanceIdentifier getParent();
* {@link #getPathArguments()}.
*
* @return Parent {@link YangInstanceIdentifier}
- * @throws VerifyException if this object is {@link #empty()}.
+ * @throws VerifyException if this object is {@link #of()}.
*/
public abstract @NonNull YangInstanceIdentifier coerceParent();
*/
public abstract PathArgument getLastPathArgument();
- public static @NonNull YangInstanceIdentifier create(final Iterable<? extends PathArgument> path) {
- return Iterables.isEmpty(path) ? empty() : new FixedYangInstanceIdentifier(ImmutableList.copyOf(path));
- }
-
- public static @NonNull YangInstanceIdentifier create(final PathArgument pathArgument) {
- return new FixedYangInstanceIdentifier(ImmutableList.of(pathArgument));
- }
-
- public static @NonNull YangInstanceIdentifier create(final PathArgument... path) {
- // We are forcing a copy, since we cannot trust the user
- return create(Arrays.asList(path));
- }
-
/**
* Create a {@link YangInstanceIdentifier} by taking a snapshot of provided path and iterating it backwards.
*
final ImmutableList.Builder<PathArgument> builder = ImmutableList.builderWithExpectedSize(
pathTowardsRoot.size());
pathTowardsRoot.descendingIterator().forEachRemaining(builder::add);
- return YangInstanceIdentifier.create(builder.build());
+ return YangInstanceIdentifier.of(builder.build());
}
/**
*/
public static <T> @NonNull YangInstanceIdentifier createReverse(final Deque<? extends T> stackTowardsRoot,
final Function<T, PathArgument> function) {
- final ImmutableList.Builder<PathArgument> builder = ImmutableList.builderWithExpectedSize(
- stackTowardsRoot.size());
- final Iterator<? extends T> it = stackTowardsRoot.descendingIterator();
+ final var builder = ImmutableList.<PathArgument>builderWithExpectedSize(stackTowardsRoot.size());
+ final var it = stackTowardsRoot.descendingIterator();
while (it.hasNext()) {
builder.add(function.apply(it.next()));
}
- return YangInstanceIdentifier.create(builder.build());
+ return YangInstanceIdentifier.of(builder.build());
}
boolean pathArgumentsEqual(final YangInstanceIdentifier other) {
*/
public Optional<YangInstanceIdentifier> relativeTo(final YangInstanceIdentifier ancestor) {
if (this == ancestor) {
- return Optional.of(empty());
+ return Optional.of(of());
}
if (ancestor.isEmpty()) {
return Optional.of(this);
}
final Iterator<PathArgument> lit = getPathArguments().iterator();
- final Iterator<PathArgument> oit = ancestor.getPathArguments().iterator();
int common = 0;
- while (oit.hasNext()) {
+ for (PathArgument element : ancestor.getPathArguments()) {
// Ancestor is not really an ancestor
- if (!lit.hasNext() || !lit.next().equals(oit.next())) {
+ if (!lit.hasNext() || !lit.next().equals(element)) {
return Optional.empty();
}
return Optional.of(this);
}
if (!lit.hasNext()) {
- return Optional.of(empty());
+ return Optional.of(of());
}
return Optional.of(createRelativeIdentifier(common));
}
checkArgument(other != null, "other should not be null");
- final Iterator<PathArgument> lit = getPathArguments().iterator();
final Iterator<PathArgument> oit = other.getPathArguments().iterator();
- while (lit.hasNext()) {
+ for (PathArgument element : getPathArguments()) {
if (!oit.hasNext()) {
return false;
}
- if (!lit.next().equals(oit.next())) {
+ if (!element.equals(oit.next())) {
return false;
}
}
return new YIDv1(this);
}
- // Static factories & helpers
-
- /**
- * Returns a new InstanceIdentifier with only one path argument of type {@link NodeIdentifier} with supplied
- * QName.
- *
- * @param name QName of first node identifier
- * @return Instance Identifier with only one path argument of type {@link NodeIdentifier}
- */
- public static @NonNull YangInstanceIdentifier of(final QName name) {
- return create(new NodeIdentifier(name));
- }
-
/**
* Returns new builder for InstanceIdentifier with empty path arguments.
*
*/
static Map<NormalizedNode, DuplicateEntry> findDuplicates(final NormalizedNode node) {
final DuplicateFinder finder = new DuplicateFinder();
- finder.findDuplicates(YangInstanceIdentifier.empty(), node);
+ finder.findDuplicates(YangInstanceIdentifier.of(), node);
return finder.identities;
}
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
public class PathArgumentListTest {
- private static final PathArgumentList LIST = new StackedPathArguments(YangInstanceIdentifier.empty(),
+ private static final PathArgumentList LIST = new StackedPathArguments(YangInstanceIdentifier.of(),
List.of(new NodeIdentifier(QName.create("foo", "foo"))));
@Test
entryLeaf.put(qNameList, "leaf");
final NodeIdentifierWithPredicates nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(qNameList,
entryLeaf);
- final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(qNameRoot).node(qNameList)
+ final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.of(qNameRoot, qNameList)
.node(nodeIdentifierWithPredicates).node(qNameLeaf);
final PathArgument pathArgumentToRoot = yangInstanceIdentifier.getAncestor(1).getPathArguments().iterator()
.next();
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
@Test
public void testGetLastPathArgument() {
- YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
+ YangInstanceIdentifier id1 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
new NodeIdentifier(NODENAME2));
assertEquals(new NodeIdentifier(NODENAME2), id1.getLastPathArgument());
- YangInstanceIdentifier id2 = YangInstanceIdentifier.create();
+ YangInstanceIdentifier id2 = YangInstanceIdentifier.of();
assertNull(id2.getLastPathArgument());
}
@Test
public void testHashCodeEquals() {
- YangInstanceIdentifier id1 = YangInstanceIdentifier.create(NodeIdentifier.create(NODENAME1),
+ YangInstanceIdentifier id1 = YangInstanceIdentifier.of(NodeIdentifier.create(NODENAME1),
new NodeIdentifier(NODENAME2));
- YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
+ YangInstanceIdentifier id2 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
NodeIdentifier.create(NODENAME2));
assertEquals(id1.hashCode(), id2.hashCode());
}
@Test
public void testEquals() {
- final YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
- final YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
- final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME2),
- new NodeIdentifier(NODENAME1));
- final YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
+ final var id1 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
+ final var id2 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
+ final var id3 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME1));
+ final var id4 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1));
assertFalse(id1.equals(null));
assertTrue(id1.equals(id1));
@Test
public void testToString() {
- YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
-
+ final var id = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
assertNotNull(id.toString());
}
@Test
public void testNode() {
- final YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
+ final var id = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
- YangInstanceIdentifier newID = id.node(NODENAME3);
+ var newID = id.node(NODENAME3);
assertNotNull(newID);
assertEquals(3, newID.getPathArguments().size());
- Iterator<PathArgument> it = newID.getPathArguments().iterator();
+ var it = newID.getPathArguments().iterator();
assertEquals(NODENAME1, it.next().getNodeType());
assertEquals(NODENAME2, it.next().getNodeType());
assertEquals(NODENAME3, it.next().getNodeType());
@Test
public void testRelativeTo() {
- final YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
+ final YangInstanceIdentifier id1 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
- final YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
+ final YangInstanceIdentifier id2 = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1),
new NodeIdentifier(NODENAME2));
- final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(List.of(
+ final YangInstanceIdentifier id3 = YangInstanceIdentifier.of(List.of(
new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2)));
Optional<YangInstanceIdentifier> relative = id1.relativeTo(id2);
@Test
public void testContainsNull() {
- final YangInstanceIdentifier id = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
-
+ final var id = YangInstanceIdentifier.of(NODENAME1);
assertThrows(IllegalArgumentException.class, () -> id.contains(null));
}
@Test
public void testContains() {
- final YangInstanceIdentifier id1 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2), new NodeIdentifier(NODENAME3), new NodeIdentifier(NODENAME4));
- final YangInstanceIdentifier id2 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
- final YangInstanceIdentifier id3 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
- final YangInstanceIdentifier id4 = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME3));
+ final var id1 = YangInstanceIdentifier.of(NODENAME1, NODENAME2, NODENAME3, NODENAME4);
+ final var id2 = YangInstanceIdentifier.of(NODENAME1, NODENAME2);
+ final var id3 = YangInstanceIdentifier.of(NODENAME1, NODENAME2);
+ final var id4 = YangInstanceIdentifier.of(NODENAME1, NODENAME3);
assertTrue(id2.contains(id1));
assertTrue(id2.contains(id3));
@Test
public void testOf() {
- YangInstanceIdentifier newID = YangInstanceIdentifier.of(NODENAME1);
+ final var newID = YangInstanceIdentifier.of(NODENAME1);
assertNotNull(newID);
assertEquals(1, newID.getPathArguments().size());
assertEquals(NODENAME1, newID.getPathArguments().get(0).getNodeType());
@Test
public void testBuilder() {
- YangInstanceIdentifier newID = YangInstanceIdentifier.builder()
+ var newID = YangInstanceIdentifier.builder()
.node(NODENAME1)
.nodeWithKey(NODENAME2, Map.of(KEY1, "foo"))
.nodeWithKey(NODENAME3, KEY2, "bar").build();
assertNotNull(newID);
assertEquals(3, newID.getPathArguments().size());
- Iterator<PathArgument> it = newID.getPathArguments().iterator();
+ var it = newID.getPathArguments().iterator();
assertEquals(NODENAME1, it.next().getNodeType());
verifyNodeIdentifierWithPredicates("PathArg 2", it.next(), NODENAME2, KEY1, "foo");
verifyNodeIdentifierWithPredicates("PathArg 3", it.next(), NODENAME3, KEY2, "bar");
@Test
public void testSerialization() throws IOException, ClassNotFoundException {
- final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
+ final var fixed = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
assertEquals(fixed, serdes(fixed));
- final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(new NodeIdentifier(NODENAME1));
+ final var stacked = YangInstanceIdentifier.of().node(new NodeIdentifier(NODENAME1));
assertEquals(stacked, serdes(stacked));
- final YangInstanceIdentifier empty = serdes(YangInstanceIdentifier.empty());
- assertSame(YangInstanceIdentifier.empty(), empty);
+ final var empty = serdes(YangInstanceIdentifier.of());
+ assertSame(YangInstanceIdentifier.of(), empty);
}
@Test
public void testToOptimized() {
- final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1),
- new NodeIdentifier(NODENAME2));
- final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(NodeIdentifier.create(NODENAME1))
+ final var fixed = YangInstanceIdentifier.of(new NodeIdentifier(NODENAME1), new NodeIdentifier(NODENAME2));
+ final var stacked = YangInstanceIdentifier.of().node(NodeIdentifier.create(NODENAME1))
.node(NodeIdentifier.create(NODENAME2));
assertSame(fixed, fixed.toOptimized());
- final YangInstanceIdentifier opt = stacked.toOptimized();
+ final var opt = stacked.toOptimized();
assertTrue(opt instanceof FixedYangInstanceIdentifier);
assertEquals(fixed, stacked.toOptimized());
}
@Test
public void testGetParent() {
- final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
- final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(new NodeIdentifier(NODENAME1));
- final YangInstanceIdentifier twoStacked = stacked.node(new NodeIdentifier(NODENAME2));
+ final var fixed = YangInstanceIdentifier.of(NODENAME1);
+ final var stacked = YangInstanceIdentifier.of().node(new NodeIdentifier(NODENAME1));
+ final var twoStacked = stacked.node(NODENAME2);
- assertNull(YangInstanceIdentifier.empty().getParent());
- assertSame(YangInstanceIdentifier.empty(), fixed.getParent());
- assertSame(YangInstanceIdentifier.empty(), stacked.getParent());
+ assertNull(YangInstanceIdentifier.of().getParent());
+ assertSame(YangInstanceIdentifier.of(), fixed.getParent());
+ assertSame(YangInstanceIdentifier.of(), stacked.getParent());
assertSame(stacked, twoStacked.getParent());
}
@Test
public void testIsEmpty() {
- final YangInstanceIdentifier fixed = YangInstanceIdentifier.create(new NodeIdentifier(NODENAME1));
- final YangInstanceIdentifier stacked = YangInstanceIdentifier.empty().node(new NodeIdentifier(NODENAME1));
+ final YangInstanceIdentifier fixed = YangInstanceIdentifier.of(NODENAME1);
+ final YangInstanceIdentifier stacked = YangInstanceIdentifier.of().node(NODENAME1);
- assertTrue(YangInstanceIdentifier.empty().isEmpty());
+ assertTrue(YangInstanceIdentifier.of().isEmpty());
assertFalse(fixed.isEmpty());
assertFalse(stacked.isEmpty());
}
final QName node3QName = QName.create("test-ns", "2016-09-16", "node3");
final QName node4Qname = QName.create("test-ns", "2016-09-16", "node4");
- final YangInstanceIdentifier rootPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
+ final YangInstanceIdentifier rootPath = YangInstanceIdentifier.of(new NodeIdentifier(node1QName),
new NodeIdentifier(node2Qname));
- final YangInstanceIdentifier childPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
+ final YangInstanceIdentifier childPath = YangInstanceIdentifier.of(new NodeIdentifier(node1QName),
new NodeIdentifier(node2Qname), new NodeIdentifier(node3QName), new NodeIdentifier(node4Qname));
assertEquals(Optional.of(mockedLeafNode),
.build())
.build())
.build(),
- ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey)));
+ ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.of(rootContainer, outerList, outerListWithKey)));
}
@Test
.build())
.build())
.build(),
- ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue)));
+ ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.of(rootContainer, leafList, leafListWithValue)));
}
@Test
public void testEmptyInstanceIdentifier() {
assertEquals(ImmutableNodes.containerNode(SchemaContext.NAME),
- ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.empty()));
+ ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.of()));
}
@Test
final NodeIdentifierWithPredicates id = NodeIdentifierWithPredicates.of(TWO_KEY_LIST.getNodeType(), misordered);
assertArrayEquals(new Object[] { BAR, FOO }, id.keySet().toArray());
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(TWO_KEY_LIST, id));
+ final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx, YangInstanceIdentifier.of(TWO_KEY_LIST, id));
assertThat(filter, isA(MapNode.class));
final Collection<MapEntryNode> value = ((MapNode) filter).body();
assertEquals(1, value.size());
*/
@Override
default DataTreeModificationCursor openCursor() {
- return openCursor(YangInstanceIdentifier.empty()).orElseThrow();
+ return openCursor(YangInstanceIdentifier.of()).orElseThrow();
}
}
* @throws IllegalStateException if there is another cursor currently open.
*/
default DataTreeSnapshotCursor openCursor() {
- return openCursor(YangInstanceIdentifier.empty()).orElseThrow();
+ return openCursor(YangInstanceIdentifier.of()).orElseThrow();
}
@Override
public Builder(final TreeType treeType) {
this.treeType = requireNonNull(treeType);
- rootPath = YangInstanceIdentifier.empty();
+ rootPath = YangInstanceIdentifier.of();
}
public @NonNull Builder setUniqueIndexes(final boolean uniqueIndexes) {
final TreeNode currentRoot = getTipRoot();
if (root.getOperation() == LogicalOperation.NONE) {
- return new NoopDataTreeCandidate(YangInstanceIdentifier.empty(), root, currentRoot);
+ return new NoopDataTreeCandidate(YangInstanceIdentifier.of(), root, currentRoot);
}
final var newRoot = m.getStrategy().apply(m.getRootModification(), Optional.of(currentRoot), m.getVersion());
checkState(newRoot.isPresent(), "Apply strategy failed to produce root node for modification %s", modification);
- return new InMemoryDataTreeCandidate(YangInstanceIdentifier.empty(), root, currentRoot, newRoot.orElseThrow());
+ return new InMemoryDataTreeCandidate(YangInstanceIdentifier.of(), root, currentRoot, newRoot.orElseThrow());
}
private static InMemoryDataTreeModification checkedCast(final DataTreeModification mod) {
}
final var builder = ImmutableList.<YangInstanceIdentifier>builder();
- findMandatoryNodes(builder, YangInstanceIdentifier.empty(), schema, treeConfig.getTreeType());
+ findMandatoryNodes(builder, YangInstanceIdentifier.of(), schema, treeConfig.getTreeType());
final var mandatoryNodes = builder.build();
return mandatoryNodes.isEmpty() ? null : new MandatoryLeafEnforcer(mandatoryNodes);
}
@Override
public List<YangNetconfError> getNetconfErrors() {
- return new RequiredElementCountException(YangInstanceIdentifier.empty(), actual, min, max, "dummy")
+ return new RequiredElementCountException(YangInstanceIdentifier.of(), actual, min, max, "dummy")
.getNetconfErrors();
}
}
final DataTree ret = createDataTree(treeConfig, initialSchemaContext, false);
final DataTreeModification mod = ret.takeSnapshot().newModification();
- mod.write(YangInstanceIdentifier.empty(), initialRoot);
+ mod.write(YangInstanceIdentifier.of(), initialRoot);
mod.ready();
ret.validate(mod);
final LeafRefContext referencingCtx = rootLeafRefCtx.getReferencingChildByName(childQName);
if (referencedByCtx != null || referencingCtx != null) {
validateNode(dataTreeCandidateNode, referencedByCtx, referencingCtx,
- YangInstanceIdentifier.create(identifier));
+ YangInstanceIdentifier.of(identifier));
}
}
}
case 2: {
/* WRITE INNER LIST ENTRY */
MapEntryNode innerListEntryA = createInnerListEntry("a", "i-a-2");
- path = YangInstanceIdentifier.of(root).node(subRoot).node(outerList).node(createOuterListEntryPath("2"))
+ path = YangInstanceIdentifier.of(root, subRoot, outerList).node(createOuterListEntryPath("2"))
.node(innerList).node(createInnerListEntryPath("a"));
modification.write(path, innerListEntryA);
break;
}
case 3: {
/* WRITE INNER LIST WITH ENTRIES */
- path = YangInstanceIdentifier.of(root).node(subRoot).node(outerList).node(createOuterListEntryPath("2"))
+ path = YangInstanceIdentifier.of(root, subRoot, outerList).node(createOuterListEntryPath("2"))
.node(innerList);
modification.write(path, createInnerListBuilder()
.withChild(createInnerListEntry("a", "i-a-3"))
}
private void writeEmptyInnerList(final DataTreeModification modification, final String outerListEntryKey) {
- YangInstanceIdentifier path = YangInstanceIdentifier.of(root).node(subRoot).node(outerList)
+ YangInstanceIdentifier path = YangInstanceIdentifier.of(root, subRoot, outerList)
.node(createOuterListEntryPath(outerListEntryKey)).node(innerList);
modification.write(path, createInnerListBuilder().build());
}
private static final QName MIN_MAX_VALUE_LEAF_QNAME = QName.create(MASTER_CONTAINER_QNAME, "min-max-value-leaf");
private static final QName PRESENCE_QNAME = QName.create(MASTER_CONTAINER_QNAME, "presence");
- private static final YangInstanceIdentifier MASTER_CONTAINER_PATH = YangInstanceIdentifier
- .of(MASTER_CONTAINER_QNAME);
- private static final YangInstanceIdentifier MIN_MAX_LIST_PATH = YangInstanceIdentifier
- .builder(MASTER_CONTAINER_PATH)
- .node(MIN_MAX_LIST_QNAME).build();
+ private static final YangInstanceIdentifier MASTER_CONTAINER_PATH =
+ YangInstanceIdentifier.of(MASTER_CONTAINER_QNAME);
+ private static final YangInstanceIdentifier MIN_MAX_LIST_PATH =
+ YangInstanceIdentifier.builder(MASTER_CONTAINER_PATH).node(MIN_MAX_LIST_QNAME).build();
private static final YangInstanceIdentifier PRESENCE_PATH = YangInstanceIdentifier.of(PRESENCE_QNAME);
private static final YangInstanceIdentifier PRESENCE_MIN_MAX_LIST_PATH = PRESENCE_PATH.node(MIN_MAX_LIST_QNAME);
- private static final YangInstanceIdentifier MIN_MAX_LIST_NO_MINMAX_PATH = YangInstanceIdentifier
- .builder(MASTER_CONTAINER_PATH)
- .node(MIN_MAX_LIST_QNAME_NO_MINMAX).build();
- private static final YangInstanceIdentifier MIN_MAX_LEAF_LIST_PATH = YangInstanceIdentifier
- .builder(MASTER_CONTAINER_PATH).node(MIN_MAX_LEAF_LIST_QNAME).build();
+ private static final YangInstanceIdentifier MIN_MAX_LIST_NO_MINMAX_PATH =
+ YangInstanceIdentifier.builder(MASTER_CONTAINER_PATH).node(MIN_MAX_LIST_QNAME_NO_MINMAX).build();
+ private static final YangInstanceIdentifier MIN_MAX_LEAF_LIST_PATH =
+ YangInstanceIdentifier.builder(MASTER_CONTAINER_PATH).node(MIN_MAX_LEAF_LIST_QNAME).build();
private final MapEntryNode fooEntryNodeWithValue = Builders.mapEntryBuilder()
.withNodeIdentifier(NodeIdentifierWithPredicates.of(MIN_MAX_LIST_QNAME, MIN_MAX_KEY_LEAF_QNAME, "foo"))
inMemoryDataTree.commit(prepare);
// Empty list should have disappeared, along with the container, as we are not enforcing root
- final NormalizedNode data = inMemoryDataTree.takeSnapshot()
- .readNode(YangInstanceIdentifier.empty()).orElseThrow();
+ final NormalizedNode data = inMemoryDataTree.takeSnapshot().readNode(YangInstanceIdentifier.of()).orElseThrow();
assertTrue(data instanceof ContainerNode);
assertEquals(0, ((ContainerNode) data).size());
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import com.google.common.collect.ImmutableMap;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
final SystemMapNode taskNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(TASK)).build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
- modificationTree.write(YangInstanceIdentifier.of(TASK_CONTAINER).node(TASK), taskNode);
+ modificationTree.write(YangInstanceIdentifier.of(TASK_CONTAINER, TASK), taskNode);
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
assertNotNull("Schema context must not be null.", schemaContext);
testContainerIsNotPresent(schemaContext);
- try {
- testContainerIsPresent(schemaContext);
- fail("Should fail due to missing mandatory node under present presence container.");
- } catch (IllegalArgumentException e) {
- assertEquals(
- "Node (foo?revision=2016-05-17)task-data is missing mandatory descendant /(foo?revision=2016-05-17)"
- + "mandatory-data", e.getMessage());
- }
+ final var ex = assertThrows(IllegalArgumentException.class, () -> testContainerIsPresent(schemaContext));
+ assertEquals(
+ "Node (foo?revision=2016-05-17)task-data is missing mandatory descendant /(foo?revision=2016-05-17)"
+ + "mandatory-data", ex.getMessage());
testMandatoryDataLeafIsPresent(schemaContext);
}
testMandatoryDataLeafIsPresent(schemaContext);
fail("Should fail due to missing mandatory node under present presence container.");
} catch (IllegalArgumentException e) {
- assertEquals("Node (foo?revision=2016-05-17)task-data "
- + "is missing mandatory descendant /(foo?revision=2016-05-17)non-presence-container/"
- + "non-presence-container-2/mandatory-leaf-2", e.getMessage());
+ assertEquals("""
+ Node (foo?revision=2016-05-17)task-data is missing mandatory descendant \
+ /(foo?revision=2016-05-17)non-presence-container/\
+ non-presence-container-2/mandatory-leaf-2""", e.getMessage());
}
testMandatoryLeaf2IsPresent(schemaContext, false);
throws DataValidationFailedException {
final DataTree inMemoryDataTree = initDataTree(schemaContext);
final MapEntryNode taskEntryNode = Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123")))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123"))
.withChild(ImmutableNodes.leafNode(TASK_ID, "123"))
- .withChild(ImmutableNodes.leafNode(TASK_MANDATORY_LEAF, "mandatory data")).build();
+ .withChild(ImmutableNodes.leafNode(TASK_MANDATORY_LEAF, "mandatory data"))
+ .build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(
- YangInstanceIdentifier.of(TASK_CONTAINER).node(TASK)
- .node(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123"))), taskEntryNode);
+ YangInstanceIdentifier.of(TASK_CONTAINER, TASK).node(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123")),
+ taskEntryNode);
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
final DataTree inMemoryDataTree = initDataTree(schemaContext);
final MapEntryNode taskEntryNode = Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123")))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123"))
.withChild(ImmutableNodes.leafNode(TASK_ID, "123"))
.withChild(ImmutableNodes.leafNode(TASK_MANDATORY_LEAF, "mandatory data"))
.withChild(createTaskDataContainer(false)).build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(
- YangInstanceIdentifier.of(TASK_CONTAINER).node(TASK)
- .node(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123"))), taskEntryNode);
+ YangInstanceIdentifier.of(TASK_CONTAINER, TASK).node(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123")),
+ taskEntryNode);
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
final DataTree inMemoryDataTree = initDataTree(schemaContext);
final MapEntryNode taskEntryNode = Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123")))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123"))
.withChild(ImmutableNodes.leafNode(TASK_ID, "123"))
.withChild(ImmutableNodes.leafNode(TASK_MANDATORY_LEAF, "mandatory data"))
.withChild(createTaskDataContainer(true)).build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(
- YangInstanceIdentifier.of(TASK_CONTAINER).node(TASK)
- .node(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123"))), taskEntryNode);
+ YangInstanceIdentifier.of(TASK_CONTAINER, TASK).node(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123")),
+ taskEntryNode);
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
final DataTree inMemoryDataTree = initDataTree(schemaContext);
final MapEntryNode taskEntryNode = Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123")))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123"))
.withChild(ImmutableNodes.leafNode(TASK_ID, "123"))
.withChild(ImmutableNodes.leafNode(TASK_MANDATORY_LEAF, "mandatory data"))
- .withChild(createTaskDataMultipleContainer(withPresenceContianer)).build();
+ .withChild(createTaskDataMultipleContainer(withPresenceContianer))
+ .build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(
- YangInstanceIdentifier.of(TASK_CONTAINER).node(TASK)
- .node(NodeIdentifierWithPredicates.of(TASK, ImmutableMap.of(TASK_ID, "123"))), taskEntryNode);
+ YangInstanceIdentifier.of(TASK_CONTAINER, TASK).node(NodeIdentifierWithPredicates.of(TASK, TASK_ID, "123")),
+ taskEntryNode);
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> root = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(ROOT));
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
- modificationTree.merge(
- YangInstanceIdentifier.of(ROOT),
- withMapNode ? root.withChild(
- Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(MY_LIST)).build()).build() : root
- .build());
+ modificationTree.merge(YangInstanceIdentifier.of(ROOT),
+ withMapNode ? root.withChild(
+ Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(MY_LIST)).build()).build()
+ : root.build());
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
private static void mergeMap(final DataTreeModification modificationTree,
final boolean mandatoryDataMissing) throws DataValidationFailedException {
- modificationTree.merge(YangInstanceIdentifier.of(ROOT).node(MY_LIST), createMap(mandatoryDataMissing));
+ modificationTree.merge(YangInstanceIdentifier.of(ROOT, MY_LIST), createMap(mandatoryDataMissing));
}
private static SystemMapNode createMap(final boolean mandatoryDataMissing) throws DataValidationFailedException {
: createMapEntry(listIdValue, mandatoryLeafValue, commonLeafValue);
modificationTree.merge(
- YangInstanceIdentifier.of(ROOT).node(MY_LIST)
- .node(NodeIdentifierWithPredicates.of(MY_LIST, ImmutableMap.of(LIST_ID, listIdValue))),
- taskEntryNode);
+ YangInstanceIdentifier.of(ROOT, MY_LIST)
+ .node(NodeIdentifierWithPredicates.of(MY_LIST, LIST_ID, listIdValue)),
+ taskEntryNode);
}
private static MapEntryNode createMapEntry(final Object listIdValue, final Object mandatoryLeafValue,
final Object commonLeafValue) throws DataValidationFailedException {
return Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(MY_LIST, ImmutableMap.of(LIST_ID, listIdValue)))
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(MY_LIST, LIST_ID, listIdValue))
.withChild(ImmutableNodes.leafNode(LIST_ID, listIdValue))
.withChild(ImmutableNodes.leafNode(MANDATORY_LEAF, mandatoryLeafValue))
.withChild(ImmutableNodes.leafNode(COMMON_LEAF, commonLeafValue)).build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.merge(YangInstanceIdentifier.of(ROOT), createContainerBuilder().build());
- modificationTree.merge(YangInstanceIdentifier.of(ROOT).node(MY_LIST), createMapBuilder().build());
+ modificationTree.merge(YangInstanceIdentifier.of(ROOT, MY_LIST), createMapBuilder().build());
modificationTree.merge(
- YangInstanceIdentifier.of(ROOT).node(MY_LIST)
- .node(NodeIdentifierWithPredicates.of(MY_LIST, ImmutableMap.of(LIST_ID, "1"))),
- createEmptyMapEntryBuilder("1").build());
+ YangInstanceIdentifier.of(ROOT, MY_LIST).node(NodeIdentifierWithPredicates.of(MY_LIST, LIST_ID, "1")),
+ createEmptyMapEntryBuilder("1").build());
modificationTree.merge(
- YangInstanceIdentifier.of(ROOT).node(MY_LIST)
- .node(NodeIdentifierWithPredicates.of(MY_LIST, ImmutableMap.of(LIST_ID, "1"))),
- createMapEntry("1", "mandatory-value", "common-value"));
+ YangInstanceIdentifier.of(ROOT, MY_LIST).node(NodeIdentifierWithPredicates.of(MY_LIST, LIST_ID, "1")),
+ createMapEntry("1", "mandatory-value", "common-value"));
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.merge(YangInstanceIdentifier.of(ROOT), createContainerBuilder().build());
- modificationTree.merge(YangInstanceIdentifier.of(ROOT).node(MY_LIST), createMapBuilder().build());
+ modificationTree.merge(YangInstanceIdentifier.of(ROOT, MY_LIST), createMapBuilder().build());
modificationTree.merge(
- YangInstanceIdentifier.of(ROOT).node(MY_LIST)
- .node(NodeIdentifierWithPredicates.of(MY_LIST, ImmutableMap.of(LIST_ID, "1"))),
- createEmptyMapEntryBuilder("1").build());
+ YangInstanceIdentifier.of(ROOT, MY_LIST).node(NodeIdentifierWithPredicates.of(MY_LIST, LIST_ID, "1")),
+ createEmptyMapEntryBuilder("1").build());
modificationTree.merge(
- YangInstanceIdentifier.of(ROOT).node(MY_LIST)
- .node(NodeIdentifierWithPredicates.of(MY_LIST, ImmutableMap.of(LIST_ID, "1"))),
- createMapEntry("1", "common-value"));
+ YangInstanceIdentifier.of(ROOT, MY_LIST).node(NodeIdentifierWithPredicates.of(MY_LIST, LIST_ID, "1")),
+ createMapEntry("1", "common-value"));
try {
modificationTree.ready();
import static org.junit.Assert.assertNotNull;
-import com.google.common.collect.ImmutableMap;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
private static void writeInnerList(final DataTree inMemoryDataTree) throws DataValidationFailedException {
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(
- YangInstanceIdentifier.create(
- NodeIdentifierWithPredicates.of(OUTER_LIST, ImmutableMap.of(OUTER_LIST_ID, 1))).node(
- INNER_LIST), Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(INNER_LIST)).build());
+ YangInstanceIdentifier.of(NodeIdentifierWithPredicates.of(OUTER_LIST, OUTER_LIST_ID, 1)).node(INNER_LIST),
+ Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(INNER_LIST)).build());
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
final MapEntryNode outerListMapEntry = Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(OUTER_LIST, ImmutableMap.of(OUTER_LIST_ID, 1)))
- .withChild(ImmutableNodes.leafNode(OUTER_LIST_ID, 1)).build();
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(OUTER_LIST, OUTER_LIST_ID, 1))
+ .withChild(ImmutableNodes.leafNode(OUTER_LIST_ID, 1))
+ .build();
- modificationTree.write(YangInstanceIdentifier.create(NodeIdentifierWithPredicates.of(OUTER_LIST,
- ImmutableMap.of(OUTER_LIST_ID, 1))), outerListMapEntry);
+ modificationTree.write(YangInstanceIdentifier.of(NodeIdentifierWithPredicates.of(OUTER_LIST, OUTER_LIST_ID, 1)),
+ outerListMapEntry);
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
dataTree.validate(modification);
final DataTreeCandidate candidate = dataTree.prepare(modification);
- assertEquals(YangInstanceIdentifier.empty(), candidate.getRootPath());
+ assertEquals(YangInstanceIdentifier.of(), candidate.getRootPath());
final DataTreeCandidateNode node = candidate.getRootNode();
assertEquals(ModificationType.UNMODIFIED, node.getModificationType());
// The entire transaction needs to fizzle to a no-op
final DataTreeCandidate candidate = dataTree.prepare(modification);
- assertEquals(YangInstanceIdentifier.empty(), candidate.getRootPath());
+ assertEquals(YangInstanceIdentifier.of(), candidate.getRootPath());
final DataTreeCandidateNode node = candidate.getRootNode();
assertEquals(ModificationType.UNMODIFIED, node.getModificationType());
.withChild(createChildOrderedListEntry("chkval1", "chlfval1"))
.withChild(createChildOrderedListEntry("chkval2", "chlfval2")).build();
- YangInstanceIdentifier path2 = YangInstanceIdentifier.of(parentContainer).node(childContainer)
- .node(parentOrderedList).node(createParentOrderedListEntryPath("pkval2")).node(childOrderedList);
+ YangInstanceIdentifier path2 = YangInstanceIdentifier.of(parentContainer, childContainer, parentOrderedList)
+ .node(createParentOrderedListEntryPath("pkval2")).node(childOrderedList);
treeModification.write(path2, childOrderedListNode);
treeModification.ready();
// Prepare root
final YangInstanceIdentifier.NodeIdentifier rootContainerId = getNId(TestModel.TEST_QNAME);
- addListEntryModification.write(YangInstanceIdentifier.create(rootContainerId),
+ addListEntryModification.write(YangInstanceIdentifier.of(rootContainerId),
Builders.containerBuilder().withNodeIdentifier(rootContainerId).build());
final NodeIdentifierWithPredicates outerListEntryId = NodeIdentifierWithPredicates.of(
// Write list entry (MapEntryNode) without creating list parent (MapNode)
final MapEntryNode outerListEntry = Builders.mapEntryBuilder().withNodeIdentifier(outerListEntryId).build();
- final YangInstanceIdentifier outerListParentPath = YangInstanceIdentifier.create(getNId(TestModel.TEST_QNAME),
+ final YangInstanceIdentifier outerListParentPath = YangInstanceIdentifier.of(getNId(TestModel.TEST_QNAME),
getNId(TestModel.OUTER_LIST_QNAME));
final YangInstanceIdentifier outerListEntryPath = outerListParentPath.node(outerListEntryId);
addListEntryModification.write(outerListEntryPath, outerListEntry);
// Prepare root container
final YangInstanceIdentifier.NodeIdentifier rootContainerId = getNId(TestModel.TEST_QNAME);
- addListEntryModification.write(YangInstanceIdentifier.create(rootContainerId),
+ addListEntryModification.write(YangInstanceIdentifier.of(rootContainerId),
Builders.containerBuilder().withNodeIdentifier(rootContainerId).build());
- final YangInstanceIdentifier outerListParentPath = YangInstanceIdentifier.create(getNId(TestModel.TEST_QNAME),
+ final YangInstanceIdentifier outerListParentPath = YangInstanceIdentifier.of(getNId(TestModel.TEST_QNAME),
getNId(TestModel.OUTER_LIST_QNAME));
addListEntryModification.merge(outerListParentPath, ImmutableNodes.mapNode(TestModel.OUTER_LIST_QNAME));
final DataTreeModification addListEntryModification = inMemoryDataTree.takeSnapshot().newModification();
final YangInstanceIdentifier.NodeIdentifier rootContainerId = getNId(TestModel.NON_PRESENCE_QNAME);
- final YangInstanceIdentifier path = YangInstanceIdentifier.create(rootContainerId);
+ final YangInstanceIdentifier path = YangInstanceIdentifier.of(rootContainerId);
addListEntryModification.write(path, Builders.containerBuilder().withNodeIdentifier(rootContainerId).build());
addListEntryModification.ready();
private void writeChoice(final DataContainerChild child) throws DataValidationFailedException {
final DataTreeModification mod = dataTree.takeSnapshot().newModification();
- mod.write(YangInstanceIdentifier.create(FOO), choiceBuilder().withNodeIdentifier(FOO).withChild(child).build());
+ mod.write(YangInstanceIdentifier.of(FOO), choiceBuilder().withNodeIdentifier(FOO).withChild(child).build());
mod.ready();
dataTree.validate(mod);
dataTree.commit(dataTree.prepare(mod));
@Test
public void testNoAttributes() {
final DataTreeModification mod = dataTree.takeSnapshot().newModification();
- mod.write(YangInstanceIdentifier.create(BOX), containerBuilder().withNodeIdentifier(BOX)
+ mod.write(YangInstanceIdentifier.of(BOX), containerBuilder().withNodeIdentifier(BOX)
.withChild(mapBuilder().withNodeIdentifier(OBJECT_LIST)
.addChild(mapEntryBuilder().withNodeIdentifier(OBJECT_ITEM)
.withChild(OBJECT_ID_LEAF)
@Test
public void testEmptyAndMergeOne() throws DataValidationFailedException {
final DataTreeModification mod = dataTree.takeSnapshot().newModification();
- mod.write(YangInstanceIdentifier.create(BOX), containerBuilder().withNodeIdentifier(BOX)
+ mod.write(YangInstanceIdentifier.of(BOX), containerBuilder().withNodeIdentifier(BOX)
.withChild(mapBuilder().withNodeIdentifier(OBJECT_LIST)
.addChild(mapEntryBuilder().withNodeIdentifier(OBJECT_ITEM)
.withChild(OBJECT_ID_LEAF)
.build())
.build())
.build());
- mod.merge(YangInstanceIdentifier.create(BOX), containerBuilder().withNodeIdentifier(BOX)
+ mod.merge(YangInstanceIdentifier.of(BOX), containerBuilder().withNodeIdentifier(BOX)
.withChild(mapBuilder().withNodeIdentifier(OBJECT_LIST)
.addChild(mapEntryBuilder().withNodeIdentifier(OBJECT_ITEM)
.withChild(OBJECT_ID_LEAF)
@Test
public void testEmptyAndMergeOneWithListTouched() throws DataValidationFailedException {
final DataTreeModification mod = dataTree.takeSnapshot().newModification();
- mod.write(YangInstanceIdentifier.create(BOX), containerBuilder().withNodeIdentifier(BOX)
+ mod.write(YangInstanceIdentifier.of(BOX), containerBuilder().withNodeIdentifier(BOX)
.withChild(mapBuilder().withNodeIdentifier(OBJECT_LIST)
.addChild(mapEntryBuilder().withNodeIdentifier(OBJECT_ITEM)
.withChild(OBJECT_ID_LEAF)
.build())
.build())
.build());
- mod.merge(YangInstanceIdentifier.create(BOX), containerBuilder().withNodeIdentifier(BOX)
+ mod.merge(YangInstanceIdentifier.of(BOX), containerBuilder().withNodeIdentifier(BOX)
.withChild(mapBuilder().withNodeIdentifier(OBJECT_LIST)
.addChild(mapEntryBuilder().withNodeIdentifier(OBJECT_ITEM)
.withChild(OBJECT_ID_LEAF)
.build())
.build());
- mod.delete(YangInstanceIdentifier.create(BOX, OBJECT_LIST, OBJECT_ITEM, NESTED_LIST, NESTED_ITEM));
+ mod.delete(YangInstanceIdentifier.of(BOX, OBJECT_LIST, OBJECT_ITEM, NESTED_LIST, NESTED_ITEM));
commit(mod);
}
public void testDisappearInChoice() throws DataValidationFailedException {
DataTreeModification mod = dataTree.takeSnapshot().newModification();
// Initialize choice with list
- mod.write(YangInstanceIdentifier.create(BOX), containerBuilder().withNodeIdentifier(BOX)
+ mod.write(YangInstanceIdentifier.of(BOX), containerBuilder()
+ .withNodeIdentifier(BOX)
.withChild(choiceBuilder().withNodeIdentifier(ANY_OF)
.withChild(mapBuilder().withNodeIdentifier(SOME_LIST_ID)
.withChild(mapEntryBuilder()
// Now delete the single item, causing the list to fizzle, while creating the alterinative case
mod = dataTree.takeSnapshot().newModification();
- mod.delete(YangInstanceIdentifier.create(BOX, ANY_OF, SOME_LIST_ID, SOME_LIST_ITEM));
- mod.write(YangInstanceIdentifier.create(BOX, ANY_OF, SOME_LEAF_ID),
+ mod.delete(YangInstanceIdentifier.of(BOX, ANY_OF, SOME_LIST_ID, SOME_LIST_ITEM));
+ mod.write(YangInstanceIdentifier.of(BOX, ANY_OF, SOME_LEAF_ID),
leafBuilder().withNodeIdentifier(SOME_LEAF_ID).withValue("foo").build());
commit(mod);
private DataTreeModification write(final ContainerNode data) throws DataValidationFailedException {
final DataTreeModification mod = dataTree.takeSnapshot().newModification();
- mod.write(YangInstanceIdentifier.create(BOX), data);
+ mod.write(YangInstanceIdentifier.of(BOX), data);
return mod;
}
private void writeAndCommit(final ContainerNode data) throws DataValidationFailedException {
final DataTreeModification mod = dataTree.takeSnapshot().newModification();
- mod.write(YangInstanceIdentifier.create(BOX), data);
+ mod.write(YangInstanceIdentifier.of(BOX), data);
commit(mod);
}
doReturn(ModificationType.WRITE).when(mockedDataTreeCandidateNode).getModificationType();
final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
doReturn(Optional.of(mockedNormalizedNode)).when(mockedDataTreeCandidateNode).getDataAfter();
- DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.empty(),
+ DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.of(),
mockedDataTreeCandidateNode);
verify(mockedCursor, times(1)).write(isNull(), any(NormalizedNode.class));
}
final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
- DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.empty(),
+ DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.of(),
mockedDataTreeCandidateNode);
verify(mockedCursor, times(1)).delete(isNull());
}
doReturn(ModificationType.DELETE).when(mockedChildNode1).getModificationType();
doReturn(List.of(mockedChildNode1)).when(mockedDataTreeCandidateNode).getChildNodes();
- DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.empty(),
+ DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.of(),
mockedDataTreeCandidateNode);
verify(mockedCursor, times(1)).enter((PathArgument) isNull());
verify(mockedCursor, times(1)).delete(isNull());
doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).getModificationType();
final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
- () -> DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.empty(),
+ () -> DataTreeCandidateNodes.applyRootedNodeToCursor(mockedCursor, YangInstanceIdentifier.of(),
mockedDataTreeCandidateNode));
assertThat(ex.getMessage(), containsString("Unsupported modification"));
}
public void testNewDataTreeCandidate() {
final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.newDataTreeCandidate(
- YangInstanceIdentifier.empty(), mockedDataTreeCandidateNode);
+ YangInstanceIdentifier.of(), mockedDataTreeCandidateNode);
assertThat(dataTreeCandidate, instanceOf(DefaultDataTreeCandidate.class));
- assertSame(YangInstanceIdentifier.empty(), dataTreeCandidate.getRootPath());
+ assertSame(YangInstanceIdentifier.of(), dataTreeCandidate.getRootPath());
assertEquals(mockedDataTreeCandidateNode, dataTreeCandidate.getRootNode());
assertThat(dataTreeCandidate.toString(),
containsString("DefaultDataTreeCandidate{rootPath=/, rootNode=Mock for DataTreeCandidateNode, hashCode: "));
public void testFromNormalizedNode() {
final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.fromNormalizedNode(
- YangInstanceIdentifier.empty(), mockedNormalizedNode);
+ YangInstanceIdentifier.of(), mockedNormalizedNode);
assertThat(dataTreeCandidate, instanceOf(DefaultDataTreeCandidate.class));
- assertSame(YangInstanceIdentifier.empty(), dataTreeCandidate.getRootPath());
+ assertSame(YangInstanceIdentifier.of(), dataTreeCandidate.getRootPath());
assertThat(dataTreeCandidate.getRootNode(), instanceOf(NormalizedNodeDataTreeCandidateNode.class));
}
final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
final CursorAwareDataTreeModification mockedModification = mock(CursorAwareDataTreeModification.class);
- doReturn(YangInstanceIdentifier.create(FOO)).when(mockedDataTreeCandidate).getRootPath();
+ doReturn(YangInstanceIdentifier.of(FOO)).when(mockedDataTreeCandidate).getRootPath();
final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
- doReturn(Optional.of(mockedCursor)).when(mockedModification).openCursor(YangInstanceIdentifier.empty());
+ doReturn(Optional.of(mockedCursor)).when(mockedModification).openCursor(YangInstanceIdentifier.of());
final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
- verify(mockedModification, times(1)).openCursor(YangInstanceIdentifier.empty());
+ verify(mockedModification, times(1)).openCursor(YangInstanceIdentifier.of());
verify(mockedCursor, times(1)).delete(FOO);
}
final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
final CursorAwareDataTreeModification mockedModification = mock(CursorAwareDataTreeModification.class);
final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
- doReturn(YangInstanceIdentifier.empty()).when(mockedDataTreeCandidate).getRootPath();
+ doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
- doReturn(YangInstanceIdentifier.empty()).when(mockedDataTreeCandidate).getRootPath();
+ doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
- verify(mockedModification, times(1)).delete(YangInstanceIdentifier.empty());
+ verify(mockedModification, times(1)).delete(YangInstanceIdentifier.of());
}
@Test
final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
- doReturn(YangInstanceIdentifier.empty()).when(mockedDataTreeCandidate).getRootPath();
+ doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
final NormalizedNode mockedNormalizedNode = mock(NormalizedNode.class);
doReturn(Optional.of(mockedNormalizedNode)).when(mockedDataTreeCandidateNode).getDataAfter();
final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
- doReturn(YangInstanceIdentifier.empty()).when(mockedDataTreeCandidate).getRootPath();
+ doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedDataTreeCandidateNode).getModificationType();
final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
- doReturn(YangInstanceIdentifier.empty()).when(mockedDataTreeCandidate).getRootPath();
+ doReturn(YangInstanceIdentifier.of()).when(mockedDataTreeCandidate).getRootPath();
doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).getModificationType();
@Override
protected final YangInstanceIdentifier deserializeImpl(final String data) {
- return YangInstanceIdentifier.create(
+ return YangInstanceIdentifier.of(
new XpathStringParsingPathArgumentBuilder(this, requireNonNull(data)).build());
}
@Test
void testCorrectInput() {
assertTrue(CONTEXT.findChild(YangInstanceIdentifier.of(FOO)).isPresent());
- assertTrue(CONTEXT.findChild(YangInstanceIdentifier.of(FOO).node(BAR)).isPresent());
- assertTrue(CONTEXT.findChild(YangInstanceIdentifier.of(FOO).node(BAR).node(BAZ)).isPresent());
+ assertTrue(CONTEXT.findChild(YangInstanceIdentifier.of(FOO, BAR)).isPresent());
+ assertTrue(CONTEXT.findChild(YangInstanceIdentifier.of(FOO, BAR, BAZ)).isPresent());
}
@Test
@Test
void testNestedBad() {
- assertEquals(Optional.empty(), CONTEXT.findChild(YangInstanceIdentifier.of(BAR).node(BAZ)));
+ assertEquals(Optional.empty(), CONTEXT.findChild(YangInstanceIdentifier.of(BAR, BAZ)));
}
}
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
@Test
void testEnterChoicePath() {
- final var result = CONTEXT.enterPath(YangInstanceIdentifier.create(
- new NodeIdentifier(ONE),
- new NodeIdentifier(TWO),
- new NodeIdentifier(THREE),
- new NodeIdentifier(FOUR)))
- .orElseThrow();
+ final var result = CONTEXT.enterPath(YangInstanceIdentifier.of(ONE, TWO, THREE, FOUR)).orElseThrow();
assertInstanceOf(LeafContextNode.class, result.node());
assertEquals(Absolute.of(ONE, TWO, THREE, THREE, FOUR, FOUR), result.stack().toSchemaNodeIdentifier());
@Test
void testEnterAugmentPath() {
- final var result = CONTEXT.enterPath(YangInstanceIdentifier.create(
- new NodeIdentifier(ONE),
- new NodeIdentifier(FIVE),
- new NodeIdentifier(FIVE)))
- .orElseThrow();
+ final var result = CONTEXT.enterPath(YangInstanceIdentifier.of(ONE, FIVE, FIVE)).orElseThrow();
assertInstanceOf(UnkeyedListItemContextNode.class, result.node());
assertEquals(Absolute.of(ONE, FIVE), result.stack().toSchemaNodeIdentifier());
@Test
void testEnterAugmentChoicePath() {
- final var result = CONTEXT.enterPath(YangInstanceIdentifier.create(
- new NodeIdentifier(ONE),
- new NodeIdentifier(TWO),
- new NodeIdentifier(THREE),
- new NodeIdentifier(SIX)))
- .orElseThrow();
+ final var result = CONTEXT.enterPath(YangInstanceIdentifier.of(ONE, TWO, THREE, SIX)).orElseThrow();
assertInstanceOf(LeafContextNode.class, result.node());
assertEquals(Absolute.of(ONE, TWO, THREE, THREE, SIX, SIX), result.stack().toSchemaNodeIdentifier());
Code Review / yangtools.git / commitdiff