<artifactId>yang-model-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>mockito-configuration</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-test-util</artifactId>
import java.util.Map;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+// FIXME: relocate to yang-data-util, where this can have a proper test suite
final class DuplicateFinder {
private final Map<NormalizedNode, DuplicateEntry> identities = new IdentityHashMap<>();
private final Map<NormalizedNode, DuplicateEntry> duplicates = new HashMap<>();
}
private void findDuplicates(final YangInstanceIdentifier path, final NormalizedNode node) {
- final DuplicateEntry i = identities.get(node);
+ final var i = identities.get(node);
if (i == null) {
- final DuplicateEntry d = duplicates.get(node);
+ final var d = duplicates.get(node);
if (d == null) {
- final DuplicateEntry n = new DuplicateEntry(path);
+ final var n = new DuplicateEntry(path);
identities.put(node, n);
duplicates.put(node, n);
} else {
}
if (node instanceof NormalizedNodeContainer<?> container) {
- for (NormalizedNode child : container.body()) {
+ for (var child : container.body()) {
findDuplicates(path.node(child.name()), child);
}
}
}
/**
- * Recursively scan a {@link NormalizedNode} instance and its children and
- * produce a collection of {@link DuplicateEntry} objects. Each holds the
- * original definition path and a list of hard/softlinks.
+ * Recursively scan a {@link NormalizedNode} instance and its children and produce a collection of
+ * {@link DuplicateEntry} objects. Each holds the original definition path and a list of hard/softlinks.
*
* @param node Root node, may not be null.
* @return List of entries
* @param node A normalized node subtree, may not be null
* @return A Map of NormalizedNode/DuplicateEntry relationships.
*/
+ // FIXME: relocate to yang-data-util, where this can have a proper test suite
public static Map<NormalizedNode, DuplicateEntry> findDuplicates(final @NonNull NormalizedNode node) {
return Maps.filterValues(DuplicateFinder.findDuplicates(node), input -> !input.getDuplicates().isEmpty());
}
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.doReturn;
import com.google.common.base.VerifyException;
import org.junit.jupiter.api.Test;
void getChildByArgHasIdentifier() {
final var key = new NodeIdentifier(QName.create("foo", "foo"));
doCallRealMethod().when(container).getChildByArg(key);
+ doReturn(null).when(container).childByArg(key);
final var ex = assertThrows(VerifyException.class, () -> container.getChildByArg(key));
assertEquals("No child matching (foo)foo", ex.getMessage());
package org.opendaylight.yangtools.yang.data.api.schema;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.doReturn;
+import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+// FIXME: This is a sorry-ass of a test. Move the method, DuplicateFinder and this test to yang-data-util and expand
+// coverage using ImmutableNodes.
+class DuplicityTest {
+ @Mock
+ private LeafNode<?> leaf;
+ @Mock
+ private ContainerNode container;
+
+ @Test
+ public void testDuplicateLeaf() {
+ assertEquals(Map.of(), NormalizedNodes.findDuplicates(leaf));
+ }
-public class DuplicityTest {
@Test
- public void testDuplicate() {
- assertEquals(Map.of(), NormalizedNodes.findDuplicates(mock(LeafNode.class)));
- assertEquals(Map.of(), NormalizedNodes.findDuplicates(mock(ContainerNode.class)));
+ public void testDuplicateContainer() {
+ doReturn(List.of()).when(container).body();
+ assertEquals(Map.of(), NormalizedNodes.findDuplicates(container));
}
}
package org.opendaylight.yangtools.yang.data.api.schema.stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mockito.ArgumentMatchers.any;
+import static org.junit.jupiter.api.Assertions.assertSame;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
import java.io.IOException;
+import java.util.List;
import java.util.Set;
import javax.xml.transform.dom.DOMSource;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QNameModule;
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.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedContainer;
import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UserLeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
+@ExtendWith(MockitoExtension.class)
class NormalizedNodeWriterTest {
- private final QNameModule bazModule = QNameModule.of("baz-namespace", "1970-01-01");
- private final QName myKeyedList = QName.create(bazModule, "my-keyed-list");
- private final QName myKeyLeaf = QName.create(bazModule, "my-key-leaf");
- private final QName myLeafList = QName.create(bazModule, "my-leaf-list");
+ private static final NodeIdentifier NODE_ID = new NodeIdentifier(QName.create("test", "nodeId"));
+ private static final QName QNAME1 = QName.create("test", "qname1");
+ private static final QName QNAME2 = QName.create("test", "qname2");
+
+ @Mock
+ private DOMSourceAnyxmlNode anyxml;
+ @Mock
+ private ChoiceNode choice;
+ @Mock
+ private ContainerNode container;
+ @Mock
+ private LeafNode<String> leaf;
+ @Mock
+ private LeafSetEntryNode<String> leafSetEntry;
+ @Mock
+ private MapEntryNode mapEntry;
+ @Mock
+ private SystemLeafSetNode<String> systemLeafSet;
+ @Mock
+ private SystemMapNode systemMap;
+ @Mock
+ private UnkeyedListEntryNode unkeyedListEntry;
+ @Mock
+ private UnkeyedListNode unkeyedList;
+ @Mock
+ private UserLeafSetNode<String> userLeafSet;
+ @Mock
+ private UserMapNode userMap;
@Test
void testNormalizedNodeWriter() throws IOException {
- final var loggingNormalizedNodeStreamWriter = new LoggingNormalizedNodeStreamWriter();
- final var orderedNormalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
- loggingNormalizedNodeStreamWriter);
+ final var loggingWriter = new LoggingNormalizedNodeStreamWriter();
+ try (var writer = NormalizedNodeWriter.forStreamWriter(loggingWriter, true)) {
- assertEquals(loggingNormalizedNodeStreamWriter, orderedNormalizedNodeWriter.getWriter());
+ assertEquals(loggingWriter, writer.getWriter());
- final var mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
- doReturn(new NodeWithValue<>(myLeafList, "leaflist-value-1")).when(mockedLeafSetEntryNode).name();
- doReturn("leaflist-value-1").when(mockedLeafSetEntryNode).body();
- assertNotNull(orderedNormalizedNodeWriter.write(mockedLeafSetEntryNode));
+ doReturn(new NodeWithValue<>(QNAME1, "leaflist-value-1")).when(leafSetEntry).name();
+ doReturn("leaflist-value-1").when(leafSetEntry).body();
+ assertSame(writer, writer.write(leafSetEntry));
- final var mockedLeafNode = mock(LeafNode.class);
- doReturn("leaf-value-1").when(mockedLeafNode).body();
- assertNotNull(orderedNormalizedNodeWriter.write(mockedLeafNode));
+ doReturn("leaf-value-1").when(leaf).body();
+ doReturn(NODE_ID).when(leaf).name();
+ assertSame(writer, writer.write(leaf));
- final var mockedAnyXmlNode = mock(DOMSourceAnyxmlNode.class);
- doCallRealMethod().when(mockedAnyXmlNode).bodyObjectModel();
- doReturn(new DOMSource()).when(mockedAnyXmlNode).body();
- assertNotNull(orderedNormalizedNodeWriter.write(mockedAnyXmlNode));
+ doCallRealMethod().when(anyxml).bodyObjectModel();
+ doReturn(NODE_ID).when(anyxml).name();
+ doReturn(new DOMSource()).when(anyxml).body();
+ assertSame(writer, writer.write(anyxml));
- final var mockedContainerNode = mock(ContainerNode.class);
- assertNotNull(orderedNormalizedNodeWriter.write(mockedContainerNode));
+ mockContainer(container);
+ assertSame(writer, writer.write(container));
- final var mockedMapEntryNode = mock(MapEntryNode.class);
- doReturn(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "list-key-value-1"))
- .when(mockedMapEntryNode).name();
- doReturn(null).when(mockedMapEntryNode).childByArg(any(NodeIdentifier.class));
- assertNotNull(orderedNormalizedNodeWriter.write(mockedMapEntryNode));
+ doReturn(NodeIdentifierWithPredicates.of(QNAME1, NODE_ID.getNodeType(), "list-key-value-1"))
+ .when(mapEntry).name();
+ doReturn(leaf).when(mapEntry).childByArg(NODE_ID);
+ doReturn(1).when(mapEntry).size();
+ doReturn(List.of(leaf)).when(mapEntry).body();
+ assertSame(writer, writer.write(mapEntry));
- final var mockedUnkeyedListEntryNode = mock(UnkeyedListEntryNode.class);
- assertNotNull(orderedNormalizedNodeWriter.write(mockedUnkeyedListEntryNode));
+ mockContainer(unkeyedListEntry);
+ assertSame(writer, writer.write(unkeyedListEntry));
- assertNotNull(orderedNormalizedNodeWriter.write(mock(ChoiceNode.class)));
+ mockContainer(choice);
+ assertSame(writer, writer.write(choice));
- final var mockedUnkeyedListNode = mock(UnkeyedListNode.class);
- final var value = Set.of(mockedUnkeyedListEntryNode);
- doReturn(value).when(mockedUnkeyedListNode).body();
- assertNotNull(orderedNormalizedNodeWriter.write(mockedUnkeyedListNode));
+ final var value = Set.of(unkeyedListEntry);
+ doReturn(NODE_ID).when(unkeyedList).name();
+ doReturn(1).when(unkeyedList).size();
+ doReturn(value).when(unkeyedList).body();
+ assertSame(writer, writer.write(unkeyedList));
- assertNotNull(orderedNormalizedNodeWriter.write(mock(UserMapNode.class)));
+ mockContainer(userMap);
+ assertSame(writer, writer.write(userMap));
- assertNotNull(orderedNormalizedNodeWriter.write(mock(SystemMapNode.class)));
+ mockContainer(systemMap);
+ assertSame(writer, writer.write(systemMap));
- assertNotNull(orderedNormalizedNodeWriter.write(mock(UserLeafSetNode.class)));
+ mockContainer(userLeafSet);
+ assertSame(writer, writer.write(userLeafSet));
- assertNotNull(orderedNormalizedNodeWriter.write(mock(SystemLeafSetNode.class)));
+ mockContainer(systemLeafSet);
+ assertSame(writer, writer.write(systemLeafSet));
- orderedNormalizedNodeWriter.flush();
- orderedNormalizedNodeWriter.close();
+ writer.flush();
+ }
- try (var nnWriter = NormalizedNodeWriter.forStreamWriter(loggingNormalizedNodeStreamWriter, false)) {
- assertNotNull(nnWriter.write(mockedMapEntryNode));
+ try (var writer = NormalizedNodeWriter.forStreamWriter(loggingWriter, false)) {
+ assertSame(writer, writer.write(mapEntry));
}
}
+
+ private static void mockContainer(final NormalizedContainer<?> container) {
+ doReturn(NODE_ID).when(container).name();
+ doReturn(0).when(container).size();
+ doReturn(List.of()).when(container).body();
+ }
}
import static org.junit.jupiter.api.Assertions.assertEquals;
-import java.io.IOException;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
-public class YT1433Test {
+class YT1433Test {
private static EffectiveModelContext CONTEXT;
@BeforeAll
- public static void beforeAll() {
+ static void beforeAll() {
CONTEXT = YangParserTestUtils.parseYang("""
module foo {
namespace foo;
}
@Test
- public void testContainerAugmentContainer() throws IOException {
+ void testContainerAugmentContainer() throws Exception {
final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
final QName bar = QName.create("foo", "bar");
}
@Test
- public void testChoiceAugmentCointainer() throws IOException {
+ void testChoiceAugmentCointainer() throws Exception {
final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
final QName bar = QName.create("bar", "bar");
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import java.io.IOException;
import java.util.Set;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@ExtendWith(MockitoExtension.class)
-public class YangInstanceIdentifierWriterTest {
+class YangInstanceIdentifierWriterTest {
private static EffectiveModelContext CONTEXT;
+ @Mock
+ private ContainerNode containerNode;
+ @Mock
+ private LeafNode<String> leafNode;
+ @Mock
+ private LeafSetEntryNode<String> leafSetEntry1;
+ @Mock
+ private LeafSetEntryNode<String> leafSetEntry2;
+
@BeforeAll
- public static void beforeAll() {
+ static void beforeAll() {
CONTEXT = YangParserTestUtils.parseYang("""
module test {
namespace test;
}
@Test
- public void testYangInstanceIdentifierWriter() throws IOException {
+ void testYangInstanceIdentifierWriter() throws Exception {
final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
}
@Test
- public void testAugmentationIdentifier() throws IOException {
- final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
+ void testAugmentationIdentifier() throws Exception {
+ final var streamWriter = new FormattingNormalizedNodeStreamWriter();
final QName augmented = QName.create("augment-namespace", "augmented-container");
}
@Test
- public void testMapIdentifier() throws IOException {
- final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
+ void testMapIdentifier() throws Exception {
+ final var streamWriter = new FormattingNormalizedNodeStreamWriter();
final QName listQname = QName.create("test", "list-1");
}
@Test
- public void testChoiceIdentifier() throws IOException {
- final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
+ void testChoiceIdentifier() throws Exception {
+ final var streamWriter = new FormattingNormalizedNodeStreamWriter();
final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
.node(QName.create("test", "choice-node"))
}
@Test
- public void testLeafSetIdentifier() throws IOException {
- final FormattingNormalizedNodeStreamWriter streamWriter = new FormattingNormalizedNodeStreamWriter();
+ void testLeafSetIdentifier() throws Exception {
+ final var streamWriter = new FormattingNormalizedNodeStreamWriter();
final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
.node(QName.create("test", "list-list"))
try (var iidWriter = YangInstanceIdentifierWriter.open(streamWriter, CONTEXT, path)) {
try (var nnWriter = new NormalizedNodeWriter(streamWriter)) {
- final QName leafQname = QName.create("test", "leaf");
+ final var leafQname = QName.create("test", "leaf");
- final LeafSetEntryNode<?> leafNode = mock(LeafSetEntryNode.class);
- doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafNode).name();
- doReturn("test-value").when(leafNode).body();
- nnWriter.write(leafNode);
+ doReturn(new NodeWithValue<>(leafQname, "test-value")).when(leafSetEntry1).name();
+ doReturn("test-value").when(leafSetEntry1).body();
+ nnWriter.write(leafSetEntry1);
- final LeafSetEntryNode<?> leafNode2 = mock(LeafSetEntryNode.class);
- doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafNode2).name();
- doReturn("test-value-2").when(leafNode2).body();
- nnWriter.write(leafNode2);
+ doReturn(new NodeWithValue<>(leafQname, "test-value-2")).when(leafSetEntry2).name();
+ doReturn("test-value-2").when(leafSetEntry2).body();
+ nnWriter.write(leafSetEntry2);
}
}
""", streamWriter.result());
}
- private static NormalizedNode mockedPayload() {
- final ContainerNode containerNode = mock(ContainerNode.class);
- final LeafNode<?> leafNode = mock(LeafNode.class);
-
+ private ContainerNode mockedPayload() {
doReturn(new NodeIdentifier(QName.create("test", "payload-container"))).when(containerNode).name();
doReturn(Set.of(leafNode)).when(containerNode).body();
doReturn(new NodeIdentifier(QName.create("test", "payload-leaf"))).when(leafNode).name();
doReturn("leaf-value").when(leafNode).body();
-
+ doReturn(1).when(containerNode).size();
return containerNode;
}
}
Code Review / yangtools.git / commitdiff