import org.opendaylight.yangtools.yang.data.tree.api.DataTree;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModificationCursor;
import org.opendaylight.yangtools.yang.data.tree.api.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.tree.impl.di.InMemoryDataTreeFactory;
import org.openjdk.jmh.annotations.Benchmark;
@Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
public void write100KSingleNodeWithOneInnerItemInOneCommitCursorBenchmark() throws DataValidationFailedException {
final CursorAwareDataTreeModification modification = begin();
- try (DataTreeModificationCursor cursor = modification.openCursor(BenchmarkModel.OUTER_LIST_PATH).get()) {
+ try (var cursor = modification.openCursor(BenchmarkModel.OUTER_LIST_PATH).orElseThrow()) {
for (int outerListKey = 0; outerListKey < OUTER_LIST_100K; ++outerListKey) {
cursor.write(OUTER_LIST_IDS[outerListKey], OUTER_LIST_ONE_ITEM_INNER_LIST[outerListKey]);
}
@Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
public void write50KSingleNodeWithTwoInnerItemsInOneCommitCursorBenchmark() throws DataValidationFailedException {
final CursorAwareDataTreeModification modification = begin();
- try (DataTreeModificationCursor cursor = modification.openCursor(BenchmarkModel.OUTER_LIST_PATH).get()) {
+ try (var cursor = modification.openCursor(BenchmarkModel.OUTER_LIST_PATH).orElseThrow()) {
for (int outerListKey = 0; outerListKey < OUTER_LIST_50K; ++outerListKey) {
cursor.write(OUTER_LIST_IDS[outerListKey], OUTER_LIST_TWO_ITEM_INNER_LIST[outerListKey]);
}
@Measurement(iterations = MEASUREMENT_ITERATIONS, timeUnit = TimeUnit.MILLISECONDS)
public void write10KSingleNodeWithTenInnerItemsInOneCommitCursorBenchmark() throws DataValidationFailedException {
final CursorAwareDataTreeModification modification = begin();
- try (DataTreeModificationCursor cursor = modification.openCursor(BenchmarkModel.OUTER_LIST_PATH).get()) {
+ try (var cursor = modification.openCursor(BenchmarkModel.OUTER_LIST_PATH).orElseThrow()) {
for (int outerListKey = 0; outerListKey < OUTER_LIST_10K; ++outerListKey) {
cursor.write(OUTER_LIST_IDS[outerListKey], OUTER_LIST_TEN_ITEM_INNER_LIST[outerListKey]);
}
encodeString(module.getNamespace().toString());
final Optional<Revision> rev = module.getRevision();
if (rev.isPresent()) {
- encodeString(rev.get().toString());
+ encodeString(rev.orElseThrow().toString());
} else {
output.writeByte(MagnesiumValue.STRING_EMPTY);
}
case UNMODIFIED -> out.writeByte(UNMODIFIED);
case WRITE -> {
out.writeByte(WRITE);
- out.writeNormalizedNode(node.getDataAfter().get());
+ out.writeNormalizedNode(node.getDataAfter().orElseThrow());
}
default -> throw unhandledNodeType(node);
}
}
case WRITE -> {
out.writeByte(WRITE);
- out.writeNormalizedNode(node.getDataAfter().get());
+ out.writeNormalizedNode(node.getDataAfter().orElseThrow());
}
case UNMODIFIED -> {
out.writeByte(UNMODIFIED);
StreamResult xmlOutput = new StreamResult(new StringWriter());
Transformer transformer = TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
- transformer.transform(((DOMSourceAnyxmlNode)child.get()).body(), xmlOutput);
+ transformer.transform(((DOMSourceAnyxmlNode)child.orElseThrow()).body(), xmlOutput);
assertEquals("XML", xml, xmlOutput.getWriter().toString());
assertEquals("http://www.w3.org/TR/html4/",
- ((DOMSourceAnyxmlNode)child.get()).body().getNode().getNamespaceURI());
+ ((DOMSourceAnyxmlNode)child.orElseThrow()).body().getNode().getNamespaceURI());
}
@Test
static final LeafNode<?> INT64_DATA = ImmutableNodes.leafNode(INT64, 2L);
static final LeafNode<?> UINT64_DATA = ImmutableNodes.leafNode(UINT64, Uint64.ONE);
- static final String UNQUOTED_DECIMAL = "{\n"
- + " \"yt1027:decimal\": 1.1\n"
- + "}";
- static final String UNQUOTED_INT64 = "{\n"
- + " \"yt1027:int64\": 2\n"
- + "}";
- static final String UNQUOTED_UINT64 = "{\n"
- + " \"yt1027:uint64\": 1\n"
- + "}";
+ static final String UNQUOTED_DECIMAL = """
+ {
+ "yt1027:decimal": 1.1
+ }""";
+ static final String UNQUOTED_INT64 = """
+ {
+ "yt1027:int64": 2
+ }""";
+ static final String UNQUOTED_UINT64 = """
+ {
+ "yt1027:uint64": 1
+ }""";
static EffectiveModelContext SCHEMA_CONTEXT;
private static DecimalTypeDefinition DECIMAL_TYPE;
}
private static TypeDefinition<?> getTypeDefinition(final QName name) {
- DataSchemaNode child = SCHEMA_CONTEXT.findDataTreeChild(name).get();
+ DataSchemaNode child = SCHEMA_CONTEXT.findDataTreeChild(name).orElseThrow();
verify(child instanceof LeafSchemaNode);
return ((LeafSchemaNode) child).getType();
}
}
private static JSONCodec<YangInstanceIdentifier> getCodec(final JSONCodecFactorySupplier supplier) {
- final DataSchemaNode top = FULL_SCHEMA_CONTEXT.findDataChildByName(TOP_QNAME).get();
+ final DataSchemaNode top = FULL_SCHEMA_CONTEXT.getDataChildByName(TOP_QNAME);
assertTrue(top instanceof ContainerSchemaNode);
- final DataSchemaNode foo = ((ContainerSchemaNode) top).findDataChildByName(FOO_QNAME).get();
+ final DataSchemaNode foo = ((ContainerSchemaNode) top).getDataChildByName(FOO_QNAME);
assertTrue(foo instanceof LeafSchemaNode);
final TypeDefinition<? extends TypeDefinition<?>> type = ((LeafSchemaNode) foo).getType();
assertTrue(type instanceof InstanceIdentifierTypeDefinition);
import static java.util.Objects.requireNonNull;
import java.io.IOException;
-import java.util.Optional;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.dom.DOMSource;
final NormalizedNodeStreamWriterStack tracker) {
super(writer);
this.tracker = requireNonNull(tracker);
- this.streamUtils = new SchemaAwareXMLStreamWriterUtils(context);
+ streamUtils = new SchemaAwareXMLStreamWriterUtils(context);
}
@Override
@Override
String encodeAnnotationValue(final ValueWriter xmlWriter, final QName qname, final Object value)
throws XMLStreamException {
- final Optional<AnnotationSchemaNode> optAnnotation =
- AnnotationSchemaNode.find(streamUtils.getEffectiveModelContext(), qname);
+ final var optAnnotation = AnnotationSchemaNode.find(streamUtils.getEffectiveModelContext(), qname);
if (optAnnotation.isPresent()) {
- return streamUtils.encodeValue(xmlWriter, resolveType(optAnnotation.get().getType()), value,
+ return streamUtils.encodeValue(xmlWriter, resolveType(optAnnotation.orElseThrow().getType()), value,
qname.getModule());
}
// Cross-relate attribute namespace to the module
final Optional<QNameModule> optModule = resolveXmlNamespace(attributeNS);
if (optModule.isPresent()) {
- final QName qname = QName.create(optModule.get(), localName);
- final Optional<AnnotationSchemaNode> optAnnotation = AnnotationSchemaNode.find(
- codecs.getEffectiveModelContext(), qname);
+ final QName qname = QName.create(optModule.orElseThrow(), localName);
+ final var optAnnotation = AnnotationSchemaNode.find(codecs.getEffectiveModelContext(), qname);
if (optAnnotation.isPresent()) {
- final AnnotationSchemaNode schema = optAnnotation.get();
+ final AnnotationSchemaNode schema = optAnnotation.orElseThrow();
final Object value = codecs.codecFor(schema, stack)
.parseValue(in.getNamespaceContext(), attrValue);
attributes.put(schema.getQName(), value);
}
if (optMount.isPresent()) {
- final MountPointIdentifier mountId = MountPointIdentifier.of(optMount.get().getQName());
+ final var mountId = MountPointIdentifier.of(optMount.orElseThrow().getQName());
LOG.debug("Assuming node {} and namespace {} belongs to mount point {}", xmlElementName,
nsUri, mountId);
.findMountPoint(mountId);
if (optFactory.isPresent()) {
final MountPointData mountData =
- mountParent.getMountPointData(mountId, optFactory.get());
+ mountParent.getMountPointData(mountId, optFactory.orElseThrow());
addMountPointChild(mountData, nsUri, xmlElementName,
new DOMSource(readAnyXmlValue(in).getDocumentElement()));
continue;
final String localName, final DOMSource source) {
final DOMSourceMountPointChild child = new DOMSourceMountPointChild(source);
if (YangLibraryConstants.MODULE_NAMESPACE.equals(namespace)) {
- final Optional<ContainerName> optName = ContainerName.forLocalName(localName);
+ final var optName = ContainerName.forLocalName(localName);
if (optName.isPresent()) {
- mount.setContainer(optName.get(), child);
+ mount.setContainer(optName.orElseThrow(), child);
return;
}
}
public final T getFirst() {
- return tryFirst().get();
+ return tryFirst().orElseThrow();
}
public final Optional<T> tryFirst() {
}
public final U getSecond() {
- return trySecond().get();
+ return trySecond().orElseThrow();
}
public final Optional<U> trySecond() {
final Either<Decimal64, CanonicalValueViolation> variant = SUPPORT.fromString(str);
final Optional<Decimal64> value = variant.tryFirst();
if (value.isPresent()) {
- return value.get();
+ return value.orElseThrow();
}
final Optional<String> message = variant.getSecond().getMessage();
- throw message.isPresent() ? new NumberFormatException(message.get()) : new NumberFormatException();
+ throw message.isPresent() ? new NumberFormatException(message.orElseThrow()) : new NumberFormatException();
}
/**
final StringBuilder sb = new StringBuilder().append('(').append(getNamespace());
final Optional<Revision> rev = getRevision();
if (rev.isPresent()) {
- sb.append("?revision=").append(rev.get());
+ sb.append("?revision=").append(rev.orElseThrow());
}
return sb.append(')').append(getLocalName()).toString();
}
*/
public static int compare(final @NonNull Optional<Revision> first, final @NonNull Optional<Revision> second) {
if (first.isPresent()) {
- return second.isPresent() ? first.get().compareTo(second.get()) : 1;
+ return second.isPresent() ? first.orElseThrow().compareTo(second.orElseThrow()) : 1;
}
return second.isPresent() ? -1 : 0;
}
default @NonNull QName createQName(final String prefix, final String localName) {
final Optional<QNameModule> namespace = findNamespaceForPrefix(prefix);
checkArgument(namespace.isPresent(), "Prefix %s is not bound", prefix);
- return QName.create(namespace.get(), localName);
+ return QName.create(namespace.orElseThrow(), localName);
}
}
final Optional<Revision> opt = Revision.ofNullable("2017-12-25");
assertTrue(opt.isPresent());
- assertEquals("2017-12-25", opt.get().toString());
+ assertEquals("2017-12-25", opt.orElseThrow().toString());
}
@Test
final NormalizedNode libData;
try {
- libData = entry.getValue().normalizeTo(optLibContext.get());
+ libData = entry.getValue().normalizeTo(optLibContext.orElseThrow());
} catch (IOException e) {
throw new YangParserException("Failed to interpret yang-library data", e);
}
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import java.util.Arrays;
-import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
public static Optional<NormalizedNode> findNode(final YangInstanceIdentifier rootPath,
final NormalizedNode rootNode, final YangInstanceIdentifier childPath) {
- final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
- return relativePath.isPresent() ? findNode(rootNode, relativePath.get()) : Optional.empty();
+ final var relativePath = childPath.relativeTo(rootPath);
+ return relativePath.isPresent() ? findNode(rootNode, relativePath.orElseThrow()) : Optional.empty();
}
public static Optional<NormalizedNode> findNode(final Optional<NormalizedNode> parent,
final Iterable<PathArgument> relativePath) {
- final Iterator<PathArgument> pathIterator = requireNonNull(relativePath, "Relative path must not be null")
- .iterator();
- Optional<NormalizedNode> currentNode = requireNonNull(parent, "Parent must not be null");
+ final var pathIterator = requireNonNull(relativePath, "Relative path must not be null").iterator();
+ var currentNode = requireNonNull(parent, "Parent must not be null");
while (currentNode.isPresent() && pathIterator.hasNext()) {
- currentNode = getDirectChild(currentNode.get(), pathIterator.next());
+ currentNode = getDirectChild(currentNode.orElseThrow(), pathIterator.next());
}
return currentNode;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Optional<NormalizedNode> getDirectChild(final NormalizedNode node,
final PathArgument pathArg) {
- if (node instanceof DataContainerNode) {
- return (Optional) ((DataContainerNode) node).findChildByArg(pathArg);
- } else if (node instanceof MapNode && pathArg instanceof NodeIdentifierWithPredicates) {
- return (Optional) ((MapNode) node).findChildByArg((NodeIdentifierWithPredicates) pathArg);
- } else if (node instanceof LeafSetNode && pathArg instanceof NodeWithValue) {
- return (Optional) ((LeafSetNode<?>) node).findChildByArg((NodeWithValue<?>) pathArg);
+ if (node instanceof DataContainerNode dataContainer) {
+ return (Optional) dataContainer.findChildByArg(pathArg);
+ } else if (node instanceof MapNode map && pathArg instanceof NodeIdentifierWithPredicates nip) {
+ return (Optional) map.findChildByArg(nip);
+ } else if (node instanceof LeafSetNode<?> leafSet && pathArg instanceof NodeWithValue<?> nwv) {
+ return (Optional) leafSet.findChildByArg(nwv);
}
// Anything else, including ValueNode
return Optional.empty();
private static void toStringTree(final StringBuilder sb, final NormalizedNode node, final int offset) {
final String prefix = " ".repeat(offset);
appendPathArgument(sb.append(prefix), node.getIdentifier());
- if (node instanceof NormalizedNodeContainer) {
+ if (node instanceof NormalizedNodeContainer<?> container) {
sb.append(" {\n");
- for (NormalizedNode child : ((NormalizedNodeContainer<?>) node).body()) {
+ for (var child : container.body()) {
toStringTree(sb, child, offset + STRINGTREE_INDENT);
}
sb.append(prefix).append('}');
}
private static void appendPathArgument(final StringBuilder sb, final PathArgument arg) {
- if (arg instanceof NodeIdentifierWithPredicates) {
- sb.append(arg.getNodeType().getLocalName()).append(((NodeIdentifierWithPredicates) arg).values());
+ if (arg instanceof NodeIdentifierWithPredicates nip) {
+ sb.append(arg.getNodeType().getLocalName()).append(nip.values());
} else if (arg instanceof AugmentationIdentifier) {
sb.append("augmentation");
} else {
Optional<YangInstanceIdentifier> relative = id1.relativeTo(id2);
assertTrue(relative.isPresent());
- List<PathArgument> path = relative.get().getPathArguments();
+ List<PathArgument> path = relative.orElseThrow().getPathArguments();
assertEquals(2, path.size());
assertEquals(NODENAME3, path.get(0).getNodeType());
assertEquals(NODENAME4, path.get(1).getNodeType());
relative = id2.relativeTo(id3);
assertTrue(relative.isPresent());
- assertEquals(0, relative.get().getPathArguments().size());
+ assertEquals(0, relative.orElseThrow().getPathArguments().size());
relative = id2.relativeTo(id1);
assertFalse(relative.isPresent());
public class NormalizedNodesTest {
@Test
public void testGetDirectChild() {
- final PathArgument mockedPathArgument = mock(PathArgument.class);
+ final var mockedPathArgument = mock(PathArgument.class);
- final LeafNode<?> mockedLeafNode = mock(LeafNode.class);
+ final var mockedLeafNode = mock(LeafNode.class);
assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafNode, mockedPathArgument));
- final LeafSetEntryNode<?> mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
+ final var mockedLeafSetEntryNode = mock(LeafSetEntryNode.class);
assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedLeafSetEntryNode, mockedPathArgument));
- final DataContainerNode mockedDataContainerNode = mock(DataContainerNode.class);
- final ContainerNode mockedContainerNode = mock(ContainerNode.class);
+ final var mockedDataContainerNode = mock(DataContainerNode.class);
+ final var mockedContainerNode = mock(ContainerNode.class);
doReturn(mockedContainerNode).when(mockedDataContainerNode).childByArg(any(PathArgument.class));
doCallRealMethod().when(mockedDataContainerNode).findChildByArg(any(PathArgument.class));
- assertEquals(mockedContainerNode, NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument)
- .get());
+ assertEquals(Optional.of(mockedContainerNode),
+ NormalizedNodes.getDirectChild(mockedDataContainerNode, mockedPathArgument));
- final SystemMapNode mockedMapNode = mock(SystemMapNode.class);
+ final var mockedMapNode = mock(SystemMapNode.class);
final QName listQName = QName.create("test-ns", "test-list");
final QName listKeyQName = QName.create("test-ns", "test-list-key");
- final NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
- NodeIdentifierWithPredicates.of(listQName, listKeyQName, "str-value");
- final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
+ final var nodeIdentifierWithPredicates = NodeIdentifierWithPredicates.of(listQName, listKeyQName, "str-value");
+ final var mockedMapEntryNode = mock(MapEntryNode.class);
doReturn(mockedMapEntryNode).when(mockedMapNode).childByArg(any(NodeIdentifierWithPredicates.class));
doCallRealMethod().when(mockedMapNode).findChildByArg(any(NodeIdentifierWithPredicates.class));
- assertEquals(mockedMapEntryNode, NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates)
- .get());
+ assertEquals(Optional.of(mockedMapEntryNode),
+ NormalizedNodes.getDirectChild(mockedMapNode, nodeIdentifierWithPredicates));
assertEquals(Optional.empty(), NormalizedNodes.getDirectChild(mockedMapNode, mockedPathArgument));
final SystemLeafSetNode<?> mockedLeafSetNode = mock(SystemLeafSetNode.class);
final NodeWithValue<?> nodeWithValue = new NodeWithValue<>(leafListQName, "str-value");
doReturn(mockedLeafSetEntryNode).when(mockedLeafSetNode).childByArg(any(NodeWithValue.class));
doCallRealMethod().when(mockedLeafSetNode).findChildByArg(any(NodeWithValue.class));
- assertEquals(mockedLeafSetEntryNode, NormalizedNodes.getDirectChild(mockedLeafSetNode, nodeWithValue).get());
+ assertEquals(Optional.of(mockedLeafSetEntryNode),
+ NormalizedNodes.getDirectChild(mockedLeafSetNode, nodeWithValue));
}
@Test
final YangInstanceIdentifier childPath = YangInstanceIdentifier.create(new NodeIdentifier(node1QName),
new NodeIdentifier(node2Qname), new NodeIdentifier(node3QName), new NodeIdentifier(node4Qname));
- assertEquals(mockedLeafNode, NormalizedNodes.findNode(rootPath, mockedDataContainerNode, childPath).get());
+ assertEquals(Optional.of(mockedLeafNode),
+ NormalizedNodes.findNode(rootPath, mockedDataContainerNode, childPath));
assertEquals(Optional.empty(), NormalizedNodes.findNode(childPath, mockedDataContainerNode, rootPath));
- final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
- final PathArgument[] pathArguments = relativePath.get().getPathArguments().toArray(new PathArgument[2]);
+ final var pathArguments = childPath.relativeTo(rootPath).orElseThrow().getPathArguments()
+ .toArray(new PathArgument[0]);
- assertEquals(mockedLeafNode, NormalizedNodes.findNode(Optional.of(mockedDataContainerNode),
- pathArguments).get());
+ assertEquals(Optional.of(mockedLeafNode),
+ NormalizedNodes.findNode(Optional.of(mockedDataContainerNode), pathArguments));
- assertEquals(mockedLeafNode, NormalizedNodes.findNode(mockedDataContainerNode, pathArguments).get());
+ assertEquals(Optional.of(mockedLeafNode), NormalizedNodes.findNode(mockedDataContainerNode, pathArguments));
}
@Test
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThrows;
import static org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodecTestHelper.getCodec;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.codec.StringCodec;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
public class StringPatternCheckingCodecTest {
-
- private static final Logger LOG = LoggerFactory.getLogger(StringPatternCheckingCodecTest.class);
-
@Test
public void testStringPatternCheckingCodec() {
- final SchemaContext schemaContext = YangParserTestUtils.parseYangResource(
- "/string-pattern-checking-codec-test.yang");
+ final var schemaContext = YangParserTestUtils.parseYangResource("/string-pattern-checking-codec-test.yang");
assertNotNull(schemaContext);
- final QNameModule testModuleQName = QNameModule.create(XMLNamespace.of("string-pattern-checking-codec-test"));
+ final var testModuleQName = QNameModule.create(XMLNamespace.of("string-pattern-checking-codec-test"));
- final Module testModule = schemaContext.findModules("string-pattern-checking-codec-test").iterator().next();
- final ContainerSchemaNode testContainer = (ContainerSchemaNode) testModule.findDataChildByName(
- QName.create(testModuleQName, "test-container")).get();
+ final var testModule = schemaContext.findModules("string-pattern-checking-codec-test").iterator().next();
+ final var testContainer = (ContainerSchemaNode) testModule.getDataChildByName(
+ QName.create(testModuleQName, "test-container"));
- final LeafSchemaNode testLeaf = (LeafSchemaNode) testContainer.findDataChildByName(
- QName.create(testModuleQName, "string-leaf-with-valid-pattern")).get();
+ final var testLeaf = (LeafSchemaNode) testContainer.getDataChildByName(
+ QName.create(testModuleQName, "string-leaf-with-valid-pattern"));
- final StringCodec<String> codec = getCodec(testLeaf.getType(), StringCodec.class);
+ final var codec = getCodec(testLeaf.getType(), StringCodec.class);
assertNotNull(codec);
assertEquals("ABCD", codec.serialize("ABCD"));
assertEquals("ABCD", codec.deserialize("ABCD"));
- try {
- codec.deserialize("abcd");
- fail("Exception should have been thrown.");
- } catch (final IllegalArgumentException ex) {
- LOG.debug("IllegalArgumentException was thrown as expected", ex);
- assertEquals("Value 'abcd' does not match regular expression '[A-Z]+'", ex.getMessage());
- }
+ final var ex = assertThrows(IllegalArgumentException.class, () -> codec.deserialize("abcd"));
+ assertEquals("Value 'abcd' does not match regular expression '[A-Z]+'", ex.getMessage());
}
}
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class BuilderTest {
public void setup() throws URISyntaxException {
final File leafRefTestYang = new File(getClass().getResource("/builder-test/immutable-ordered-map-node.yang")
.toURI());
- final SchemaContext schema = YangParserTestUtils.parseYangFiles(leafRefTestYang);
+ final var schema = YangParserTestUtils.parseYangFiles(leafRefTestYang);
final Module module = schema.getModules().iterator().next();
- final DataSchemaNode root = module.findDataChildByName(ROOT_CONTAINER).get();
- list = (ListSchemaNode)((ContainerSchemaNode) root).findDataChildByName(LIST_MAIN).get();
- leafList = (LeafListSchemaNode)((ContainerSchemaNode) root).findDataChildByName(LEAF_LIST_MAIN).get();
+ final DataSchemaNode root = module.getDataChildByName(ROOT_CONTAINER);
+ list = (ListSchemaNode)((ContainerSchemaNode) root).getDataChildByName(LIST_MAIN);
+ leafList = (LeafListSchemaNode)((ContainerSchemaNode) root).getDataChildByName(LEAF_LIST_MAIN);
}
@Test
*/
@Override
default DataTreeModificationCursor openCursor() {
- return openCursor(YangInstanceIdentifier.empty()).get();
+ return openCursor(YangInstanceIdentifier.empty()).orElseThrow();
}
}
* @throws IllegalStateException if there is another cursor currently open.
*/
default DataTreeSnapshotCursor openCursor() {
- return openCursor(YangInstanceIdentifier.empty()).get();
+ return openCursor(YangInstanceIdentifier.empty()).orElseThrow();
}
@Override
return new NoopDataTreeCandidate(YangInstanceIdentifier.empty(), root, currentRoot);
}
- final Optional<? extends TreeNode> newRoot = m.getStrategy().apply(m.getRootModification(),
- Optional.of(currentRoot), m.getVersion());
+ 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.get());
+ return new InMemoryDataTreeCandidate(YangInstanceIdentifier.empty(), root, currentRoot, newRoot.orElseThrow());
}
private static InMemoryDataTreeModification checkedCast(final DataTreeModification mod) {
AbstractNodeContainerModificationStrategy(final NormalizedNodeContainerSupport<?, ?> support,
final DataTreeConfiguration treeConfig) {
this.support = requireNonNull(support);
- this.verifyChildrenStructure = treeConfig.getTreeType() == TreeType.CONFIGURATION;
+ verifyChildrenStructure = treeConfig.getTreeType() == TreeType.CONFIGURATION;
}
@Override
final Optional<? extends TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
if (result.isPresent()) {
- final TreeNode tn = result.get();
+ final TreeNode tn = result.orElseThrow();
meta.putChild(tn);
data.addChild(tn.getData());
} else {
final Optional<? extends TreeNode> current = apply(modification, modification.getOriginal(),
Version.initial());
if (current.isPresent()) {
- modification.updateValue(LogicalOperation.WRITE, current.get().getData());
+ modification.updateValue(LogicalOperation.WRITE, current.orElseThrow().getData());
mergeChildrenIntoModification(modification, children, version);
return;
}
"Node was deleted by other transaction.");
}
} else {
- currentNode = current.get();
+ currentNode = current.orElseThrow();
}
checkChildPreconditions(path, modification, currentNode, version);
protected final void checkMergeApplicable(final ModificationPath path, final NodeModification modification,
final Optional<? extends TreeNode> current, final Version version) throws DataValidationFailedException {
if (current.isPresent()) {
- checkChildPreconditions(path, modification, current.get(), version);
+ checkChildPreconditions(path, modification, current.orElseThrow(), version);
}
}
ret = delegate.apply(modification, storeMeta, version);
}
- return ret.isPresent() ? disappearResult(modification, ret.get(), storeMeta) : ret;
+ return ret.isPresent() ? disappearResult(modification, ret.orElseThrow(), storeMeta) : ret;
}
private static Optional<? extends TreeNode> applyTouch(final Apply delegate, final NormalizedNode emptyNode,
}
final ImmutableMap<AugmentationIdentifier, AugmentationSchemaNode> augmentations = augmentationsBuilder.build();
final Optional<MandatoryLeafEnforcer> enforcer = MandatoryLeafEnforcer.forContainer(schema, treeConfig);
- return enforcer.isPresent() ? new EnforcingMandatory(children, augmentations, enforcer.get())
+ return enforcer.isPresent() ? new EnforcingMandatory(children, augmentations, enforcer.orElseThrow())
: new CaseEnforcer(children, augmentations);
}
static ModificationApplyOperation of(final ContainerSchemaNode schema, final DataTreeConfiguration treeConfig) {
if (schema.isPresenceContainer()) {
- final Optional<MandatoryLeafEnforcer> enforcer = MandatoryLeafEnforcer.forContainer(schema, treeConfig);
- return enforcer.isPresent() ? new EnforcingMandatory(schema, treeConfig, enforcer.get())
+ final var enforcer = MandatoryLeafEnforcer.forContainer(schema, treeConfig);
+ return enforcer.isPresent() ? new EnforcingMandatory(schema, treeConfig, enforcer.orElseThrow())
: new ContainerModificationStrategy(schema, treeConfig);
}
return;
}
- final DataSchemaNode rootSchemaNode = rootContextNode.get().getDataSchemaNode();
+ final DataSchemaNode rootSchemaNode = rootContextNode.orElseThrow().getDataSchemaNode();
if (!(rootSchemaNode instanceof DataNodeContainer)) {
LOG.warn("Root {} resolves to non-container type {}, not upgrading", getRootPath(), rootSchemaNode);
return;
if (candidate instanceof NoopDataTreeCandidate) {
return;
}
- if (!(candidate instanceof InMemoryDataTreeCandidate)) {
+ if (!(candidate instanceof InMemoryDataTreeCandidate c)) {
throw new IllegalArgumentException("Invalid candidate class " + candidate.getClass());
}
- final InMemoryDataTreeCandidate c = (InMemoryDataTreeCandidate)candidate;
if (LOG.isTraceEnabled()) {
LOG.trace("Data Tree is {}", NormalizedNodes.toStringTree(c.getTipRoot().getData()));
}
InMemoryDataTreeModification(final InMemoryDataTreeSnapshot snapshot,
final RootApplyStrategy resolver) {
this.snapshot = requireNonNull(snapshot);
- this.strategyTree = requireNonNull(resolver).snapshot();
- this.rootNode = ModifiedNode.createUnmodified(snapshot.getRootNode(), getStrategy().getChildPolicy());
+ strategyTree = requireNonNull(resolver).snapshot();
+ rootNode = ModifiedNode.createUnmodified(snapshot.getRootNode(), getStrategy().getChildPolicy());
/*
* We could allocate version beforehand, since Version contract
* node in modification and in data tree (if successfully
* committed) will be same and will not change.
*/
- this.version = snapshot.getRootNode().getSubtreeVersion().next();
+ version = snapshot.getRootNode().getSubtreeVersion().next();
}
ModifiedNode getRootModification() {
final Optional<? extends TreeNode> result = resolveSnapshot(key, mod);
if (result.isPresent()) {
- final NormalizedNode data = result.get().getData();
+ final NormalizedNode data = result.orElseThrow().getData();
return NormalizedNodes.findNode(key, data, path);
}
checkState(tempRoot.isPresent(), "Data tree root is not present, possibly removed by previous modification");
final InMemoryDataTreeSnapshot tempTree = new InMemoryDataTreeSnapshot(snapshot.getEffectiveModelContext(),
- tempRoot.get(), strategyTree);
+ tempRoot.orElseThrow(), strategyTree);
return tempTree.newModification();
}
final Optional<NormalizedNode> maybeChildNode = NormalizedNodes.getDirectChild(stack.peek(), child);
checkArgument(maybeChildNode.isPresent(), "Child %s not found", child);
- final NormalizedNode childNode = maybeChildNode.get();
+ final NormalizedNode childNode = maybeChildNode.orElseThrow();
checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", child);
stack.push((DistinctNodeContainer<?, ?>) childNode);
}
final Optional<NormalizedNode> maybeChildNode = NormalizedNodes.findNode(stack.peek(), path);
checkArgument(maybeChildNode.isPresent(), "Child %s not found", path);
- final NormalizedNode childNode = maybeChildNode.get();
+ final NormalizedNode childNode = maybeChildNode.orElseThrow();
checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", path);
int depth = 0;
final Optional<? extends TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
if (result.isPresent()) {
- final TreeNode tn = result.get();
+ final TreeNode tn = result.orElseThrow();
meta.putChild(tn);
data.addChild(tn.getData());
} else {
static @NonNull MapEntryModificationStrategy of(final ListSchemaNode schema,
final DataTreeConfiguration treeConfig) {
- final Optional<MandatoryLeafEnforcer> enforcer = MandatoryLeafEnforcer.forContainer(schema, treeConfig);
- return enforcer.isPresent() ? new EnforcingMandatory(schema, treeConfig, enforcer.get())
+ final var enforcer = MandatoryLeafEnforcer.forContainer(schema, treeConfig);
+ return enforcer.isPresent() ? new EnforcingMandatory(schema, treeConfig, enforcer.orElseThrow())
: new MapEntryModificationStrategy(schema, treeConfig);
}
}
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.base.MoreObjects.ToStringHelper;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.tree.api.RequiredElementCountException;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraintAware;
final class MinMaxElementsValidation<T extends DataSchemaNode & ElementCountConstraintAware>
static <T extends DataSchemaNode & ElementCountConstraintAware> ModificationApplyOperation from(
final SchemaAwareApplyOperation<T> delegate) {
- final Optional<ElementCountConstraint> optConstraint = delegate.getSchema().getElementCountConstraint();
- if (!optConstraint.isPresent()) {
+ final var optConstraint = delegate.getSchema().getElementCountConstraint();
+ if (optConstraint.isEmpty()) {
return delegate;
}
- final ElementCountConstraint constraint = optConstraint.get();
+ final var constraint = optConstraint.orElseThrow();
return new MinMaxElementsValidation<>(delegate, constraint.getMinElements(), constraint.getMaxElements());
}
}
private Optional<? extends TreeNode> metadataFromSnapshot(final @NonNull PathArgument child) {
- return original.isPresent() ? original.get().findChildByArg(child) : Optional.empty();
+ return original.isPresent() ? original.orElseThrow().findChildByArg(child) : Optional.empty();
}
private Optional<? extends TreeNode> metadataFromData(final @NonNull PathArgument child, final Version modVersion) {
private final ModifiedNode modification;
private OperationWithModification(final ModificationApplyOperation op, final ModifiedNode mod) {
- this.applyOperation = requireNonNull(op);
- this.modification = requireNonNull(mod);
+ applyOperation = requireNonNull(op);
+ modification = requireNonNull(mod);
}
void write(final NormalizedNode value) {
}
if (snapshot.isPresent()) {
- return snapshot.get().findChildByArg(child).map(TreeNode::getData);
+ return snapshot.orElseThrow().findChildByArg(child).map(TreeNode::getData);
}
return Optional.empty();
* it should not cause transaction to fail, since result of this merge
* leads to same data.
*/
- final TreeNode orig = original.get();
- final TreeNode cur = current.get();
+ final TreeNode orig = original.orElseThrow();
+ final TreeNode cur = current.orElseThrow();
if (!orig.getData().equals(cur.getData())) {
checkNotConflicting(path, orig, cur);
}
final Optional<? extends TreeNode> current, final Version version) throws DataValidationFailedException {
final Optional<? extends TreeNode> original = modification.getOriginal();
if (original.isPresent() && current.isPresent()) {
- checkNotConflicting(path, original.get(), current.get());
+ checkNotConflicting(path, original.orElseThrow(), current.orElseThrow());
} else {
checkConflicting(path, !original.isPresent(), "Node was deleted by other transaction.");
checkConflicting(path, !current.isPresent(), "Node was created by other transaction.");
result = applyWrite(modification, modification.getWrittenValue(), currentMeta, version);
fullVerifyStructure(result.getData());
} else {
- result = applyMerge(modification, currentMeta.get(), version);
+ result = applyMerge(modification, currentMeta.orElseThrow(), version);
}
yield modification.setSnapshot(Optional.of(result));
final Optional<DataSchemaContextNode<?>> rootContextNode = contextTree.findChild(rootPath);
checkArgument(rootContextNode.isPresent(), "Failed to find root %s in schema context", rootPath);
- final DataSchemaNode rootSchemaNode = rootContextNode.get().getDataSchemaNode();
+ final DataSchemaNode rootSchemaNode = rootContextNode.orElseThrow().getDataSchemaNode();
checkArgument(rootSchemaNode instanceof DataNodeContainer, "Root %s resolves to non-container type %s",
rootPath, rootSchemaNode);
return rootSchemaNode;
package org.opendaylight.yangtools.yang.data.tree.leafref;
import java.util.Objects;
-import java.util.Optional;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.Revision;
abstract class AbstractQNameWithPredicate implements Immutable, QNameWithPredicate {
@Override
public final boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (!(obj instanceof QNameWithPredicate)) {
- return false;
- }
- final QNameWithPredicate other = (QNameWithPredicate) obj;
- // FIXME: check also predicates ...
- return Objects.equals(getLocalName(), other.getLocalName())
- && Objects.equals(getModuleQname(), other.getModuleQname());
+ return this == obj || obj instanceof QNameWithPredicate other
+ // FIXME: check also predicates ...
+ && Objects.equals(getLocalName(), other.getLocalName())
+ && Objects.equals(getModuleQname(), other.getModuleQname());
}
@Override
final QNameModule moduleQname = getModuleQname();
if (moduleQname != null) {
sb.append('(').append(moduleQname.getNamespace());
- final Optional<Revision> rev = moduleQname.getRevision();
+ final var rev = moduleQname.getRevision();
if (rev.isPresent()) {
- sb.append("?revision=").append(rev.get());
+ sb.append("?revision=").append(rev.orElseThrow());
}
sb.append(')');
}
public static void validate(final DataTreeCandidate tree, final LeafRefContext rootLeafRefCtx)
throws LeafRefDataValidationFailedException {
- final Optional<NormalizedNode> root = tree.getRootNode().getDataAfter();
+ final var root = tree.getRootNode().getDataAfter();
if (root.isPresent()) {
- new LeafRefValidation(root.get()).validateChildren(rootLeafRefCtx, tree.getRootNode().getChildNodes());
+ new LeafRefValidation(root.orElseThrow())
+ .validateChildren(rootLeafRefCtx, tree.getRootNode().getChildNodes());
}
}
private void validateChildren(final LeafRefContext rootLeafRefCtx, final Collection<DataTreeCandidateNode> children)
throws LeafRefDataValidationFailedException {
- for (final DataTreeCandidateNode dataTreeCandidateNode : children) {
+ for (var dataTreeCandidateNode : children) {
if (dataTreeCandidateNode.getModificationType() != ModificationType.UNMODIFIED) {
final PathArgument identifier = dataTreeCandidateNode.getIdentifier();
final QName childQName = identifier.getNodeType();
if (!errorsMessages.isEmpty()) {
final StringBuilder message = new StringBuilder();
int errCount = 0;
- for (final String errorMessage : errorsMessages) {
+ for (var errorMessage : errorsMessages) {
message.append(errorMessage);
errCount++;
}
final LeafRefContext referencingCtx, final YangInstanceIdentifier current) {
if (node.getModificationType() == ModificationType.WRITE && node.getDataAfter().isPresent()) {
- validateNodeData(node.getDataAfter().get(), referencedByCtx, referencingCtx, node.getModificationType(),
- current);
+ validateNodeData(node.getDataAfter().orElseThrow(), referencedByCtx, referencingCtx,
+ node.getModificationType(), current);
return;
}
if (node.getModificationType() == ModificationType.DELETE && referencedByCtx != null) {
- validateNodeData(node.getDataBefore().get(), referencedByCtx, null, node.getModificationType(), current);
+ validateNodeData(node.getDataBefore().orElseThrow(), referencedByCtx, null, node.getModificationType(),
+ current);
return;
}
- for (final DataTreeCandidateNode childNode : node.getChildNodes()) {
+ for (var childNode : node.getChildNodes()) {
if (childNode.getModificationType() != ModificationType.UNMODIFIED) {
final LeafRefContext childReferencedByCtx = getReferencedByCtxChild(referencedByCtx, childNode);
final LeafRefContext childReferencingCtx = getReferencingCtxChild(referencingCtx, childNode);
final QName childQName = childNode.getIdentifier().getNodeType();
LeafRefContext childReferencingCtx = referencingCtx.getReferencingChildByName(childQName);
if (childReferencingCtx == null) {
- final NormalizedNode data = childNode.getDataAfter().get();
+ final NormalizedNode data = childNode.getDataAfter().orElseThrow();
if (data instanceof MapEntryNode || data instanceof UnkeyedListEntryNode) {
childReferencingCtx = referencingCtx;
}
final QName childQName = childNode.getIdentifier().getNodeType();
LeafRefContext childReferencedByCtx = referencedByCtx.getReferencedChildByName(childQName);
if (childReferencedByCtx == null) {
- final NormalizedNode data = childNode.getDataAfter().get();
+ final NormalizedNode data = childNode.getDataAfter().orElseThrow();
if (data instanceof MapEntryNode || data instanceof UnkeyedListEntryNode) {
childReferencedByCtx = referencedByCtx;
}
while (pathIterator.hasNext()) {
final PathArgument childPathArgument = pathIterator.next();
if (pathIterator.hasNext() && currentNode.isPresent()) {
- currentNode = NormalizedNodes.getDirectChild(currentNode.get(), childPathArgument);
+ currentNode = NormalizedNodes.getDirectChild(currentNode.orElseThrow(), childPathArgument);
} else {
return currentNode;
}
final DataTreeModification modificationAfterTx = snapshotAfterTx.newModification();
final Optional<NormalizedNode> readNode = modificationAfterTx.readNode(TestModel.OUTER_LIST_PATH);
assertTrue(readNode.isPresent());
- assertEquals(2, ((NormalizedNodeContainer<?>)readNode.get()).size());
+ assertEquals(2, ((NormalizedNodeContainer<?>)readNode.orElseThrow()).size());
}
@Test
DataTreeSnapshot test2 = inMemoryDataTree.takeSnapshot();
minMaxListRead = test2.readNode(MIN_MAX_LIST_PATH);
assertTrue(minMaxListRead.isPresent());
- assertEquals(3, ((NormalizedNodeContainer<?>) minMaxListRead.get()).size());
+ assertEquals(3, ((NormalizedNodeContainer<?>) minMaxListRead.orElseThrow()).size());
DataTreeModification tempMod2 = test2.newModification();
tempMod2.write(MIN_MAX_LIST_PATH, mapNodeBaz);
DataTreeSnapshot test3 = inMemoryDataTree.takeSnapshot();
minMaxListRead = test3.readNode(MIN_MAX_LIST_PATH);
assertTrue(minMaxListRead.isPresent());
- assertEquals(1, ((NormalizedNodeContainer<?>) minMaxListRead.get()).size());
- assertThat(minMaxListRead.get().body().toString(), containsString("test2"));
+ assertEquals(1, ((NormalizedNodeContainer<?>) minMaxListRead.orElseThrow()).size());
+ assertThat(minMaxListRead.orElseThrow().body().toString(), containsString("test2"));
DataTreeModification tempMod3 = test3.newModification();
tempMod3.merge(MIN_MAX_LIST_PATH, mapNodeBar);
final DataTreeSnapshot snapshotAfterCommit = inMemoryDataTree.takeSnapshot();
final Optional<NormalizedNode> masterContainer = snapshotAfterCommit.readNode(MASTER_CONTAINER_PATH);
assertTrue(masterContainer.isPresent());
- final Optional<NormalizedNodeContainer<?>> leafList = ((DistinctNodeContainer) masterContainer.get())
+ final Optional<NormalizedNodeContainer<?>> leafList = ((DistinctNodeContainer) masterContainer.orElseThrow())
.findChildByArg(new NodeIdentifier(MIN_MAX_LEAF_LIST_QNAME));
assertTrue(leafList.isPresent());
- assertEquals(3, leafList.get().size());
+ assertEquals(3, leafList.orElseThrow().size());
}
@Test
// Empty list should have disappeared, along with the container, as we are not enforcing root
final NormalizedNode data = inMemoryDataTree.takeSnapshot()
- .readNode(YangInstanceIdentifier.empty()).get();
+ .readNode(YangInstanceIdentifier.empty()).orElseThrow();
assertTrue(data instanceof ContainerNode);
assertEquals(0, ((ContainerNode) data).size());
}
modificationTree.ready();
fail("Should have failed with IAE");
} catch (IllegalArgumentException e) {
- assertEquals("Node (urn:opendaylight:params:xml:ns:yang:list-constraints-validation-test-model?"
- + "revision=2015-02-02)presence is missing mandatory descendant "
- + "/(urn:opendaylight:params:xml:ns:yang:list-constraints-validation-test-model?"
- + "revision=2015-02-02)min-max-list", e.getMessage());
+ assertEquals("""
+ Node (urn:opendaylight:params:xml:ns:yang:list-constraints-validation-test-model?revision=2015-02-02)\
+ presence is missing mandatory descendant /(urn:opendaylight:params:xml:ns:yang:list-constraints-\
+ validation-test-model?revision=2015-02-02)min-max-list""", e.getMessage());
}
}
private static void testLoop(final DataTreeSnapshot snapshot, final String first, final String second) {
Optional<NormalizedNode> minMaxListRead = snapshot.readNode(MIN_MAX_LIST_PATH);
assertTrue(minMaxListRead.isPresent());
- assertEquals(2, ((NormalizedNodeContainer<?>) minMaxListRead.get()).size());
+ assertEquals(2, ((NormalizedNodeContainer<?>) minMaxListRead.orElseThrow()).size());
- for (Object collectionChild : (Collection<?>) minMaxListRead.get().body()) {
+ for (Object collectionChild : (Collection<?>) minMaxListRead.orElseThrow().body()) {
if (collectionChild.toString().contains(first)) {
assertTrue(collectionChild.toString().contains(first));
} else {
private static <T> T assertPresentAndType(final Optional<?> potential, final Class<T> type) {
assertNotNull(potential);
assertTrue(potential.isPresent());
- assertTrue(type.isInstance(potential.get()));
- return type.cast(potential.get());
+ assertTrue(type.isInstance(potential.orElseThrow()));
+ return type.cast(potential.orElseThrow());
}
@Test
DataTreeCandidates.applyToModification(newModification,
newCandidate);
- final LeafNode<?> readLeaf = (LeafNode<?>) newModification.readNode(TestModel.INNER_VALUE_PATH).get();
+ final LeafNode<?> readLeaf = (LeafNode<?>) newModification.readNode(TestModel.INNER_VALUE_PATH).orElseThrow();
assertEquals(readLeaf, leaf);
}
final DataTreeSnapshot snapshotAfterCommit = inMemoryDataTree.takeSnapshot();
final Optional<NormalizedNode> minMaxListRead = snapshotAfterCommit.readNode(MIN_MAX_LIST_PATH);
assertTrue(minMaxListRead.isPresent());
- assertEquals(2, ((NormalizedNodeContainer<?>) minMaxListRead.get()).size());
+ assertEquals(2, ((NormalizedNodeContainer<?>) minMaxListRead.orElseThrow()).size());
}
@Test(expected = DataValidationFailedException.class)
DataTreeSnapshot snapshotAfterCommit = inMemoryDataTree.takeSnapshot();
Optional<NormalizedNode> minMaxListRead = snapshotAfterCommit.readNode(MIN_MAX_LIST_PATH);
assertTrue(minMaxListRead.isPresent());
- assertEquals(2, ((NormalizedNodeContainer<?>) minMaxListRead.get()).size());
+ assertEquals(2, ((NormalizedNodeContainer<?>) minMaxListRead.orElseThrow()).size());
modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(gooPath, gooEntryNode);
snapshotAfterCommit = inMemoryDataTree.takeSnapshot();
minMaxListRead = snapshotAfterCommit.readNode(MIN_MAX_LIST_PATH);
assertTrue(minMaxListRead.isPresent());
- assertEquals(3, ((NormalizedNodeContainer<?>) minMaxListRead.get()).size());
+ assertEquals(3, ((NormalizedNodeContainer<?>) minMaxListRead.orElseThrow()).size());
modificationTree = inMemoryDataTree.takeSnapshot().newModification();
final Optional<NormalizedNode> masterContainer = snapshotAfterCommit.readNode(MASTER_CONTAINER_PATH);
assertTrue(masterContainer.isPresent());
final NormalizedNodeContainer<?> leafList =
- (NormalizedNodeContainer<?>) ((DistinctNodeContainer) masterContainer.get())
+ (NormalizedNodeContainer<?>) ((DistinctNodeContainer) masterContainer.orElseThrow())
.childByArg(new NodeIdentifier(MIN_MAX_LEAF_LIST_QNAME));
assertNotNull(leafList);
assertEquals(2, leafList.size());
final DataTreeSnapshot snapshotAfterCommit = inMemoryDataTree.takeSnapshot();
final Optional<NormalizedNode> unkeyedListRead = snapshotAfterCommit.readNode(UNKEYED_LIST_PATH);
assertTrue(unkeyedListRead.isPresent());
- assertEquals(1, ((UnkeyedListNode) unkeyedListRead.get()).size());
+ assertEquals(1, ((UnkeyedListNode) unkeyedListRead.orElseThrow()).size());
}
@Test
TreeNode.of(createDocumentOne(), Version.initial()), rootOper), rootOper);
final Optional<NormalizedNode> originalBarNode = modificationTree.readNode(OUTER_LIST_2_PATH);
assertTrue(originalBarNode.isPresent());
- assertSame(BAR_NODE, originalBarNode.get());
+ assertSame(BAR_NODE, originalBarNode.orElseThrow());
// writes node to /outer-list/1/inner_list/two/value
modificationTree.write(TWO_TWO_VALUE_PATH, ImmutableNodes.leafNode(TestModel.VALUE_QNAME, "test"));
// and checks if node is already present
final Optional<NormalizedNode> barTwoCModified = modificationTree.readNode(TWO_TWO_VALUE_PATH);
assertTrue(barTwoCModified.isPresent());
- assertEquals(ImmutableNodes.leafNode(TestModel.VALUE_QNAME, "test"), barTwoCModified.get());
+ assertEquals(ImmutableNodes.leafNode(TestModel.VALUE_QNAME, "test"), barTwoCModified.orElseThrow());
// delete node to /outer-list/1/inner_list/two/value
modificationTree.delete(TWO_TWO_VALUE_PATH);
private static <T> T assertPresentAndType(final Optional<?> potential, final Class<T> type) {
assertNotNull(potential);
assertTrue(potential.isPresent());
- assertTrue(type.isInstance(potential.get()));
- return type.cast(potential.get());
+ assertTrue(type.isInstance(potential.orElseThrow()));
+ return type.cast(potential.orElseThrow());
}
}
assertPresentAndType(expectedNode, TreeNode.class);
final Entry<YangInstanceIdentifier, TreeNode> actualNode = StoreTreeNodes.findClosest(rootNode, TWO_TWO_PATH);
- assertTreeNodeEquals(expectedNode.get(), actualNode.getValue());
+ assertTreeNodeEquals(expectedNode.orElseThrow(), actualNode.getValue());
}
@Test
final Entry<YangInstanceIdentifier, TreeNode> actualNode = StoreTreeNodes.findClosest(rootNode,
twoTwoInvalidPath);
- assertTreeNodeEquals(expectedNode.get(), actualNode.getValue());
+ assertTreeNodeEquals(expectedNode.orElseThrow(), actualNode.getValue());
}
private static ContainerNode createTestContainer() {
final Class<T> type) {
assertNotNull(potential);
assertTrue(potential.isPresent());
- assertTrue(type.isInstance(potential.get()));
- return type.cast(potential.get());
+ assertTrue(type.isInstance(potential.orElseThrow()));
+ return type.cast(potential.orElseThrow());
}
private static void assertTreeNodeEquals(final TreeNode expected, final TreeNode actual) {
private static ContainerNode createContributorContainer(final ContainerSchemaNode contributorCont) {
return Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(odlContributor))
- .addChild(createContributorList((ListSchemaNode) contributorCont.findDataChildByName(contributor).get()))
+ .addChild(createContributorList((ListSchemaNode) contributorCont.getDataChildByName(contributor)))
.build();
}
// No-op
break;
case WRITE:
- cursor.write(node.getIdentifier(), node.getDataAfter().get());
+ cursor.write(node.getIdentifier(), node.getDataAfter().orElseThrow());
break;
default:
throw new IllegalArgumentException("Unsupported modification " + node.getModificationType());
// No-op
break;
case WRITE:
- cursor.write(rootPath.getLastPathArgument(), node.getDataAfter().get());
+ cursor.write(rootPath.getLastPathArgument(), node.getDataAfter().orElseThrow());
break;
default:
throw new IllegalArgumentException("Unsupported modification " + node.getModificationType());
// No-op
break;
case WRITE:
- cursor.write(node.getIdentifier(), node.getDataAfter().get());
+ cursor.write(node.getIdentifier(), node.getDataAfter().orElseThrow());
break;
default:
throw new IllegalArgumentException("Unsupported modification " + node.getModificationType());
// No-op
break;
case WRITE:
- modification.write(path, node.getDataAfter().get());
+ modification.write(path, node.getDataAfter().orElseThrow());
LOG.debug("Modification {} written path {}", modification, path);
break;
default:
if (dataBefore.isEmpty()) {
return new TerminalDataTreeCandidateNode(null, ModificationType.UNMODIFIED, null, null);
}
- return new TerminalDataTreeCandidateNode(null, nodeModification, dataBefore.get(), null);
+ return new TerminalDataTreeCandidateNode(null, nodeModification, dataBefore.orElseThrow(), null);
case WRITE:
return new TerminalDataTreeCandidateNode(null, nodeModification, dataBefore.orElse(null),
dataAfter.orElseThrow());
// No-op
break;
case WRITE:
- modification.write(child, node.getDataAfter().get());
+ modification.write(child, node.getDataAfter().orElseThrow());
LOG.debug("Modification {} written path {}", modification, child);
break;
default:
public static ImmutableNormalizedAnydata ofOptional(final EffectiveStatementInference inference,
final NormalizedNode data, final Optional<NormalizedMetadata> metadata) {
return metadata.isPresent()
- ? new ImmutableMetadataNormalizedAnydata(inference, data, metadata.get())
+ ? new ImmutableMetadataNormalizedAnydata(inference, data, metadata.orElseThrow())
: new ImmutableNormalizedAnydata(inference, data);
}
@Override
default Optional<NotificationDefinition> findNotification(final QName qname) {
- final Optional<Collection<? extends @NonNull NotificationDefinition>> defs = findModule(qname.getModule())
- .map(Module::getNotifications);
+ final var defs = findModule(qname.getModule()).map(Module::getNotifications);
if (defs.isPresent()) {
- for (NotificationDefinition def : defs.get()) {
+ for (var def : defs.orElseThrow()) {
if (qname.equals(def.getQName())) {
return Optional.of(def);
}
}
default @NonNull PrefixStatement getPrefix() {
- return findFirstDeclaredSubstatement(PrefixStatement.class).get();
+ return findFirstDeclaredSubstatement(PrefixStatement.class).orElseThrow();
}
}
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
}
default @Nullable PositionStatement getPosition() {
- final Optional<PositionStatement> opt = findFirstDeclaredSubstatement(PositionStatement.class);
- return opt.isPresent() ? opt.get() : null;
+ final var opt = findFirstDeclaredSubstatement(PositionStatement.class);
+ return opt.isPresent() ? opt.orElseThrow() : null;
}
}
}
default @NonNull PrefixStatement getPrefix() {
- return findFirstDeclaredSubstatement(PrefixStatement.class).get();
+ return findFirstDeclaredSubstatement(PrefixStatement.class).orElseThrow();
}
default @Nullable RevisionDateStatement getRevisionDate() {
@Beta
public interface TypeAwareDeclaredStatement extends DeclaredStatement<QName> {
default @NonNull TypeStatement getType() {
- return findFirstDeclaredSubstatement(TypeStatement.class).get();
+ return findFirstDeclaredSubstatement(TypeStatement.class).orElseThrow();
}
default @NonNull Optional<UnitsStatement> getUnits() {
final StatementDefinition def = root.statementDefinition();
final QName name = def.getStatementName();
- final ArgumentDefinition arg = def.getArgumentDefinition().get();
+ final ArgumentDefinition arg = def.getArgumentDefinition().orElseThrow();
events.add(eventFactory.createStartElement(XMLConstants.DEFAULT_NS_PREFIX, name.getNamespace().toString(),
name.getLocalName(), singletonIterator(attribute(arg.argumentName(), root.rawArgument())),
final var fooModule = schemaContext.findModule("foo", Revision.of("2017-02-28")).orElseThrow();
YinExportUtils.writeModuleAsYinText(fooModule.asEffectiveStatement(), bufferedOutputStream);
- final String output = byteArrayOutputStream.toString();
+ final var output = byteArrayOutputStream.toString();
assertNotNull(output);
assertFalse(output.isEmpty());
final var byteArrayOutputStream = new ByteArrayOutputStream();
final var bufferedOutputStream = new BufferedOutputStream(byteArrayOutputStream);
- final var barModule = schemaContext.findModule("bar", Revision.of("2017-02-28")).get();
+ final var barModule = schemaContext.findModule("bar", Revision.of("2017-02-28")).orElseThrow();
YinExportUtils.writeModuleAsYinText(barModule.asEffectiveStatement(), bufferedOutputStream);
- final String output = byteArrayOutputStream.toString();
+ final var output = byteArrayOutputStream.toString();
assertNotNull(output);
assertFalse(output.isEmpty());
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
-import org.opendaylight.yangtools.yang.model.ri.type.DerivedTypeBuilder;
import org.opendaylight.yangtools.yang.model.ri.type.DerivedTypes;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.SchemaNodeMixin;
@Override
public TypeDefinition<?> getTypeDefinition() {
- final TypeDefinition<?> existing = (TypeDefinition<?>) TYPE_DEFINITION.getAcquire(this);
+ final var existing = (TypeDefinition<?>) TYPE_DEFINITION.getAcquire(this);
return existing != null ? existing : loadTypeDefinition();
}
}
private @NonNull TypeDefinition<?> loadTypeDefinition() {
- final TypeEffectiveStatement<?> type = findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
- final DerivedTypeBuilder<?> builder = DerivedTypes.derivedTypeBuilder(type.getTypeDefinition(), argument());
+ final var type = findFirstEffectiveSubstatement(TypeEffectiveStatement.class).orElseThrow();
+ final var builder = DerivedTypes.derivedTypeBuilder(type.getTypeDefinition(), argument());
for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
- if (stmt instanceof DefaultEffectiveStatement) {
- builder.setDefaultValue(((DefaultEffectiveStatement) stmt).argument());
- } else if (stmt instanceof DescriptionEffectiveStatement) {
- builder.setDescription(((DescriptionEffectiveStatement)stmt).argument());
- } else if (stmt instanceof ReferenceEffectiveStatement) {
- builder.setReference(((ReferenceEffectiveStatement)stmt).argument());
- } else if (stmt instanceof StatusEffectiveStatement) {
- builder.setStatus(((StatusEffectiveStatement)stmt).argument());
- } else if (stmt instanceof UnitsEffectiveStatement) {
- builder.setUnits(((UnitsEffectiveStatement)stmt).argument());
- } else if (stmt instanceof UnknownSchemaNode) {
+ if (stmt instanceof DefaultEffectiveStatement dflt) {
+ builder.setDefaultValue(dflt.argument());
+ } else if (stmt instanceof DescriptionEffectiveStatement description) {
+ builder.setDescription(description.argument());
+ } else if (stmt instanceof ReferenceEffectiveStatement reference) {
+ builder.setReference(reference.argument());
+ } else if (stmt instanceof StatusEffectiveStatement status) {
+ builder.setStatus(status.argument());
+ } else if (stmt instanceof UnitsEffectiveStatement units) {
+ builder.setUnits(units.argument());
+ } else if (stmt instanceof UnknownSchemaNode unknown) {
// FIXME: should not directly implement, I think
- builder.addUnknownSchemaNode((UnknownSchemaNode)stmt);
+ builder.addUnknownSchemaNode(unknown);
} else if (!(stmt instanceof TypeEffectiveStatement)) {
LOG.debug("Ignoring statement {}", stmt);
}
}
- final TypeDefinition<?> created = builder.build();
- final Object witness = TYPE_DEFINITION.compareAndExchangeRelease(this, null, created);
+ final var created = builder.build();
+ final var witness = TYPE_DEFINITION.compareAndExchangeRelease(this, null, created);
return witness == null ? created : (TypeDefinition<?>) witness;
}
private @NonNull ProxyTypeEffectiveStatement loadTypeStatement() {
- final ProxyTypeEffectiveStatement created = new ProxyTypeEffectiveStatement();
- final Object witness = TYPE_STATEMENT.compareAndExchangeRelease(this, null, created);
+ final var created = new ProxyTypeEffectiveStatement();
+ final var witness = TYPE_STATEMENT.compareAndExchangeRelease(this, null, created);
return witness == null ? created : (ProxyTypeEffectiveStatement) witness;
}
}
public static ConcreteTypeBuilder<?> concreteTypeBuilder(final TypeDefinition<?> baseType, final QName qname) {
- if (baseType instanceof BinaryTypeDefinition) {
- return concreteBinaryBuilder((BinaryTypeDefinition) baseType, qname);
- } else if (baseType instanceof BitsTypeDefinition) {
- return concreteBitsBuilder((BitsTypeDefinition) baseType, qname);
- } else if (baseType instanceof BooleanTypeDefinition) {
- return concreteBooleanBuilder((BooleanTypeDefinition) baseType, qname);
- } else if (baseType instanceof DecimalTypeDefinition) {
- return concreteDecimalBuilder((DecimalTypeDefinition) baseType, qname);
- } else if (baseType instanceof EmptyTypeDefinition) {
- return concreteEmptyBuilder((EmptyTypeDefinition) baseType, qname);
- } else if (baseType instanceof EnumTypeDefinition) {
- return concreteEnumerationBuilder((EnumTypeDefinition) baseType, qname);
- } else if (baseType instanceof IdentityrefTypeDefinition) {
- return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, qname);
- } else if (baseType instanceof InstanceIdentifierTypeDefinition) {
- return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, qname);
- } else if (baseType instanceof Int8TypeDefinition) {
- return concreteInt8Builder((Int8TypeDefinition) baseType, qname);
- } else if (baseType instanceof Int16TypeDefinition) {
- return concreteInt16Builder((Int16TypeDefinition) baseType, qname);
- } else if (baseType instanceof Int32TypeDefinition) {
- return concreteInt32Builder((Int32TypeDefinition) baseType, qname);
- } else if (baseType instanceof Int64TypeDefinition) {
- return concreteInt64Builder((Int64TypeDefinition) baseType, qname);
- } else if (baseType instanceof LeafrefTypeDefinition) {
- return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, qname);
- } else if (baseType instanceof StringTypeDefinition) {
- return concreteStringBuilder((StringTypeDefinition) baseType, qname);
- } else if (baseType instanceof UnionTypeDefinition) {
- return concreteUnionBuilder((UnionTypeDefinition) baseType, qname);
- } else if (baseType instanceof Uint8TypeDefinition) {
- return concreteUint8Builder((Uint8TypeDefinition) baseType, qname);
- } else if (baseType instanceof Uint16TypeDefinition) {
- return concreteUint16Builder((Uint16TypeDefinition) baseType, qname);
- } else if (baseType instanceof Uint32TypeDefinition) {
- return concreteUint32Builder((Uint32TypeDefinition) baseType, qname);
- } else if (baseType instanceof Uint64TypeDefinition) {
- return concreteUint64Builder((Uint64TypeDefinition) baseType, qname);
+ if (baseType instanceof BinaryTypeDefinition binary) {
+ return concreteBinaryBuilder(binary, qname);
+ } else if (baseType instanceof BitsTypeDefinition bits) {
+ return concreteBitsBuilder(bits, qname);
+ } else if (baseType instanceof BooleanTypeDefinition bool) {
+ return concreteBooleanBuilder(bool, qname);
+ } else if (baseType instanceof DecimalTypeDefinition decimal) {
+ return concreteDecimalBuilder(decimal, qname);
+ } else if (baseType instanceof EmptyTypeDefinition empty) {
+ return concreteEmptyBuilder(empty, qname);
+ } else if (baseType instanceof EnumTypeDefinition enumType) {
+ return concreteEnumerationBuilder(enumType, qname);
+ } else if (baseType instanceof IdentityrefTypeDefinition identityRef) {
+ return concreteIdentityrefBuilder(identityRef, qname);
+ } else if (baseType instanceof InstanceIdentifierTypeDefinition instanceIdentifier) {
+ return concreteInstanceIdentifierBuilder(instanceIdentifier, qname);
+ } else if (baseType instanceof Int8TypeDefinition int8) {
+ return concreteInt8Builder(int8, qname);
+ } else if (baseType instanceof Int16TypeDefinition int16) {
+ return concreteInt16Builder(int16, qname);
+ } else if (baseType instanceof Int32TypeDefinition int32) {
+ return concreteInt32Builder(int32, qname);
+ } else if (baseType instanceof Int64TypeDefinition int64) {
+ return concreteInt64Builder(int64, qname);
+ } else if (baseType instanceof LeafrefTypeDefinition leafRef) {
+ return concreteLeafrefBuilder(leafRef, qname);
+ } else if (baseType instanceof StringTypeDefinition string) {
+ return concreteStringBuilder(string, qname);
+ } else if (baseType instanceof UnionTypeDefinition union) {
+ return concreteUnionBuilder(union, qname);
+ } else if (baseType instanceof Uint8TypeDefinition uint8) {
+ return concreteUint8Builder(uint8, qname);
+ } else if (baseType instanceof Uint16TypeDefinition uint16) {
+ return concreteUint16Builder(uint16, qname);
+ } else if (baseType instanceof Uint32TypeDefinition uint32) {
+ return concreteUint32Builder(uint32, qname);
+ } else if (baseType instanceof Uint64TypeDefinition uint64) {
+ return concreteUint64Builder(uint64, qname);
} else {
throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
}
final var typeStmt = leaf.findFirstEffectiveSubstatement(TypeEffectiveStatement.class).orElseThrow();
final var builder = concreteTypeBuilder(typeStmt.getTypeDefinition(), leaf.argument());
for (var stmt : leaf.effectiveSubstatements()) {
- if (stmt instanceof DefaultEffectiveStatement) {
- builder.setDefaultValue(((DefaultEffectiveStatement)stmt).argument());
- } else if (stmt instanceof DescriptionEffectiveStatement) {
- builder.setDescription(((DescriptionEffectiveStatement)stmt).argument());
- } else if (stmt instanceof ReferenceEffectiveStatement) {
- builder.setReference(((ReferenceEffectiveStatement)stmt).argument());
- } else if (stmt instanceof StatusEffectiveStatement) {
- builder.setStatus(((StatusEffectiveStatement)stmt).argument());
- } else if (stmt instanceof UnitsEffectiveStatement) {
- builder.setUnits(((UnitsEffectiveStatement)stmt).argument());
+ if (stmt instanceof DefaultEffectiveStatement dflt) {
+ builder.setDefaultValue(dflt.argument());
+ } else if (stmt instanceof DescriptionEffectiveStatement description) {
+ builder.setDescription(description.argument());
+ } else if (stmt instanceof ReferenceEffectiveStatement reference) {
+ builder.setReference(reference.argument());
+ } else if (stmt instanceof StatusEffectiveStatement status) {
+ builder.setStatus(status.argument());
+ } else if (stmt instanceof UnitsEffectiveStatement units) {
+ builder.setUnits(units.argument());
}
}
return builder.build();
}
public static TypeDefinition<?> typeOf(final LeafListEffectiveStatement leafList) {
- final var typeStmt = leafList.findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
+ final var typeStmt = leafList.findFirstEffectiveSubstatement(TypeEffectiveStatement.class).orElseThrow();
final var builder = concreteTypeBuilder(typeStmt.getTypeDefinition(), leafList.argument());
for (var stmt : leafList.effectiveSubstatements()) {
// NOTE: 'default' is omitted here on purpose
- if (stmt instanceof DescriptionEffectiveStatement) {
- builder.setDescription(((DescriptionEffectiveStatement)stmt).argument());
- } else if (stmt instanceof ReferenceEffectiveStatement) {
- builder.setReference(((ReferenceEffectiveStatement)stmt).argument());
- } else if (stmt instanceof StatusEffectiveStatement) {
- builder.setStatus(((StatusEffectiveStatement)stmt).argument());
- } else if (stmt instanceof UnitsEffectiveStatement) {
- builder.setUnits(((UnitsEffectiveStatement)stmt).argument());
+ if (stmt instanceof DescriptionEffectiveStatement description) {
+ builder.setDescription(description.argument());
+ } else if (stmt instanceof ReferenceEffectiveStatement reference) {
+ builder.setReference(reference.argument());
+ } else if (stmt instanceof StatusEffectiveStatement status) {
+ builder.setStatus(status.argument());
+ } else if (stmt instanceof UnitsEffectiveStatement units) {
+ builder.setUnits(units.argument());
}
}
return builder.build();
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
public final void setUnits(final String units) {
requireNonNull(units);
- final Optional<String> baseUnits = getBaseType().getUnits();
- if (baseUnits.isPresent() && !units.equals(baseUnits.get())) {
+ final var baseUnits = getBaseType().getUnits();
+ if (baseUnits.isPresent() && !units.equals(baseUnits.orElseThrow())) {
LOG.warn("Type {} uverrides 'units' of type {} to \"{}\"", getQName(), getBaseType(), units);
}
static <T extends ContainerLike> T findAsContainer(final EffectiveStatement<?, ?> stmt,
final Class<? extends EffectiveStatement<QName, ?>> type, final Class<T> target) {
- return target.cast(stmt.findFirstEffectiveSubstatement(type).get());
+ return target.cast(stmt.findFirstEffectiveSubstatement(type).orElseThrow());
}
static Collection<? extends @NonNull TypeDefinition<?>> filterTypeDefinitions(final Mixin<?, ?> stmt) {
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableBiMap.Builder;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.BiMapYangNamespaceContext;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.spi.AbstractEffectiveModelContextProvider;
/**
* @return A BiMapYangNamespaceContext.
*/
public BiMapYangNamespaceContext toBiMap() {
- final Builder<String, QNameModule> builder = ImmutableBiMap.builder();
- for (ModuleEffectiveStatement module : getEffectiveModelContext().getModuleStatements().values()) {
- final String name = module.argument().getLocalName();
- builder.put(name, findNamespaceForPrefix(name).get());
+ final var builder = ImmutableBiMap.<String, QNameModule>builder();
+ for (var module : getEffectiveModelContext().getModuleStatements().values()) {
+ final var name = module.argument().getLocalName();
+ builder.put(name, findNamespaceForPrefix(name).orElseThrow());
}
return new BiMapYangNamespaceContext(builder.build());
}
import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleLike;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.Submodule;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private static final String MODULE41_NAME = "module41";
private static final String MODULE5_NAME = "module5";
- private static SchemaContext mockSchema(final Module... modules) {
+ private static EffectiveModelContext mockSchema(final Module... modules) {
Arrays.sort(modules, AbstractSchemaContext.NAME_REVISION_COMPARATOR);
- SchemaContext mock = mock(SchemaContext.class);
+ var mock = mock(EffectiveModelContext.class);
doReturn(ImmutableSet.copyOf(modules)).when(mock).getModules();
return mock;
}
*/
@Test
void testBasic() {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module2, moduleConfig);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
+ var schemaContext = mockSchema(moduleConfig, module2, module3);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
}
*/
@Test
void testNull() {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module2, moduleConfig);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
+ var schemaContext = mockSchema(moduleConfig, module2, module3);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
assertProxyContext(filteringSchemaContextProxy, null);
}
*/
@Test
void testConfigDifferentRevisions() {
- Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
- Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
- Module moduleConfig2 = mockModule(CONFIG_NAME, REVISION2);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
+ var moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
+ var moduleConfig = mockModule(CONFIG_NAME, REVISION);
+ var moduleConfig2 = mockModule(CONFIG_NAME, REVISION2);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module2, moduleConfigNullRevision);
- SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
+ var schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
}
*/
@Test
void testBasicNullRevision() throws Exception {
- final Module moduleConfig = mockModule(CONFIG_NAME, Revision.of("2013-04-05"));
- final Module module2 = mockModule(MODULE2_NAME, Revision.of("2014-06-17"));
- final Module module20 = mockModule(MODULE2_NAME, null);
- final Module module3 = mockModule(MODULE3_NAME, Revision.of("2014-06-12"));
- final Module module30 = mockModule(MODULE3_NAME, null);
+ final var moduleConfig = mockModule(CONFIG_NAME, Revision.of("2013-04-05"));
+ final var module2 = mockModule(MODULE2_NAME, Revision.of("2014-06-17"));
+ final var module20 = mockModule(MODULE2_NAME, null);
+ final var module3 = mockModule(MODULE3_NAME, Revision.of("2014-06-12"));
+ final var module30 = mockModule(MODULE3_NAME, null);
mockModuleImport(module20, moduleConfig);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module20, moduleConfig);
mockModuleImport(module30, module20, moduleConfig);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
-
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var schemaContext = mockSchema(moduleConfig, module2, module3);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
}
*/
@Test
void testBasicMoreRootModules() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final Module moduleRoot = mockModule(ROOT_NAME);
- final Module module2 = mockModule(MODULE2_NAME);
- final Module module3 = mockModule(MODULE3_NAME);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var moduleRoot = mockModule(ROOT_NAME);
+ final var module2 = mockModule(MODULE2_NAME);
+ final var module3 = mockModule(MODULE3_NAME);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, moduleRoot);
- SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
+ var schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
}
*/
@Test
void testChainNotDepend() {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module2);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
+ var schemaContext = mockSchema(moduleConfig, module2, module3);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
}
*/
@Test
void testChainDependMulti() {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
- Module module4 = mockModule(MODULE4_NAME);
- Module module5 = mockModule(MODULE5_NAME);
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
+ var module4 = mockModule(MODULE4_NAME);
+ var module5 = mockModule(MODULE5_NAME);
mockModuleImport(module2, moduleConfig, module3);
mockModuleImport(module3, module4);
mockModuleImport(module4, module5);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
+ var schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
}
*/
@Test
void testChainNotDependMulti() {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
- Module module4 = mockModule(MODULE4_NAME);
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
+ var module4 = mockModule(MODULE4_NAME);
mockModuleImport(module2, moduleConfig, module3);
mockModuleImport(module4, module3);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
+ var schemaContext = mockSchema(moduleConfig, module2, module3, module4);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
}
*/
@Test
void testChainNotMulti() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final Module module2 = mockModule(MODULE2_NAME);
- final Module module3 = mockModule(MODULE3_NAME);
- final Module module4 = mockModule(MODULE4_NAME);
- final Module module5 = mockModule(MODULE5_NAME);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var module2 = mockModule(MODULE2_NAME);
+ final var module3 = mockModule(MODULE3_NAME);
+ final var module4 = mockModule(MODULE4_NAME);
+ final var module5 = mockModule(MODULE5_NAME);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, moduleConfig);
mockModuleImport(module4, moduleConfig);
mockModuleImport(module5, moduleConfig);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
+ var schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
}
*/
@Test
void testBasicRevisionChange() throws Exception {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
- Module module4 = mockModule(MODULE3_NAME, Revision.of("2015-10-10"));
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
+ var module4 = mockModule(MODULE3_NAME, Revision.of("2015-10-10"));
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module2, moduleConfig);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
+ var schemaContext = mockSchema(moduleConfig, module2, module3, module4);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
}
*/
@Test
void testImportNoRevision() {
- Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
- Module module2 = mockModule(MODULE2_NAME, REVISION);
+ var moduleConfig = mockModule(CONFIG_NAME, REVISION);
+ var module2 = mockModule(MODULE2_NAME, REVISION);
- Module module3 = mockModule(MODULE3_NAME, null);
- Module module30 = mockModule(MODULE3_NAME, REVISION);
- Module module31 = mockModule(MODULE3_NAME, REVISION2);
+ var module3 = mockModule(MODULE3_NAME, null);
+ var module30 = mockModule(MODULE3_NAME, REVISION);
+ var module31 = mockModule(MODULE3_NAME, REVISION2);
mockModuleImport(module2, moduleConfig, module3);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
-
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var schemaContext = mockSchema(moduleConfig, module2, module30, module31);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
}
*/
@Test
void testBasicSubmodule() {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
- Module module4 = mockModule(MODULE4_NAME);
- Submodule module41 = mockSubmodule(MODULE41_NAME);
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
+ var module4 = mockModule(MODULE4_NAME);
+ var module41 = mockSubmodule(MODULE41_NAME);
mockSubmodules(module4, module41);
mockModuleImport(module2, moduleConfig, module3);
mockModuleImport(module41, moduleConfig);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
+ var schemaContext = mockSchema(moduleConfig, module2, module3, module4);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
}
*/
@Test
void testChainAdditionalModules() {
- Module module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
- Module module4 = mockModule(MODULE4_NAME);
- Module module5 = mockModule(MODULE5_NAME);
+ var module2 = mockModule(MODULE2_NAME);
+ var module3 = mockModule(MODULE3_NAME);
+ var module4 = mockModule(MODULE4_NAME);
+ var module5 = mockModule(MODULE5_NAME);
mockModuleImport(module2, module3);
mockModuleImport(module3, module4);
mockModuleImport(module4, module5);
- SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
+ var schemaContext = mockSchema(module2, module3, module4, module5);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(module2),
- null);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(module2), null);
assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
}
*/
@Test
void testChainAdditionalModulesConfig() {
- Module moduleConfig = mockModule(CONFIG_NAME);
- Module module2 = mockModule(MODULE2_NAME);
+ var moduleConfig = mockModule(CONFIG_NAME);
+ var module2 = mockModule(MODULE2_NAME);
- Module module3 = mockModule(MODULE3_NAME);
- Module module4 = mockModule(MODULE4_NAME);
- Module module5 = mockModule(MODULE5_NAME);
+ var module3 = mockModule(MODULE3_NAME);
+ var module4 = mockModule(MODULE4_NAME);
+ var module5 = mockModule(MODULE5_NAME);
mockModuleImport(module2, moduleConfig);
mockModuleImport(module3, module4);
- SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
+ var schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
- FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(module3),
- moduleConfig);
+ var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(module3), moduleConfig);
assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
}
@Test
void testGetDataDefinitions() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
+ final var mockedContainer = mock(ContainerSchemaNode.class);
doReturn(Set.of(mockedContainer)).when(moduleConfig).getChildNodes();
final var dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
@Test
void testGetNotifications() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
+ final var mockedNotification = mock(NotificationDefinition.class);
doReturn(Set.of(mockedNotification)).when(moduleConfig).getNotifications();
final var schemaContextProxyNotifications = filteringSchemaContextProxy.getNotifications();
@Test
void testGetOperations() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final RpcDefinition mockedRpc = mock(RpcDefinition.class);
+ final var mockedRpc = mock(RpcDefinition.class);
doReturn(Set.of(mockedRpc)).when(moduleConfig).getRpcs();
final var operations = filteringSchemaContextProxy.getOperations();
@Test
void testGetExtensions() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
+ final var mockedExtension = mock(ExtensionDefinition.class);
doReturn(List.of(mockedExtension)).when(moduleConfig).getExtensionSchemaNodes();
final var schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
@Test
void testGetUnknownSchemaNodes() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
+ final var mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
doReturn(List.of(mockedUnknownSchemaNode)).when(moduleConfig).getUnknownSchemaNodes();
final var schemaContextProxyUnknownSchemaNodes = filteringSchemaContextProxy.getUnknownSchemaNodes();
@Test
void testGetTypeDefinitions() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
+ final var mockedTypeDefinition = mock(TypeDefinition.class);
doReturn(Set.of(mockedTypeDefinition)).when(moduleConfig).getTypeDefinitions();
final var schemaContextProxyTypeDefinitions = filteringSchemaContextProxy.getTypeDefinitions();
@Test
void testGetChildNodes() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
+ final var mockedContainer = mock(ContainerSchemaNode.class);
doReturn(Set.of(mockedContainer)).when(moduleConfig).getChildNodes();
final var schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
@Test
void testGetGroupings() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
+ final var mockedGrouping = mock(GroupingDefinition.class);
doReturn(Set.of(mockedGrouping)).when(moduleConfig).getGroupings();
final var schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
@Test
void testGetDataChildByName() {
- final Module moduleConfig = mockModule(CONFIG_NAME);
- final SchemaContext schemaContext = mockSchema(moduleConfig);
- final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
- moduleConfig);
+ final var moduleConfig = mockModule(CONFIG_NAME);
+ final var schemaContext = mockSchema(moduleConfig);
+ final var filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(), moduleConfig);
- final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
- final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
+ final var qname = QName.create("config-namespace", "2016-08-11", "cont");
+ final var mockedContainer = mock(ContainerSchemaNode.class);
doReturn(mockedContainer).when(moduleConfig).dataChildByName(any(QName.class));
- final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
+ final var dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
}
private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
final Module... expected) {
- final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : Set.of();
- Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
+ final var modSet = expected != null ? ImmutableSet.copyOf(expected) : Set.of();
+ var modSetFiltering = filteringSchemaContextProxy.getModules();
assertEquals(modSet, modSetFiltering);
//asserting collections
if (expected != null) {
- for (final Module module : expected) {
+ for (var module : expected) {
assertEquals(Optional.of(module),
filteringSchemaContextProxy.findModule(module.getName(), module.getRevision()));
}
}
- private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
+ private static FilteringSchemaContextProxy createProxySchemaCtx(final EffectiveModelContext schemaContext,
final Set<Module> additionalModules, final Module... modules) {
final var modulesSet = modules != null ? ImmutableSet.copyOf(modules) : Set.<Module>of();
return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
private static void mockModuleImport(final ModuleLike importer, final Module... imports) {
final var mockedImports = new HashSet<ModuleImport>();
- for (final var module : imports) {
+ for (var module : imports) {
mockedImports.add(new ModuleImport() {
@Override
public Unqualified getModuleName() {
private static void mockModuleLike(final ModuleLike mockedModule, final String name) {
doReturn(name).when(mockedModule).getName();
doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
- final XMLNamespace newNamespace = XMLNamespace.of(NAMESPACE + ":" + name);
+ final var newNamespace = XMLNamespace.of(NAMESPACE + ":" + name);
doReturn(newNamespace).when(mockedModule).getNamespace();
doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
doReturn(Set.of()).when(mockedModule).getSubmodules();
package org.opendaylight.yangtools.yang.model.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.PathExpression.LocationPathSteps;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathAxis;
@Test
void findDataSchemaNodeTest() {
- final Module importedModule = context.findModule(XMLNamespace.of("uri:imported-module"),
+ final var importedModule = context.findModule(XMLNamespace.of("uri:imported-module"),
Revision.of("2014-10-07")).orElseThrow();
final QName myImportedContainer = QName.create(importedModule.getQNameModule(), "my-imported-container");
final QName myImportedLeaf = QName.create(importedModule.getQNameModule(), "my-imported-leaf");
- final SchemaNode testNode = ((ContainerSchemaNode) importedModule.getDataChildByName(myImportedContainer))
- .getDataChildByName(myImportedLeaf);
+ final var testNode = assertInstanceOf(ContainerSchemaNode.class,
+ importedModule.getDataChildByName(myImportedContainer)).getDataChildByName(myImportedLeaf);
- final PathExpression expr = mock(PathExpression.class);
+ final var expr = mock(PathExpression.class);
doReturn(true).when(expr).isAbsolute();
doReturn(new LocationPathSteps(YangLocationPath.absolute(
YangXPathAxis.CHILD.asStep(myImportedContainer), YangXPathAxis.CHILD.asStep(myImportedLeaf))))
@Test
void findDataSchemaNodeTest2() {
final QName myLeafInGrouping2 = QName.create(myModule.getQNameModule(), "my-leaf-in-gouping2");
- final PathExpression expr = mock(PathExpression.class);
+ final var expr = mock(PathExpression.class);
doReturn(true).when(expr).isAbsolute();
doReturn(new LocationPathSteps(YangLocationPath.relative(YangXPathAxis.CHILD.asStep(myLeafInGrouping2))))
.when(expr).getSteps();
- final GroupingDefinition grouping = getGroupingByName(myModule, "my-grouping");
- final SchemaInferenceStack stack = SchemaInferenceStack.of(context);
+ final var grouping = getGroupingByName(myModule, "my-grouping");
+ final var stack = SchemaInferenceStack.of(context);
assertSame(grouping, stack.enterGrouping(grouping.getQName()));
assertEquals(grouping.getDataChildByName(myLeafInGrouping2), stack.resolvePathExpression(expr));
}
@Test
void enterGroupingNegativeTest() {
- final SchemaInferenceStack stack = SchemaInferenceStack.of(context);
+ final var stack = SchemaInferenceStack.of(context);
assertNotExistentGrouping(stack, "module (uri:my-module?revision=2014-10-07)my-module");
stack.enterDataTree(QName.create(myModule.getQNameModule(), "my-container"));
assertNotExistentGrouping(stack, "schema parent (uri:my-module?revision=2014-10-07)my-container");
@Test
void enterNestedTypedefTest() {
- final SchemaInferenceStack stack = SchemaInferenceStack.of(context);
+ final var stack = SchemaInferenceStack.of(context);
stack.enterDataTree(QName.create(myModule.getQNameModule(), "my-container"));
assertNotNull(stack.enterTypedef(QName.create(myModule.getQNameModule(), "my-typedef-in-container")));
}
@Test
void enterTypedefNegativeTest() {
- final SchemaInferenceStack stack = SchemaInferenceStack.of(context);
+ final var stack = SchemaInferenceStack.of(context);
assertNotExistentTypedef(stack, "module (uri:my-module?revision=2014-10-07)my-module");
stack.enterDataTree(QName.create(myModule.getQNameModule(), "my-container"));
assertNotExistentTypedef(stack, "schema parent (uri:my-module?revision=2014-10-07)my-container");
}
private static GroupingDefinition getGroupingByName(final DataNodeContainer dataNodeContainer, final String name) {
- for (final GroupingDefinition grouping : dataNodeContainer.getGroupings()) {
+ for (var grouping : dataNodeContainer.getGroupings()) {
if (grouping.getQName().getLocalName().equals(name)) {
return grouping;
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.io.IOException;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Optional;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.rfc6241.model.api.NetconfConstants;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
public class NetconfTest {
}
@Test
- public void testResolution() throws ReactorException, IOException, YangSyntaxErrorException {
- final SchemaContext context = reactor.newBuild()
+ public void testResolution() throws Exception {
+ final var context = reactor.newBuild()
.addLibSources(YangStatementStreamSource.create(
YangTextSchemaSource.forResource("/ietf-inet-types@2013-07-15.yang")))
.addSource(YangStatementStreamSource.create(
YangTextSchemaSource.forResource("/ietf-netconf@2011-06-01.yang")))
.buildEffective();
- final Module module = context.findModule(NetconfConstants.RFC6241_MODULE).get();
- final Collection<? extends RpcDefinition> rpcs = module.getRpcs();
+ final var module = context.findModule(NetconfConstants.RFC6241_MODULE).orElseThrow();
+ final var rpcs = module.getRpcs();
assertEquals(13, rpcs.size());
- final Iterator<? extends RpcDefinition> it = module.getRpcs().iterator();
+ final var it = module.getRpcs().iterator();
// get-config
assertExtension(true, it.next());
assertExtension(false, it.next());
}
private static void assertExtension(final boolean expected, final RpcDefinition def) {
- final Optional<DataSchemaNode> optFilter = def.getInput().findDataTreeChild(FILTER);
+ final var optFilter = def.getInput().findDataTreeChild(FILTER);
assertEquals(expected, optFilter.isPresent());
optFilter.ifPresent(filter -> {
assertThat(filter, is(instanceOf(AnyxmlSchemaNode.class)));
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import java.io.IOException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.rfc6536.model.api.DefaultDenyWriteSchemaNode;
import org.opendaylight.yangtools.rfc6536.model.api.NACMConstants;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
public class NACMTest {
- private static CrossSourceStatementReactor reactor;
+ private static CrossSourceStatementReactor REACTOR;
@BeforeClass
public static void createReactor() {
- reactor = RFC7950Reactors.defaultReactorBuilder()
+ REACTOR = RFC7950Reactors.defaultReactorBuilder()
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
new DefaultDenyAllStatementSupport(YangParserConfiguration.DEFAULT))
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
@AfterClass
public static void freeReactor() {
- reactor = null;
+ REACTOR = null;
}
@Test
- public void testResolution() throws ReactorException, IOException, YangSyntaxErrorException {
- final BuildAction build = reactor.newBuild();
- build.addSource(YangStatementStreamSource.create(
- YangTextSchemaSource.forResource("/ietf-netconf-acm@2012-02-22.yang")));
- build.addSource(YangStatementStreamSource.create(
- YangTextSchemaSource.forResource("/ietf-yang-types@2013-07-15.yang")));
- final SchemaContext context = build.buildEffective();
+ public void testResolution() throws Exception {
+ final var context = REACTOR.newBuild()
+ .addSources(
+ YangStatementStreamSource.create(YangTextSchemaSource.forResource("/ietf-netconf-acm@2012-02-22.yang")),
+ YangStatementStreamSource.create(YangTextSchemaSource.forResource("/ietf-yang-types@2013-07-15.yang")))
+ .buildEffective();
- final Module module = context.findModule(NACMConstants.RFC6536_MODULE).get();
- final DataSchemaNode nacm = module.findDataChildByName(QName.create(NACMConstants.RFC6536_MODULE, "nacm"))
- .get();
+ final var module = context.findModule(NACMConstants.RFC6536_MODULE).orElseThrow();
+ final var nacm = module.getDataChildByName(QName.create(NACMConstants.RFC6536_MODULE, "nacm"));
assertTrue(DefaultDenyAllSchemaNode.findIn(nacm).isPresent());
assertFalse(DefaultDenyWriteSchemaNode.findIn(nacm).isPresent());
}
public class IetfYangSmiv2ExtensionsMappingTest {
@Test
public void testGetEffectiveRepresentationClass() {
- IetfYangSmiv2ExtensionsMapping extensionMapping = IetfYangSmiv2ExtensionsMapping.ALIAS;
- assertEquals(extensionMapping.getEffectiveRepresentationClass(), AliasEffectiveStatement.class);
+ assertEquals(IetfYangSmiv2ExtensionsMapping.ALIAS.getEffectiveRepresentationClass(),
+ AliasEffectiveStatement.class);
}
@Test
public void testIsArgumentYinElement() {
- IetfYangSmiv2ExtensionsMapping extensionMapping = IetfYangSmiv2ExtensionsMapping.ALIAS;
- assertFalse(extensionMapping.getArgumentDefinition().get().isYinElement());
+ assertFalse(IetfYangSmiv2ExtensionsMapping.ALIAS.getArgumentDefinition().orElseThrow().isYinElement());
}
}
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
-import java.io.IOException;
-import java.util.Map;
import java.util.Optional;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
public class AnnotationTest {
private static final QName LAST_MODIFIED_QNAME = QName.create("http://example.org/example-last-modified",
"last-modified");
- private static CrossSourceStatementReactor reactor;
+ private static CrossSourceStatementReactor REACTOR;
@BeforeClass
public static void createReactor() {
- reactor = RFC7950Reactors.vanillaReactorBuilder()
+ REACTOR = RFC7950Reactors.vanillaReactorBuilder()
.addStatementSupport(ModelProcessingPhase.FULL_DECLARATION,
new AnnotationStatementSupport(YangParserConfiguration.DEFAULT))
.build();
@AfterClass
public static void freeReactor() {
- reactor = null;
+ REACTOR = null;
}
@Test
- public void testAnnotationResolution() throws ReactorException, IOException, YangSyntaxErrorException {
- final BuildAction build = reactor.newBuild();
- build.addSource(YangStatementStreamSource.create(
- YangTextSchemaSource.forResource("/ietf-yang-metadata@2016-08-05.yang")));
- build.addSource(YangStatementStreamSource.create(
- YangTextSchemaSource.forResource("/example-last-modified.yang")));
- final SchemaContext context = build.buildEffective();
+ public void testAnnotationResolution() throws Exception {
+ final var context = REACTOR.newBuild()
+ .addSources(YangStatementStreamSource.create(
+ YangTextSchemaSource.forResource("/ietf-yang-metadata@2016-08-05.yang")),
+ YangStatementStreamSource.create(YangTextSchemaSource.forResource("/example-last-modified.yang")))
+ .buildEffective();
- final Map<QName, AnnotationSchemaNode> annotations = AnnotationSchemaNode.findAll(context);
+ final var annotations = AnnotationSchemaNode.findAll(context);
assertEquals(1, annotations.size());
- final AnnotationSchemaNode annotation = annotations.get(LAST_MODIFIED_QNAME);
+ final var annotation = annotations.get(LAST_MODIFIED_QNAME);
assertNotNull(annotation);
- final Optional<AnnotationSchemaNode> findAnnotation = AnnotationSchemaNode.find(context, LAST_MODIFIED_QNAME);
+ final var findAnnotation = AnnotationSchemaNode.find(context, LAST_MODIFIED_QNAME);
assertTrue(findAnnotation.isPresent());
- assertSame(annotation, findAnnotation.get());
+ assertSame(annotation, findAnnotation.orElseThrow());
assertEquals(BaseTypes.stringType(), annotation.getType());
assertEquals(Optional.empty(), annotation.getReference());
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
public class YangDataExtensionTest extends AbstractYangDataTest {
-
private static final StatementStreamSource FOO_MODULE = sourceForResource(
"/yang-data-extension-test/foo.yang");
private static final StatementStreamSource FOO_INVALID_1_MODULE = sourceForResource(
for (var unknownSchemaNode : unknownSchemaNodes) {
assertThat(unknownSchemaNode, instanceOf(YangDataSchemaNode.class));
final var yangDataSchemaNode = (YangDataSchemaNode) unknownSchemaNode;
- if ("my-yang-data-a".equals(unknownSchemaNode.getNodeParameter())) {
+ if ("my-yang-data-a".equals(yangDataSchemaNode.getNodeParameter())) {
myYangDataANode = yangDataSchemaNode;
} else if ("my-yang-data-b".equals(yangDataSchemaNode.getNodeParameter())) {
myYangDataBNode = yangDataSchemaNode;
final var schemaContext = REACTOR.newBuild().addSources(BAZ_MODULE, IETF_RESTCONF_MODULE).buildEffective();
assertNotNull(schemaContext);
- final var baz = schemaContext.findModule("baz", REVISION).get();
+ final var baz = schemaContext.findModule("baz", REVISION).orElseThrow();
final var unknownSchemaNodes = baz.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
.buildEffective();
assertNotNull(schemaContext);
- final var foobar = schemaContext.findModule("foobar", REVISION).get();
+ final var foobar = schemaContext.findModule("foobar", REVISION).orElseThrow();
final var unknownSchemaNodes = foobar.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final var schemaContext = REACTOR.newBuild().addSources(BAR_MODULE, IETF_RESTCONF_MODULE).buildEffective();
assertNotNull(schemaContext);
- final var bar = schemaContext.findModule("bar", REVISION).get();
- final var cont = (ContainerSchemaNode) bar.getDataChildByName(
- QName.create(bar.getQNameModule(), "cont"));
+ final var bar = schemaContext.findModule("bar", REVISION).orElseThrow();
+ final var cont = (ContainerSchemaNode) bar.getDataChildByName(QName.create(bar.getQNameModule(), "cont"));
assertNotNull(cont);
final var extensions = schemaContext.getExtensions();
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import java.io.IOException;
-import java.util.List;
-import java.util.stream.Collectors;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
-import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
public class MountPointTest {
}
@Test
- public void testMountPointResolution() throws ReactorException, IOException, YangSyntaxErrorException {
- final SchemaContext context = reactor.newBuild()
+ public void testMountPointResolution() throws Exception {
+ final var context = reactor.newBuild()
.addLibSources(
YangStatementStreamSource.create(YangTextSchemaSource.forResource(
"/ietf-inet-types@2013-07-15.yang")),
assertEquals(5, context.getModules().size());
- DataSchemaNode child = context.findDataTreeChild(EXAMPLE_CONT).get();
+ var child = context.findDataTreeChild(EXAMPLE_CONT).orElseThrow();
assertThat(child, instanceOf(ContainerSchemaNode.class));
- List<MountPointSchemaNode> mps = MountPointSchemaNode.streamAll((ContainerSchemaNode) child)
- .collect(Collectors.toList());
+ var mps = MountPointSchemaNode.streamAll((ContainerSchemaNode) child).toList();
assertEquals(2, mps.size());
assertEquals(EXAMPLE_CONT, mps.get(0).getQName());
assertEquals(EXAMPLE_CONT, mps.get(1).getQName());
- child = context.findDataTreeChild(EXAMPLE_GRP_CONT).get();
+ child = context.findDataTreeChild(EXAMPLE_GRP_CONT).orElseThrow();
assertThat(child, instanceOf(ContainerSchemaNode.class));
- mps = MountPointSchemaNode.streamAll((ContainerSchemaNode) child).collect(Collectors.toList());
+ mps = MountPointSchemaNode.streamAll((ContainerSchemaNode) child).toList();
assertEquals(1, mps.size());
assertEquals(EXAMPLE_GRP, mps.get(0).getQName());
- child = context.findDataTreeChild(EXAMPLE_LIST).get();
+ child = context.findDataTreeChild(EXAMPLE_LIST).orElseThrow();
assertThat(child, instanceOf(ListSchemaNode.class));
- mps = MountPointSchemaNode.streamAll((ListSchemaNode) child).collect(Collectors.toList());
+ mps = MountPointSchemaNode.streamAll((ListSchemaNode) child).toList();
assertEquals(1, mps.size());
assertEquals(EXAMPLE_LIST, mps.get(0).getQName());
}
continue;
}
- final SourceException sourceEx = optSourceEx.get();
+ final SourceException sourceEx = optSourceEx.orElseThrow();
// Workaround for broken logging implementations which ignore
// suppressed exceptions
final Throwable cause = sourceEx.getCause() != null ? sourceEx.getCause() : sourceEx;
import static java.util.Objects.requireNonNull;
-import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.parser.spi.source.QNameToStatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter.ResumedStatement;
class StatementContextVisitor {
private final QNameToStatementDefinition stmtDef;
// Normal entry point, checks for potential resume
private boolean processStatement(final int myOffset, final IRStatement stmt) {
- final Optional<? extends ResumedStatement> optResumed = writer.resumeStatement(myOffset);
+ final var optResumed = writer.resumeStatement(myOffset);
if (optResumed.isPresent()) {
- final ResumedStatement resumed = optResumed.get();
+ final var resumed = optResumed.orElseThrow();
return resumed.isFullyDefined() || doProcessStatement(stmt, resumed.getSourceReference());
}
return processNewStatement(myOffset, stmt);
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
-import java.util.Optional;
import javax.xml.transform.TransformerException;
import org.opendaylight.yangtools.concepts.AbstractSimpleIdentifiable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
-import org.opendaylight.yangtools.yang.model.api.meta.ArgumentDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YinDomSchemaSource;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter.ResumedStatement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Attr;
private static boolean processAttribute(final int childId, final Attr attr, final StatementWriter writer,
final QNameToStatementDefinition stmtDef, final StatementSourceReference ref) {
- final Optional<? extends ResumedStatement> optResumed = writer.resumeStatement(childId);
+ final var optResumed = writer.resumeStatement(childId);
if (optResumed.isPresent()) {
- final ResumedStatement resumed = optResumed.get();
+ final var resumed = optResumed.orElseThrow();
checkState(resumed.isFullyDefined(), "Statement %s is not fully defined", resumed);
return true;
}
private static boolean processElement(final int childId, final Element element, final StatementWriter writer,
final QNameToStatementDefinition stmtDef) {
- final Optional<? extends ResumedStatement> optResumed = writer.resumeStatement(childId);
+ final var optResumed = writer.resumeStatement(childId);
final StatementSourceReference ref;
final QName argName;
final boolean allAttrs;
final boolean allElements;
if (optResumed.isPresent()) {
- final ResumedStatement resumed = optResumed.get();
+ final var resumed = optResumed.orElseThrow();
if (resumed.isFullyDefined()) {
return true;
}
final StatementDefinition def = resumed.getDefinition();
ref = resumed.getSourceReference();
- final Optional<ArgumentDefinition> optArgDef = def.getArgumentDefinition();
+ final var optArgDef = def.getArgumentDefinition();
if (optArgDef.isPresent()) {
- final ArgumentDefinition argDef = optArgDef.get();
+ final var argDef = optArgDef.orElseThrow();
argName = argDef.argumentName();
allAttrs = argDef.isYinElement();
allElements = !allAttrs;
}
final String argValue;
- final Optional<ArgumentDefinition> optArgDef = def.getArgumentDefinition();
+ final var optArgDef = def.getArgumentDefinition();
if (optArgDef.isPresent()) {
- final ArgumentDefinition argDef = optArgDef.get();
+ final var argDef = optArgDef.orElseThrow();
argName = argDef.argumentName();
allAttrs = argDef.isYinElement();
allElements = !allAttrs;
final Set<UsesNode> mutableUses = new LinkedHashSet<>();
final Set<TypeDefinition<?>> mutableTypeDefinitions = new LinkedHashSet<>();
- for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
+ for (var effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof UsesNode usesNode && !mutableUses.add(usesNode)) {
throw EffectiveStmtUtils.createNameCollisionSourceException(stmt, effectiveStatement);
}
import java.util.Collection;
import java.util.List;
import java.util.Objects;
-import java.util.Optional;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
return;
}
- final SchemaNodeIdentifier augmentArg = augmentNode.getArgument();
- final Optional<StmtContext<?, ?, ?>> targetNode = ParserNamespaces.findSchemaTreeStatement(
+ final var augmentArg = augmentNode.getArgument();
+ final var targetNode = ParserNamespaces.findSchemaTreeStatement(
AbstractAugmentStatementSupport.getSearchRoot(augmentNode), augmentArg);
- if (targetNode.isPresent() && StmtContextUtils.isUnknownStatement(targetNode.get())) {
+ if (targetNode.isPresent() && StmtContextUtils.isUnknownStatement(targetNode.orElseThrow())) {
augmentNode.setUnsupported();
LOG.warn("Uses-augment to unknown node {}. Augmentation has not been performed. At line: {}",
augmentArg, augmentNode.sourceReference());
// This could be an augmentation stacked on top of a previous augmentation from the same module, which is
// conditional -- in which case we do not run further checks
if (targetCtx.history().getLastOperation() == CopyType.ADDED_BY_AUGMENTATION) {
- final Optional<? extends StmtContext<?, ?, ?>> optPrevCopy = targetCtx.getPreviousCopyCtx();
+ final var optPrevCopy = targetCtx.getPreviousCopyCtx();
if (optPrevCopy.isPresent()) {
- final StmtContext<?, ?, ?> original = optPrevCopy.get();
- final Object origArg = original.getArgument();
+ final var original = optPrevCopy.orElseThrow();
+ final var origArg = original.getArgument();
verify(origArg instanceof QName, "Unexpected statement argument %s", origArg);
if (sourceStmtQName.getModule().equals(((QName) origArg).getModule())
}
@Override
- public Optional<ExtensionEffectiveStatement> findExtension(QName qname) {
+ public Optional<ExtensionEffectiveStatement> findExtension(final QName qname) {
return findValue(qnameToExtension, qname);
}
}
@Override
- public Optional<String> findNamespacePrefix(QNameModule namespace) {
+ public Optional<String> findNamespacePrefix(final QNameModule namespace) {
return findValue(namespaceToPrefix, namespace);
}
}
@Override
- public Optional<SubmoduleEffectiveStatement> findSubmodule(Unqualified submoduleName) {
+ public Optional<SubmoduleEffectiveStatement> findSubmodule(final Unqualified submoduleName) {
return findValue(nameToSubmodule, submoduleName);
}
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import com.google.common.collect.ImmutableList;
-import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
final BitsTypeBuilder builder = BaseTypes.bitsTypeBuilder(stmt.argumentAsTypeQName());
Uint32 highestPosition = null;
- for (final EffectiveStatement<?, ?> subStmt : substatements) {
- if (subStmt instanceof BitEffectiveStatement) {
- final BitEffectiveStatement bitSubStmt = (BitEffectiveStatement) subStmt;
-
- final Optional<Uint32> declaredPosition = bitSubStmt.findDeclaredPosition();
+ for (var subStmt : substatements) {
+ if (subStmt instanceof BitEffectiveStatement bitSubStmt) {
+ var declaredPosition = bitSubStmt.findDeclaredPosition();
final Uint32 effectivePos;
if (declaredPosition.isEmpty()) {
if (highestPosition != null) {
effectivePos = Uint32.ZERO;
}
} else {
- effectivePos = declaredPosition.get();
+ effectivePos = declaredPosition.orElseThrow();
}
final Bit bit = EffectiveTypeUtil.buildBit(bitSubStmt, effectivePos);
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableMap;
-import java.util.Optional;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.api.stmt.BitEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement;
@Override
Bit addRestrictedBit(final EffectiveStmtCtx stmt, final BitsTypeDefinition base, final BitEffectiveStatement bit) {
// FIXME: this looks like a duplicate of BitsSpecificationEffectiveStatement
- final Optional<Uint32> declaredPosition = bit.findDeclaredPosition();
+ final var declaredPosition = bit.findDeclaredPosition();
final Uint32 effectivePos;
if (declaredPosition.isEmpty()) {
effectivePos = getBaseTypeBitPosition(bit.argument(), base, stmt);
} else {
- effectivePos = declaredPosition.get();
+ effectivePos = declaredPosition.orElseThrow();
}
return EffectiveTypeUtil.buildBit(bit, effectivePos);
@Override
EnumPair addRestrictedEnum(final EffectiveStmtCtx stmt, final EnumTypeDefinition base,
final EnumEffectiveStatement enumStmt) {
- final EnumEffectiveStatement enumSubStmt = enumStmt;
- final Optional<Integer> declaredValue =
- enumSubStmt.findFirstEffectiveSubstatementArgument(ValueEffectiveStatement.class);
+ final var declaredValue = enumStmt.findFirstEffectiveSubstatementArgument(ValueEffectiveStatement.class);
final int effectiveValue;
if (declaredValue.isEmpty()) {
- effectiveValue = getBaseTypeEnumValue(enumSubStmt.getDeclared().rawArgument(), base, stmt);
+ effectiveValue = getBaseTypeEnumValue(enumStmt.getDeclared().rawArgument(), base, stmt);
} else {
effectiveValue = declaredValue.orElseThrow();
}
- return EffectiveTypeUtil.buildEnumPair(enumSubStmt, effectiveValue);
+ return EffectiveTypeUtil.buildEnumPair(enumStmt, effectiveValue);
}
private static Uint32 getBaseTypeBitPosition(final String bitName, final BitsTypeDefinition baseType,
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
private static void performRefine(final Mutable<?, ?, ?> subStmtCtx, final StmtContext<?, ?, ?> usesParentCtx) {
final Object refineArgument = subStmtCtx.argument();
- InferenceException.throwIf(!(refineArgument instanceof SchemaNodeIdentifier), subStmtCtx,
- "Invalid refine argument %s. It must be instance of SchemaNodeIdentifier.", refineArgument);
+ if (!(refineArgument instanceof SchemaNodeIdentifier refineTarget)) {
+ throw new InferenceException(subStmtCtx,
+ "Invalid refine argument %s. It must be instance of SchemaNodeIdentifier.", refineArgument);
+ }
// FIXME: this really should be handled via separate inference, i.e. we first instantiate the template and when
// it appears, this refine will trigger on it. This reinforces the FIXME below.
- final Optional<StmtContext<?, ?, ?>> optRefineTargetCtx = ParserNamespaces.findSchemaTreeStatement(
- usesParentCtx, (SchemaNodeIdentifier) refineArgument);
+ final var optRefineTargetCtx = ParserNamespaces.findSchemaTreeStatement(usesParentCtx, refineTarget);
InferenceException.throwIf(!optRefineTargetCtx.isPresent(), subStmtCtx, "Refine target node %s not found.",
- refineArgument);
+ refineTarget);
// FIXME: This communicates the looked-up target node to RefineStatementSupport.buildEffective(). We should do
// this trick through a shared namespace or similar reactor-agnostic meeting place. It really feels like
// an inference action RefineStatementSupport should be doing.
- final StmtContext<?, ?, ?> refineTargetNodeCtx = optRefineTargetCtx.get();
+ final var refineTargetNodeCtx = optRefineTargetCtx.orElseThrow();
if (StmtContextUtils.isUnknownStatement(refineTargetNodeCtx)) {
LOG.trace("Refine node '{}' in uses '{}' has target node unknown statement '{}'. "
+ "Refine has been skipped. At line: {}", subStmtCtx.argument(),
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.stmt.AbstractYangTest;
class ElementCountConstraintsTest extends AbstractYangTest {
void testElementCountConstraints() {
final var context = assertEffectiveModel("/constraint-definitions-test/foo.yang");
- final Module testModule = context.findModule("foo", Revision.of("2016-09-20")).get();
- final LeafListSchemaNode constrainedLeafList1 = (LeafListSchemaNode) testModule.getDataChildByName(
- QName.create(testModule.getQNameModule(), "constrained-leaf-list-1"));
- ElementCountConstraint constraints1 = constrainedLeafList1.getElementCountConstraint().get();
+ final var testModule = context.findModule("foo", Revision.of("2016-09-20")).orElseThrow();
+ final var constraints1 = assertInstanceOf(LeafListSchemaNode.class,
+ testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "constrained-leaf-list-1")))
+ .getElementCountConstraint().orElseThrow();
- final LeafListSchemaNode constrainedLeafList2 = (LeafListSchemaNode) testModule.getDataChildByName(
- QName.create(testModule.getQNameModule(), "constrained-leaf-list-2"));
- ElementCountConstraint constraints2 = constrainedLeafList2.getElementCountConstraint().get();
+ var constraints2 = assertInstanceOf(LeafListSchemaNode.class,
+ testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "constrained-leaf-list-2")))
+ .getElementCountConstraint().orElseThrow();
assertEquals(constraints1.hashCode(), constraints2.hashCode());
assertEquals(constraints1, constraints2);
- final LeafListSchemaNode constrainedLeafList3 = (LeafListSchemaNode) testModule.getDataChildByName(
- QName.create(testModule.getQNameModule(), "constrained-leaf-list-3"));
- ElementCountConstraint constraints3 = constrainedLeafList3.getElementCountConstraint().get();
+ var constraints3 = assertInstanceOf(LeafListSchemaNode.class,
+ testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "constrained-leaf-list-3")))
+ .getElementCountConstraint().orElseThrow();
assertNotEquals(constraints2.hashCode(), constraints3.hashCode());
assertNotEquals(constraints2, constraints3);
- final LeafListSchemaNode constrainedLeafList4 = (LeafListSchemaNode) testModule.getDataChildByName(
- QName.create(testModule.getQNameModule(), "constrained-leaf-list-4"));
- ElementCountConstraint constraints4 = constrainedLeafList4.getElementCountConstraint().get();
+ var constraints4 = assertInstanceOf(LeafListSchemaNode.class,
+ testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "constrained-leaf-list-4")))
+ .getElementCountConstraint().orElseThrow();
assertNotEquals(constraints3.hashCode(), constraints4.hashCode());
assertNotEquals(constraints3, constraints4);
for (var expectedContainer : expectedContainers) {
assertThat(String.format("Expected container %s not found.", expectedContainer),
- schemaContext.findDataTreeChild(QName.create(FOO_NS, expectedContainer)).get(),
+ schemaContext.findDataTreeChild(QName.create(FOO_NS, expectedContainer)).orElseThrow(),
instanceOf(ContainerSchemaNode.class));
}
}
private static Set<QName> createFeaturesSet(final Set<String> featureNames) {
- final Set<QName> supportedFeatures = new HashSet<>();
+ final var supportedFeatures = new HashSet<QName>();
for (var featureName : featureNames) {
if (featureName.indexOf(':') == -1) {
supportedFeatures.add(QName.create(FOO_NS, featureName));
import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.stmt.AbstractYangTest;
class Bug6887Test extends AbstractYangTest {
-
@Test
void testRestrictedEnumeration() {
final var context = assertEffectiveModel("/rfc7950/bug6887/foo.yang");
- final Module foo = context.findModule("foo", Revision.of("2017-01-26")).get();
- final LeafSchemaNode myEnumerationLeaf = (LeafSchemaNode) foo.getDataChildByName(
- QName.create(foo.getQNameModule(), "my-enumeration-leaf"));
+ final var foo = context.findModule("foo", Revision.of("2017-01-26")).orElseThrow();
+ final var myEnumerationLeaf = assertInstanceOf(LeafSchemaNode.class,
+ foo.getDataChildByName(QName.create(foo.getQNameModule(), "my-enumeration-leaf")));
- EnumTypeDefinition enumerationType = (EnumTypeDefinition) myEnumerationLeaf.getType();
+ var enumerationType = assertInstanceOf(EnumTypeDefinition.class, myEnumerationLeaf.getType());
- List<EnumPair> enums = enumerationType.getValues();
+ var enums = enumerationType.getValues();
assertEquals(2, enums.size());
- final EnumPair yellowEnum = createEnumPair("yellow", 2);
- final EnumPair redEnum = createEnumPair("red", 3);
+ final var yellowEnum = createEnumPair("yellow", 2);
+ final var redEnum = createEnumPair("red", 3);
assertContainsEnums(enums, yellowEnum, redEnum);
enumerationType = enumerationType.getBaseType();
enums = enumerationType.getValues();
assertEquals(3, enums.size());
- final EnumPair blackEnum = createEnumPair("black", 4);
+ final var blackEnum = createEnumPair("black", 4);
assertContainsEnums(enums, yellowEnum, redEnum, blackEnum);
enumerationType = enumerationType.getBaseType();
enums = enumerationType.getValues();
assertEquals(4, enums.size());
- final EnumPair whiteEnum = createEnumPair("white", 1);
+ final var whiteEnum = createEnumPair("white", 1);
assertContainsEnums(enums, whiteEnum, yellowEnum, redEnum, blackEnum);
- final LeafSchemaNode myEnumerationLeaf2 = (LeafSchemaNode) foo.getDataChildByName(
- QName.create(foo.getQNameModule(), "my-enumeration-leaf-2"));
+ final var myEnumerationLeaf2 = assertInstanceOf(LeafSchemaNode.class, foo.getDataChildByName(
+ QName.create(foo.getQNameModule(), "my-enumeration-leaf-2")));
- enumerationType = (EnumTypeDefinition) myEnumerationLeaf2.getType();
+ enumerationType = assertInstanceOf(EnumTypeDefinition.class, myEnumerationLeaf2.getType());
enums = enumerationType.getValues();
assertEquals(3, enums.size());
assertContainsEnums(enums, yellowEnum, redEnum, blackEnum);
@Test
void testInvalidRestrictedEnumeration3() {
- assertInvalidEnumDefinitionException(startsWith("Value of enum 'red' must be the same as the value of "
- + "corresponding enum in the base enumeration type (foo?revision=2017-02-02)"
- + "my-derived-enumeration-type."), "/rfc7950/bug6887/foo-invalid-3.yang");
+ assertInvalidEnumDefinitionException(startsWith("""
+ Value of enum 'red' must be the same as the value of corresponding enum in the base enumeration type \
+ (foo?revision=2017-02-02)my-derived-enumeration-type."""), "/rfc7950/bug6887/foo-invalid-3.yang");
}
@Test
void testInvalidRestrictedEnumeration4() {
- assertInvalidEnumDefinitionException(startsWith("Value of enum 'black' must be the same as the value of "
- + "corresponding enum in the base enumeration type (foo?revision=2017-02-02)"
- + "my-base-enumeration-type."), "/rfc7950/bug6887/foo-invalid-4.yang");
+ assertInvalidEnumDefinitionException(startsWith("""
+ Value of enum 'black' must be the same as the value of corresponding enum in the base enumeration type \
+ (foo?revision=2017-02-02)my-base-enumeration-type."""), "/rfc7950/bug6887/foo-invalid-4.yang");
}
@Test
void testRestrictedBits() {
final var context = assertEffectiveModel("/rfc7950/bug6887/bar.yang");
- final Module bar = context.findModule("bar", Revision.of("2017-02-02")).get();
- final LeafSchemaNode myBitsLeaf = (LeafSchemaNode) bar.getDataChildByName(
- QName.create(bar.getQNameModule(), "my-bits-leaf"));
+ final var bar = context.findModule("bar", Revision.of("2017-02-02")).orElseThrow();
+ final var myBitsLeaf = assertInstanceOf(LeafSchemaNode.class, bar.getDataChildByName(
+ QName.create(bar.getQNameModule(), "my-bits-leaf")));
- BitsTypeDefinition bitsType = (BitsTypeDefinition) myBitsLeaf.getType();
+ var bitsType = assertInstanceOf(BitsTypeDefinition.class, myBitsLeaf.getType());
- Collection<? extends Bit> bits = bitsType.getBits();
+ var bits = bitsType.getBits();
assertEquals(2, bits.size());
- Bit bitB = createBit("bit-b", 2);
- Bit bitC = createBit("bit-c", 3);
+ var bitB = createBit("bit-b", 2);
+ var bitC = createBit("bit-c", 3);
assertContainsBits(bits, bitB, bitC);
bitsType = bitsType.getBaseType();
assertEquals(3, bits.size());
bitB = createBit("bit-b", 2);
bitC = createBit("bit-c", 3);
- Bit bitD = createBit("bit-d", 4);
+ var bitD = createBit("bit-d", 4);
assertContainsBits(bits, bitB, bitC, bitD);
bitsType = bitsType.getBaseType();
bits = bitsType.getBits();
assertEquals(4, bits.size());
- final Bit bitA = createBit("bit-a", 1);
+ final var bitA = createBit("bit-a", 1);
bitB = createBit("bit-b", 2);
bitC = createBit("bit-c", 3);
bitD = createBit("bit-d", 4);
assertContainsBits(bits, bitA, bitB, bitC, bitD);
- final LeafSchemaNode myBitsLeaf2 = (LeafSchemaNode) bar.getDataChildByName(
- QName.create(bar.getQNameModule(), "my-bits-leaf-2"));
+ final var myBitsLeaf2 = assertInstanceOf(LeafSchemaNode.class, bar.getDataChildByName(
+ QName.create(bar.getQNameModule(), "my-bits-leaf-2")));
bitsType = (BitsTypeDefinition) myBitsLeaf2.getType();
bits = bitsType.getBits();
}
private static void assertContainsEnums(final List<EnumPair> enumList, final EnumPair... enumPairs) {
- for (final EnumPair enumPair : enumPairs) {
+ for (var enumPair : enumPairs) {
assertTrue(enumList.contains(enumPair));
}
}
}
private static void assertContainsBits(final Collection<? extends Bit> bitList, final Bit... bits) {
- for (final Bit bit : bits) {
+ for (var bit : bits) {
assertTrue(bitList.contains(bit));
}
}
package org.opendaylight.yangtools.yang.parser.stmt.rfc7950;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementOrigin;
import org.opendaylight.yangtools.yang.stmt.AbstractYangTest;
void testImplicitInputAndOutputInAction() {
final var context = assertEffectiveModel("/rfc7950/bug9241/foo.yang");
- final Module fooModule = context.findModule("foo", Revision.of("2017-10-13")).get();
+ final var fooModule = context.findModule("foo", Revision.of("2017-10-13")).orElseThrow();
- final ContainerSchemaNode actionCont = (ContainerSchemaNode) fooModule.getDataChildByName(QName.create(
- fooModule.getQNameModule(), "action-cont"));
+ final var actionCont = assertInstanceOf(ContainerSchemaNode.class,
+ fooModule.getDataChildByName(QName.create(fooModule.getQNameModule(), "action-cont")));
- final ActionDefinition actionInCont = actionCont.getActions().iterator().next();
+ final var actionInCont = actionCont.getActions().iterator().next();
- final InputSchemaNode input = actionInCont.getInput();
- assertNotNull(input);
+ final var input = actionInCont.getInput();
assertEquals(1, input.getChildNodes().size());
assertEquals(StatementOrigin.CONTEXT, ((EffectiveStatement<?, ?>) input).statementOrigin());
- final OutputSchemaNode output = actionInCont.getOutput();
- assertNotNull(output);
+ final var output = actionInCont.getOutput();
assertEquals(1, output.getChildNodes().size());
assertEquals(StatementOrigin.CONTEXT, ((EffectiveStatement<?, ?>) output).statementOrigin());
}
import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import java.util.Collection;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.stmt.AbstractYangTest;
class IdentityStatementTest extends AbstractYangTest {
-
@Test
void testMultipleBaseIdentities() {
final var context = assertEffectiveModel("/rfc7950/identity-stmt/foo.yang");
- final Module foo = context.findModule("foo", Revision.of("2016-12-21")).get();
- for (final IdentitySchemaNode identity : foo.getIdentities()) {
+ final var foo = context.findModule("foo", Revision.of("2016-12-21")).orElseThrow();
+ for (var identity : foo.getIdentities()) {
if ("derived-id".equals(identity.getQName().getLocalName())) {
- final Collection<? extends IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
+ final var baseIdentities = identity.getBaseIdentities();
assertEquals(3, baseIdentities.size());
}
}
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.opendaylight.yangtools.yang.stmt.AbstractYangTest;
void testIdentityrefWithMultipleBaseIdentities() {
final var context = assertEffectiveModel("/rfc7950/identityref-stmt/foo.yang");
- final Module foo = context.findModule("foo", Revision.of("2017-01-11")).get();
+ final var foo = context.findModule("foo", Revision.of("2017-01-11")).orElseThrow();
final var identities = foo.getIdentities();
assertEquals(3, identities.size());
- final LeafSchemaNode idrefLeaf = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
- "idref-leaf"));
- final IdentityrefTypeDefinition idrefType = (IdentityrefTypeDefinition) idrefLeaf.getType();
+ final var idrefLeaf = assertInstanceOf(LeafSchemaNode.class,
+ foo.getDataChildByName(QName.create(foo.getQNameModule(), "idref-leaf")));
+ final var idrefType = assertInstanceOf(IdentityrefTypeDefinition.class, idrefLeaf.getType());
final var referencedIdentities = idrefType.getIdentities();
assertEquals(3, referencedIdentities.size());
assertThat(referencedIdentities, containsInAnyOrder(identities.toArray()));
import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import java.util.Collection;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.stmt.AbstractYangTest;
class LeafrefStatementTest extends AbstractYangTest {
-
@Test
void testRequireInstanceInLeafrefs() {
final var context = assertEffectiveModel("/rfc7950/leafref-stmt/foo.yang");
- final Module foo = context.findModule("foo", Revision.of("2016-12-20")).get();
- final Collection<? extends TypeDefinition<?>> typeDefinitions = foo.getTypeDefinitions();
+ final var foo = context.findModule("foo", Revision.of("2016-12-20")).orElseThrow();
+ final var typeDefinitions = foo.getTypeDefinitions();
assertEquals(1, typeDefinitions.size());
- final TypeDefinition<?> typeDefinition = typeDefinitions.iterator().next();
- final LeafrefTypeDefinition leafrefTypeDefinition = (LeafrefTypeDefinition) typeDefinition;
+ final var leafrefTypeDefinition = assertInstanceOf(LeafrefTypeDefinition.class,
+ typeDefinitions.iterator().next());
assertTrue(leafrefTypeDefinition.requireInstance());
- final LeafSchemaNode leafrefA = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
- "leafref-a"));
+ final var leafrefA = assertInstanceOf(LeafSchemaNode.class,
+ foo.getDataChildByName(QName.create(foo.getQNameModule(), "leafref-a")));
assertRequireInstanceInLeafref(leafrefA, true);
- final LeafSchemaNode leafrefB = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
- "leafref-b"));
+ final var leafrefB = assertInstanceOf(LeafSchemaNode.class,
+ foo.getDataChildByName(QName.create(foo.getQNameModule(), "leafref-b")));
assertRequireInstanceInLeafref(leafrefB, true);
- final LeafSchemaNode leafrefC = (LeafSchemaNode) foo.getDataChildByName(QName.create(foo.getQNameModule(),
- "leafref-c"));
+ final var leafrefC = assertInstanceOf(LeafSchemaNode.class,
+ foo.getDataChildByName(QName.create(foo.getQNameModule(), "leafref-c")));
assertRequireInstanceInLeafref(leafrefC, true);
}
private static void assertRequireInstanceInLeafref(final LeafSchemaNode leaf, final boolean requireInstance) {
- final LeafrefTypeDefinition leafrefTypeDefnition = (LeafrefTypeDefinition) leaf.getType();
- assertEquals(requireInstance, leafrefTypeDefnition.requireInstance());
+ assertEquals(requireInstance, assertInstanceOf(LeafrefTypeDefinition.class, leaf.getType()).requireInstance());
}
@Test
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-import com.google.common.collect.Range;
-import java.util.Collection;
-import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
class Bug4623Test extends AbstractYangTest {
@Test
void testStringTypeWithUnknownSchemaNodeAtTheEndOfTypeDefinition() {
// when
- final LeafSchemaNode leaf = (LeafSchemaNode) TYPES.getDataChildByName(
+ final var leaf = (LeafSchemaNode) TYPES.getDataChildByName(
QName.create(XMLNamespace.of("urn:custom.types.demo"), "leaf-length-pattern-unknown"));
// then
- final TypeDefinition<?> type = leaf.getType();
+ final var type = leaf.getType();
assertNotNull(type);
// here are no effective extensions
assertEquals(0, type.getUnknownSchemaNodes().size());
assertExtension(leaf);
- final LengthConstraint lengthConstraint = ((StringTypeDefinition) type).getLengthConstraint().get();
- final List<PatternConstraint> patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
+ final var lengthConstraint = ((StringTypeDefinition) type).getLengthConstraint().orElseThrow();
+ final var patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
assertNotNull(lengthConstraint);
assertNotNull(patternConstraints);
assertFalse(lengthConstraint.getAllowedRanges().isEmpty());
assertFalse(patternConstraints.isEmpty());
- final Range<Integer> span = lengthConstraint.getAllowedRanges().span();
+ final var span = lengthConstraint.getAllowedRanges().span();
assertEquals(Integer.valueOf(2), span.lowerEndpoint());
assertEquals(Integer.valueOf(10), span.upperEndpoint());
- final PatternConstraint patternConstraint = patternConstraints.get(0);
+ final var patternConstraint = patternConstraints.get(0);
assertEquals("[0-9a-fA-F]", patternConstraint.getRegularExpressionString());
}
@Test
void testStringTypeWithUnknownSchemaNodeBetweenStringRestrictionStatements() {
// when
- final LeafSchemaNode leaf = (LeafSchemaNode) TYPES.getDataChildByName(
+ final var leaf = (LeafSchemaNode) TYPES.getDataChildByName(
QName.create(XMLNamespace.of("urn:custom.types.demo"), "leaf-length-unknown-pattern"));
// then
assertNotNull(leaf);
- final TypeDefinition<?> type = leaf.getType();
+ final var type = leaf.getType();
assertNotNull(type);
assertEquals(0, type.getUnknownSchemaNodes().size());
assertExtension(leaf);
- final LengthConstraint lengthConstraints = ((StringTypeDefinition) type).getLengthConstraint().get();
- final List<PatternConstraint> patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
+ final var lengthConstraints = ((StringTypeDefinition) type).getLengthConstraint().orElseThrow();
+ final var patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
assertNotNull(lengthConstraints);
assertNotNull(patternConstraints);
assertEquals(1, lengthConstraints.getAllowedRanges().asRanges().size());
assertFalse(patternConstraints.isEmpty());
- final Range<Integer> lengthConstraint = lengthConstraints.getAllowedRanges().span();
+ final var lengthConstraint = lengthConstraints.getAllowedRanges().span();
assertEquals(Integer.valueOf(2), lengthConstraint.lowerEndpoint());
assertEquals(Integer.valueOf(10), lengthConstraint.upperEndpoint());
- final PatternConstraint patternConstraint = patternConstraints.get(0);
+ final var patternConstraint = patternConstraints.get(0);
assertEquals("[0-9a-fA-F]", patternConstraint.getRegularExpressionString());
}
@Test
void testStringTypeWithUnknownSchemaNodeOnTheStartOfTypeDefinition() {
// when
- final LeafSchemaNode leaf = (LeafSchemaNode) TYPES.getDataChildByName(
- QName.create(XMLNamespace.of("urn:custom.types.demo"), "leaf-unknown-length-pattern"));
+ final var leaf = (LeafSchemaNode) TYPES.getDataChildByName(
+ QName.create(XMLNamespace.of("urn:custom.types.demo"), "leaf-unknown-length-pattern"));
// then
- final TypeDefinition<?> type = leaf.getType();
+ final var type = leaf.getType();
assertNotNull(type);
assertEquals(0, type.getUnknownSchemaNodes().size());
assertExtension(leaf);
- final LengthConstraint lengthConstraints =
- ((StringTypeDefinition) type).getLengthConstraint().get();
+ final var lengthConstraints = ((StringTypeDefinition) type).getLengthConstraint().orElseThrow();
assertEquals(1, lengthConstraints.getAllowedRanges().asRanges().size());
- final Range<Integer> lengthConstraint = lengthConstraints.getAllowedRanges().span();
+ final var lengthConstraint = lengthConstraints.getAllowedRanges().span();
assertEquals(Integer.valueOf(2), lengthConstraint.lowerEndpoint());
assertEquals(Integer.valueOf(10), lengthConstraint.upperEndpoint());
- final List<PatternConstraint> patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
+ final var patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
assertEquals(1, patternConstraints.size());
- final PatternConstraint patternConstraint = patternConstraints.get(0);
+ final var patternConstraint = patternConstraints.get(0);
assertEquals("[0-9a-fA-F]", patternConstraint.getRegularExpressionString());
}
private static void assertExtension(final LeafSchemaNode leaf) {
- final Collection<? extends UnrecognizedStatement> unknownSchemaNodes = leaf.asEffectiveStatement().getDeclared()
+ final var unknownSchemaNodes = leaf.asEffectiveStatement().getDeclared()
.findFirstDeclaredSubstatement(TypeStatement.class).orElseThrow()
.declaredSubstatements(UnrecognizedStatement.class);
assertEquals(1, unknownSchemaNodes.size());
- final UnrecognizedStatement unknownSchemaNode = unknownSchemaNodes.iterator().next();
+ final var unknownSchemaNode = unknownSchemaNodes.iterator().next();
assertEquals("unknown", unknownSchemaNode.argument());
assertEquals(QName.create("urn:simple.extension.typedefs", "unknown"),
unknownSchemaNode.statementDefinition().getStatementName());
}
-}
\ No newline at end of file
+}
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import java.util.List;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
QName root = QName.create("foo", "root");
QName myLeaf2 = QName.create("foo", "my-leaf2");
- SchemaNode findDataSchemaNode = context.findDataTreeChild(root, myLeaf2).get();
+ var findDataSchemaNode = context.findDataTreeChild(root, myLeaf2).orElseThrow();
- LeafSchemaNode leaf2 = assertInstanceOf(LeafSchemaNode.class, findDataSchemaNode);
- TypeDefinition<?> type = leaf2.getType();
-
- UnionTypeDefinition union = assertInstanceOf(UnionTypeDefinition.class, type);
- List<TypeDefinition<?>> types = union.getTypes();
+ var leaf2 = assertInstanceOf(LeafSchemaNode.class, findDataSchemaNode);
+ var union = assertInstanceOf(UnionTypeDefinition.class, leaf2.getType());
+ var types = union.getTypes();
assertEquals(4, types.size());
- TypeDefinition<?> type0 = types.get(0);
- TypeDefinition<?> type1 = types.get(1);
- TypeDefinition<?> type2 = types.get(2);
- TypeDefinition<?> type3 = types.get(3);
+ var type0 = types.get(0);
+ var type1 = types.get(1);
+ var type2 = types.get(2);
+ var type3 = types.get(3);
assertNotEquals(type0, type1);
assertNotEquals(type0, type2);
assertNotEquals(type0, type3);
- StringTypeDefinition stringType0 = assertInstanceOf(StringTypeDefinition.class, type0);
- StringTypeDefinition stringType1 = assertInstanceOf(StringTypeDefinition.class, type1);
- StringTypeDefinition stringType2 = assertInstanceOf(StringTypeDefinition.class, type2);
- StringTypeDefinition stringType3 = assertInstanceOf(StringTypeDefinition.class, type3);
+ var stringType0 = assertInstanceOf(StringTypeDefinition.class, type0);
+ var stringType1 = assertInstanceOf(StringTypeDefinition.class, type1);
+ var stringType2 = assertInstanceOf(StringTypeDefinition.class, type2);
+ var stringType3 = assertInstanceOf(StringTypeDefinition.class, type3);
- final List<PatternConstraint> patternConstraints0 = stringType0.getPatternConstraints();
- final List<PatternConstraint> patternConstraints1 = stringType1.getPatternConstraints();
- final List<PatternConstraint> patternConstraints2 = stringType2.getPatternConstraints();
- final List<PatternConstraint> patternConstraints3 = stringType3.getPatternConstraints();
+ final var patternConstraints0 = stringType0.getPatternConstraints();
+ final var patternConstraints1 = stringType1.getPatternConstraints();
+ final var patternConstraints2 = stringType2.getPatternConstraints();
+ final var patternConstraints3 = stringType3.getPatternConstraints();
assertEquals(1, patternConstraints0.size());
assertEquals(1, patternConstraints1.size());
assertEquals(1, patternConstraints2.size());
assertEquals(1, patternConstraints3.size());
- final PatternConstraint patternConstraint0 = patternConstraints0.get(0);
- final PatternConstraint patternConstraint1 = patternConstraints1.get(0);
- final PatternConstraint patternConstraint2 = patternConstraints2.get(0);
- final PatternConstraint patternConstraint3 = patternConstraints3.get(0);
+ final var patternConstraint0 = patternConstraints0.get(0);
+ final var patternConstraint1 = patternConstraints1.get(0);
+ final var patternConstraint2 = patternConstraints2.get(0);
+ final var patternConstraint3 = patternConstraints3.get(0);
assertEquals("^(?:dp[0-9]+o[0-9]+(d[0-9]+)?)$", patternConstraint0.getJavaPatternString());
assertEquals("^(?:dp[0-9]+s[0-9]+(f[0-9]+)?(d[0-9]+)?)$", patternConstraint1.getJavaPatternString());
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class Bug5884Test extends AbstractYangTest {
- private static final String NS = "urn:yang.foo";
- private static final String REV = "2016-01-01";
-
@Test
void testBug5884() {
final var context = assertEffectiveModelDir("/bugs/bug5884");
-
- final QName root = QName.create(NS, REV, "main-container");
- final QName choice = QName.create(NS, REV, "test-choice");
- final QName testContainerQname = QName.create(NS, REV, "test");
- final Module foo = context.findModule("foo", Revision.of("2016-01-01")).get();
- final ContainerSchemaNode rootContainer = (ContainerSchemaNode) context.getDataChildByName(root);
- final ContainerSchemaNode testContainer = (ContainerSchemaNode) rootContainer.getDataChildByName(
- testContainerQname);
- final ChoiceSchemaNode dataChildByName = (ChoiceSchemaNode) testContainer.getDataChildByName(choice);
+ final var root = QName.create("urn:yang.foo", "2016-01-01", "main-container");
+ final var foo = context.findModule("foo", Revision.of("2016-01-01")).orElseThrow();
+ final var rootContainer = assertInstanceOf(ContainerSchemaNode.class, context.getDataChildByName(root));
+ final var testContainer = assertInstanceOf(ContainerSchemaNode.class,
+ rootContainer.getDataChildByName(QName.create(root, "test")));
+ final var dataChildByName = assertInstanceOf(ChoiceSchemaNode.class,
+ testContainer.getDataChildByName(QName.create(root, "test-choice")));
testIterator(foo.getAugmentations().iterator());
testIterator(dataChildByName.getAvailableAugmentations().iterator());
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
assertInstanceOf(ContainerSchemaNode.class, context.getDataChildByName(foo("before")));
assertInstanceOf(ContainerSchemaNode.class, context.getDataChildByName(foo("after")));
- final DataSchemaNode dataChildByName = context.getDataChildByName(foo("my-choice"));
- final ChoiceSchemaNode myChoice = assertInstanceOf(ChoiceSchemaNode.class, dataChildByName);
+ final var dataChildByName = context.getDataChildByName(foo("my-choice"));
+ final var myChoice = assertInstanceOf(ChoiceSchemaNode.class, dataChildByName);
assertEquals(4, myChoice.getCases().size());
assertEquals(2, implCase.getChildNodes().size());
assertTrue(getLeafSchemaNode(implCase, "leaf-after-container").isAugmenting());
- final ContainerSchemaNode implCaseContainer = getContainerSchemaNode(implCase, "implicit-case-container");
+ final var implCaseContainer = getContainerSchemaNode(implCase, "implicit-case-container");
assertEquals(3, implCaseContainer.getChildNodes().size());
assertTrue(getLeafSchemaNode(implCaseContainer, "leaf-inside-container").isAugmenting());
assertFalse(getLeafSchemaNode(implCaseContainer, "declared-leaf-in-case-container").isAugmenting());
- final ContainerSchemaNode declContInCaseCont = getContainerSchemaNode(implCaseContainer,
+ final var declContInCaseCont = getContainerSchemaNode(implCaseContainer,
"declared-container-in-case-container");
assertEquals(1, declContInCaseCont.getChildNodes().size());
assertEquals(2, secondImplCase.getChildNodes().size());
assertTrue(getLeafSchemaNode(secondImplCase, "leaf-after-second-container").isAugmenting());
- final ContainerSchemaNode secondImplCaseContainer = getContainerSchemaNode(secondImplCase,
- "second-implicit-case-container");
+ final var secondImplCaseContainer = getContainerSchemaNode(secondImplCase, "second-implicit-case-container");
assertEquals(2, secondImplCaseContainer.getChildNodes().size());
assertTrue(getLeafSchemaNode(secondImplCaseContainer, "leaf-inside-second-container").isAugmenting());
private static ContainerSchemaNode getContainerSchemaNode(final DataNodeContainer parent,
final String containerName) {
- final DataSchemaNode dataChildByName = parent.getDataChildByName(foo(containerName));
- return assertInstanceOf(ContainerSchemaNode.class, dataChildByName);
+ return assertInstanceOf(ContainerSchemaNode.class, parent.getDataChildByName(foo(containerName)));
}
private static LeafSchemaNode getLeafSchemaNode(final DataNodeContainer parent, final String leafName) {
- final DataSchemaNode dataChildByName = parent.getDataChildByName(foo(leafName));
- return assertInstanceOf(LeafSchemaNode.class, dataChildByName);
+ return assertInstanceOf(LeafSchemaNode.class, parent.getDataChildByName(foo(leafName)));
}
private static QName foo(final String localName) {
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertSame;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
class Bug6972Test extends AbstractYangTest {
private static UnitsEffectiveStatement getEffectiveUnits(final Module module, final QName containerQName,
final QName leafQName) {
- final var cont = (ContainerSchemaNode) module.getDataChildByName(containerQName);
- assertNotNull(cont);
- final var leaf = (LeafSchemaNode) cont.getDataChildByName(leafQName);
- assertNotNull(leaf);
-
- return ((LeafEffectiveStatement) leaf).streamEffectiveSubstatements(UnitsEffectiveStatement.class)
+ final var cont = assertInstanceOf(ContainerSchemaNode.class, module.getDataChildByName(containerQName));
+ return assertInstanceOf(LeafSchemaNode.class, cont.getDataChildByName(leafQName)).asEffectiveStatement()
+ .streamEffectiveSubstatements(UnitsEffectiveStatement.class)
.findFirst()
.orElse(null);
}
final var schemaContext = assertEffectiveModelDir("/bugs/bug7440");
final var revision = Revision.of("2016-12-23");
- final var foo = schemaContext.findModule("foo", revision).get();
- final var bar = schemaContext.findModule("bar", revision).get();
+ final var foo = schemaContext.findModule("foo", revision).orElseThrow();
+ final var bar = schemaContext.findModule("bar", revision).orElseThrow();
final var deviations = foo.getDeviations();
assertEquals(1, deviations.size());
final var subFoos = foo.iterator().next().getSubmodules();
assertEquals(1, subFoos.size());
- final var parentMod = context.findModule(XMLNamespace.of("parent-mod-ns"), Revision.of("2017-09-07")).get();
+ final var parentMod = context.findModule(XMLNamespace.of("parent-mod-ns"), Revision.of("2017-09-07"))
+ .orElseThrow();
assertEquals(1, parentMod.getSubmodules().size());
}
void missingRelevantImportTest() throws Exception {
final var ex = assertThrows(SomeModifiersUnresolvedException.class,
() -> parseYangSources("/bugs/bug7480/files-2", "/bugs/bug7480/lib-2"));
- final String message = ex.getSuppressed().length > 0
- ? ex.getSuppressed()[0].getMessage() : ex.getCause().getMessage();
+ final var message = ex.getSuppressed().length > 0 ? ex.getSuppressed()[0].getMessage()
+ : ex.getCause().getMessage();
assertThat(message, startsWith("Imported module [missing-lib] was not found."));
}
}
private static EffectiveModelContext parseYangSources(final String yangFilesDirectoryPath,
- final String yangLibsDirectoryPath) throws Exception {
+ final String yangLibsDirectoryPath) throws Exception {
return RFC7950Reactors.defaultReactor().newBuild()
.addSources(TestUtils.loadSources(yangFilesDirectoryPath))
.addLibSources(TestUtils.loadSources(yangLibsDirectoryPath))
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class Bug9244Test extends AbstractYangTest {
@Test
void testDeviateReplaceOfImplicitSubstatements() {
final var schemaContext = assertEffectiveModelDir("/bugs/bug9244/");
- final Module barModule = schemaContext.findModule("bar", Revision.of("2017-10-13")).get();
- final ContainerSchemaNode barCont = (ContainerSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "bar-cont"));
+ final var barModule = schemaContext.findModule("bar", Revision.of("2017-10-13")).orElseThrow();
+ final var barCont = assertInstanceOf(ContainerSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "bar-cont")));
assertEquals(Optional.of(Boolean.FALSE), barCont.effectiveConfig());
- final LeafListSchemaNode barLeafList = (LeafListSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "bar-leaf-list"));
- final ElementCountConstraint constraint = barLeafList.getElementCountConstraint().get();
+ final var barLeafList = assertInstanceOf(LeafListSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "bar-leaf-list")));
+ final var constraint = barLeafList.getElementCountConstraint().orElseThrow();
assertEquals(5, constraint.getMinElements());
assertEquals(10, constraint.getMaxElements());
- final LeafSchemaNode barLeaf = (LeafSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "bar-leaf"));
+ final var barLeaf = assertInstanceOf(LeafSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "bar-leaf")));
assertTrue(barLeaf.isMandatory());
}
}
void setup() {
schema = assertEffectiveModelDir("/case-test");
Revision rev = Revision.of("2015-09-09");
- rootFoo = schema.findModule("foo", rev).get();
- rootBar = schema.findModule("bar", rev).get();
+ rootFoo = schema.findModule("foo", rev).orElseThrow();
+ rootBar = schema.findModule("bar", rev).orElseThrow();
assertNotNull(rootFoo);
assertNotNull(rootBar);
qnameFoo = QNameModule.create(XMLNamespace.of("foo"), rev);
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.api.Test;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
class ChoiceStmtTest extends AbstractModelTest {
@Test
void choiceAndCaseTest() {
- final ContainerSchemaNode container = (ContainerSchemaNode) FOO.getDataChildByName(fooQName("transfer"));
- final ChoiceSchemaNode choice = (ChoiceSchemaNode) container.getDataChildByName(fooQName("how"));
+ final var container = assertInstanceOf(ContainerSchemaNode.class, FOO.getDataChildByName(fooQName("transfer")));
+ final var choice = assertInstanceOf(ChoiceSchemaNode.class, container.getDataChildByName(fooQName("how")));
assertEquals(5, choice.getCases().size());
- CaseSchemaNode caseNode = choice.findCaseNodes("input").iterator().next();
+ var caseNode = choice.findCaseNodes("input").iterator().next();
assertNotNull(caseNode);
caseNode = choice.findCaseNodes("output").iterator().next();
assertNotNull(caseNode);
assertNotNull(caseNode);
caseNode = choice.findCaseNodes("manual").iterator().next();
assertNotNull(caseNode);
- assertEquals("interval", choice.getDefaultCase().get().getQName().getLocalName());
+ assertEquals("interval", choice.getDefaultCase().orElseThrow().getQName().getLocalName());
}
}
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import java.util.Collection;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement;
class ControllerStmtParserTest extends AbstractYangTest {
- @Test
- void test() {
- final var context = assertEffectiveModelDir("/sal-broker-impl");
- salDomBrokerImplModuleTest(context);
- configModuleTest(context);
+ private static EffectiveModelContext CONTEXT;
+
+ @BeforeEach
+ void before() {
+ CONTEXT = assertEffectiveModelDir("/sal-broker-impl");
}
- private static void salDomBrokerImplModuleTest(final SchemaContext context) {
- final Module module = context.findModule("opendaylight-sal-dom-broker-impl", Revision.of("2013-10-28")).get();
+ @Test
+ public void salDomBrokerImplModuleTest() {
+ final var module = CONTEXT.findModule("opendaylight-sal-dom-broker-impl", Revision.of("2013-10-28"))
+ .orElseThrow();
boolean checked = false;
- for (final AugmentationSchemaNode augmentationSchema : module.getAugmentations()) {
- final DataSchemaNode dataNode = augmentationSchema.dataChildByName(
+ for (var augmentationSchema : module.getAugmentations()) {
+ final var dataNode = augmentationSchema.dataChildByName(
QName.create(module.getQNameModule(), "dom-broker-impl"));
if (dataNode instanceof CaseSchemaNode caseNode) {
final DataSchemaNode dataNode2 = caseNode.dataChildByName(
.getDataChildByName(QName.create(module.getQNameModule(), "type"));
assertEquals(0, leaf.getUnknownSchemaNodes().size());
- final Collection<? extends UnrecognizedStatement> unknownSchemaNodes =
- containerNode.asEffectiveStatement()
+ final var unknownSchemaNodes = containerNode.asEffectiveStatement()
.findFirstEffectiveSubstatement(UsesEffectiveStatement.class).orElseThrow()
.findFirstEffectiveSubstatement(RefineEffectiveStatement.class).orElseThrow()
.getDeclared().declaredSubstatements(UnrecognizedStatement.class);
- final UnrecognizedStatement unknownSchemaNode = unknownSchemaNodes.iterator().next();
+ final var unknownSchemaNode = unknownSchemaNodes.iterator().next();
assertEquals("sal:dom-async-data-broker", unknownSchemaNode.argument());
checked = true;
}
assertTrue(checked);
}
- private static void configModuleTest(final SchemaContext context) {
- final Module configModule = context.findModule("config", Revision.of("2013-04-05")).get();
- final Module module = context.findModule("opendaylight-sal-dom-broker-impl", Revision.of("2013-10-28")).get();
+ @Test
+ public void configModuleTest() {
+ final var configModule = CONTEXT.findModule("config", Revision.of("2013-04-05")).orElseThrow();
+ final var module = CONTEXT.findModule("opendaylight-sal-dom-broker-impl", Revision.of("2013-10-28"))
+ .orElseThrow();
final DataSchemaNode dataNode = configModule.getDataChildByName(QName.create(configModule.getQNameModule(),
"modules"));
final ContainerSchemaNode schemaServiceContainer = assertInstanceOf(ContainerSchemaNode.class, schemaService);
assertEquals(1, schemaServiceContainer.getUses().size());
- final UsesNode uses = schemaServiceContainer.getUses().iterator().next();
+ final var uses = schemaServiceContainer.getUses().iterator().next();
final QName groupingQName = QName.create("urn:opendaylight:params:xml:ns:yang:controller:config", "2013-04-05",
"service-ref");
assertEquals(groupingQName, uses.getSourceGrouping().getQName());
assertEquals(0, getChildNodeSizeWithoutUses(schemaServiceContainer));
- final DataSchemaNode type = schemaServiceContainer.getDataChildByName(QName.create(module.getQNameModule(),
- "type"));
+ final var type = schemaServiceContainer.getDataChildByName(QName.create(module.getQNameModule(), "type"));
assertEquals(0, type.getUnknownSchemaNodes().size());
- final Collection<? extends UnrecognizedStatement> typeUnknownSchemaNodes =
- schemaServiceContainer.asEffectiveStatement()
+ final var typeUnknownSchemaNodes = schemaServiceContainer.asEffectiveStatement()
.findFirstEffectiveSubstatement(UsesEffectiveStatement.class).orElseThrow()
.findFirstEffectiveSubstatement(RefineEffectiveStatement.class).orElseThrow()
.getDeclared().declaredSubstatements(UnrecognizedStatement.class);
assertEquals(1, typeUnknownSchemaNodes.size());
- final UnrecognizedStatement typeUnknownSchemaNode = typeUnknownSchemaNodes.iterator().next();
+ final var typeUnknownSchemaNode = typeUnknownSchemaNodes.iterator().next();
assertEquals("sal:schema-service", typeUnknownSchemaNode.argument());
assertEquals(QName.create(groupingQName, "required-identity"),
typeUnknownSchemaNode.statementDefinition().getStatementName());
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
class DeviationResolutionTest extends AbstractYangTest {
@Test
void testDeviateNotSupported() {
final var schemaContext = assertEffectiveModelDir("/deviation-resolution-test/deviation-not-supported");
- assertNotNull(schemaContext);
- final Module importedModule = schemaContext.findModule("imported", Revision.of("2017-01-20")).get();
- final ContainerSchemaNode myContA = (ContainerSchemaNode) importedModule.getDataChildByName(
- QName.create(importedModule.getQNameModule(), "my-cont-a"));
- assertNotNull(myContA);
+ final var importedModule = schemaContext.findModule("imported", Revision.of("2017-01-20")).orElseThrow();
+ final var myContA = assertInstanceOf(ContainerSchemaNode.class,
+ importedModule.getDataChildByName(QName.create(importedModule.getQNameModule(), "my-cont-a")));
assertEquals(1, myContA.getChildNodes().size());
assertNotNull(myContA.getDataChildByName(QName.create(importedModule.getQNameModule(), "my-leaf-a3")));
- final ContainerSchemaNode myContB = (ContainerSchemaNode) importedModule.dataChildByName(
- QName.create(importedModule.getQNameModule(), "my-cont-b"));
- assertNull(myContB);
+ assertNull(importedModule.dataChildByName(QName.create(importedModule.getQNameModule(), "my-cont-b")));
- final ContainerSchemaNode myContC = (ContainerSchemaNode) importedModule.getDataChildByName(
- QName.create(importedModule.getQNameModule(), "my-cont-c"));
- assertNotNull(myContC);
+ final var myContC = assertInstanceOf(ContainerSchemaNode.class,
+ importedModule.getDataChildByName(QName.create(importedModule.getQNameModule(), "my-cont-c")));
assertEquals(2, myContC.getChildNodes().size());
assertNotNull(myContC.getDataChildByName(QName.create(importedModule.getQNameModule(), "my-leaf-c1")));
"/deviation-resolution-test/deviation-add/foo.yang",
"/deviation-resolution-test/deviation-add/bar.yang");
- final Module barModule = schemaContext.findModule("bar", Revision.of("2017-01-20")).get();
- final LeafListSchemaNode myLeafList = (LeafListSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-leaf-list"));
- assertNotNull(myLeafList);
+ final var barModule = schemaContext.findModule("bar", Revision.of("2017-01-20")).orElseThrow();
+ final var myLeafList = assertInstanceOf(LeafListSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-leaf-list")));
assertEquals(Optional.of(Boolean.FALSE), myLeafList.effectiveConfig());
assertEquals(3, myLeafList.getDefaults().size());
- final ElementCountConstraint constraint = myLeafList.getElementCountConstraint().get();
+ final var constraint = myLeafList.getElementCountConstraint().orElseThrow();
assertEquals((Object) 10, constraint.getMaxElements());
assertEquals((Object) 5, constraint.getMinElements());
assertNotNull(myLeafList.getType().getUnits());
- final ListSchemaNode myList = (ListSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-list"));
- assertNotNull(myList);
+ final var myList = assertInstanceOf(ListSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-list")));
assertEquals(2, myList.getUniqueConstraints().size());
- final ChoiceSchemaNode myChoice = (ChoiceSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-choice"));
- assertNotNull(myChoice);
- assertEquals("c2", myChoice.getDefaultCase().get().getQName().getLocalName());
+ final var myChoice = assertInstanceOf(ChoiceSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-choice")));
+ assertEquals("c2", myChoice.getDefaultCase().orElseThrow().getQName().getLocalName());
- final RpcDefinition myRpc = barModule.getRpcs().iterator().next();
- final InputSchemaNode input = myRpc.getInput();
+ final var myRpc = barModule.getRpcs().iterator().next();
+ final var input = myRpc.getInput();
assertEquals(2, input.getMustConstraints().size());
- final OutputSchemaNode output = myRpc.getOutput();
+ final var output = myRpc.getOutput();
assertEquals(2, output.getMustConstraints().size());
- final NotificationDefinition myNotification = barModule.getNotifications().iterator().next();
+ final var myNotification = barModule.getNotifications().iterator().next();
assertEquals(2, myNotification.getMustConstraints().size());
- final AnyxmlSchemaNode myAnyxml = (AnyxmlSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-anyxml"));
- assertNotNull(myAnyxml);
+ final var myAnyxml = assertInstanceOf(AnyxmlSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-anyxml")));
assertTrue(myAnyxml.isMandatory());
- final AnydataSchemaNode myAnyData = (AnydataSchemaNode) barModule.findDataChildByName(
- QName.create(barModule.getQNameModule(), "my-anydata")).orElse(null);
- assertNotNull(myAnyData);
+ final var myAnyData = assertInstanceOf(AnydataSchemaNode.class,
+ barModule.findDataChildByName(QName.create(barModule.getQNameModule(), "my-anydata")).orElseThrow());
assertTrue(myAnyData.isMandatory());
}
"/deviation-resolution-test/deviation-replace/foo.yang",
"/deviation-resolution-test/deviation-replace/bar.yang");
- final Module barModule = schemaContext.findModule("bar", Revision.of("2017-01-20")).get();
- assertNotNull(barModule);
-
- final LeafSchemaNode myLeaf = (LeafSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-leaf"));
- assertNotNull(myLeaf);
+ final var barModule = schemaContext.findModule("bar", Revision.of("2017-01-20")).orElseThrow();
+ final var myLeaf = assertInstanceOf(LeafSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-leaf")));
assertInstanceOf(Uint32TypeDefinition.class, myLeaf.getType());
assertEquals(Optional.of("bytes"), myLeaf.getType().getUnits());
assertEquals(Optional.of("10"), myLeaf.getType().getDefaultValue());
- final LeafListSchemaNode myLeafList = (LeafListSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-leaf-list-test"));
- assertNotNull(myLeafList);
-
- final ElementCountConstraint constraint = myLeafList.getElementCountConstraint().get();
+ final var myLeafList = assertInstanceOf(LeafListSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-leaf-list-test")));
+ final var constraint = myLeafList.getElementCountConstraint().orElseThrow();
assertEquals((Object) 6, constraint.getMaxElements());
assertEquals((Object) 3, constraint.getMinElements());
assertEquals(Optional.of(Boolean.TRUE), myLeafList.effectiveConfig());
- final ChoiceSchemaNode myChoice = (ChoiceSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-choice"));
- assertNotNull(myChoice);
-
+ final var myChoice = assertInstanceOf(ChoiceSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-choice")));
assertFalse(myChoice.isMandatory());
// FIXME: we need a supported extension to properly test this
assertEquals(0, myChoice.getUnknownSchemaNodes().size());
- final ContainerSchemaNode myCont = (ContainerSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-cont"));
- assertNotNull(myCont);
+ final var myCont = assertInstanceOf(ContainerSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-cont")));
- final LeafSchemaNode myAugLeaf = (LeafSchemaNode) myCont.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-aug-leaf"));
+ final var myAugLeaf = assertInstanceOf(LeafSchemaNode.class,
+ myCont.getDataChildByName(QName.create(barModule.getQNameModule(), "my-aug-leaf")));
assertNotNull(myAugLeaf);
assertInstanceOf(Uint32TypeDefinition.class, myAugLeaf.getType());
assertEquals(Optional.of("seconds"), myAugLeaf.getType().getUnits());
// FIXME: we need a supported extension to properly test this
assertEquals(0, myAugLeaf.getUnknownSchemaNodes().size());
- final LeafSchemaNode myUsedLeaf = (LeafSchemaNode) myCont.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-used-leaf"));
- assertNotNull(myUsedLeaf);
+ final var myUsedLeaf = assertInstanceOf(LeafSchemaNode.class,
+ myCont.getDataChildByName(QName.create(barModule.getQNameModule(), "my-used-leaf")));
assertInstanceOf(Uint32TypeDefinition.class, myUsedLeaf.getType());
assertEquals(Optional.of("weeks"), myUsedLeaf.getType().getUnits());
assertEquals(Optional.of("new-def-val"), myUsedLeaf.getType().getDefaultValue());
"/deviation-resolution-test/deviation-delete/foo.yang",
"/deviation-resolution-test/deviation-delete/bar.yang");
- final Module barModule = schemaContext.findModule("bar", Revision.of("2017-01-20")).get();
- final LeafSchemaNode myLeaf = (LeafSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-leaf"));
- assertNotNull(myLeaf);
+ final var barModule = schemaContext.findModule("bar", Revision.of("2017-01-20")).orElseThrow();
+ final var myLeaf = assertInstanceOf(LeafSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-leaf")));
assertEquals(Optional.empty(), myLeaf.getType().getDefaultValue());
assertEquals(Optional.empty(), myLeaf.getType().getUnits());
assertEquals(0, myLeaf.getUnknownSchemaNodes().size());
- final LeafListSchemaNode myLeafList = (LeafListSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-leaf-list"));
- assertNotNull(myLeafList);
-
+ final var myLeafList = assertInstanceOf(LeafListSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-leaf-list")));
assertEquals(0, myLeafList.getDefaults().size());
assertEquals(0, myLeafList.getMustConstraints().size());
- final ListSchemaNode myList = (ListSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-list"));
- assertNotNull(myList);
-
+ final var myList = assertInstanceOf(ListSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-list")));
assertEquals(0, myList.getUniqueConstraints().size());
assertEquals(0, myList.getUnknownSchemaNodes().size());
- final ContainerSchemaNode myCont = (ContainerSchemaNode) barModule.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-cont"));
- assertNotNull(myCont);
-
- final LeafSchemaNode myAugLeaf = (LeafSchemaNode) myCont.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-aug-leaf"));
- assertNotNull(myAugLeaf);
+ final var myCont = assertInstanceOf(ContainerSchemaNode.class,
+ barModule.getDataChildByName(QName.create(barModule.getQNameModule(), "my-cont")));
+ final var myAugLeaf = assertInstanceOf(LeafSchemaNode.class,
+ myCont.getDataChildByName(QName.create(barModule.getQNameModule(), "my-aug-leaf")));
assertEquals(Optional.empty(), myAugLeaf.getType().getDefaultValue());
assertEquals(Optional.empty(), myAugLeaf.getType().getUnits());
assertEquals(0, myAugLeaf.getMustConstraints().size());
assertEquals(0, myAugLeaf.getUnknownSchemaNodes().size());
- final LeafSchemaNode myUsedLeaf = (LeafSchemaNode) myCont.getDataChildByName(
- QName.create(barModule.getQNameModule(), "my-used-leaf"));
+ final var myUsedLeaf = assertInstanceOf(LeafSchemaNode.class,
+ myCont.getDataChildByName(QName.create(barModule.getQNameModule(), "my-used-leaf")));
assertNotNull(myUsedLeaf);
assertEquals(Optional.empty(), myUsedLeaf.getType().getDefaultValue());
assertEquals(Optional.empty(), myUsedLeaf.getType().getUnits());
@Test
void shouldFailOnInvalidDeviateAdd() {
- assertInferenceException(startsWith("Deviation cannot add substatement (urn:ietf:params:xml:ns:yang"
- + ":yin:1)config to target node (bar?revision=2017-01-20)my-leaf because it is already defined in"
- + " target and can appear only once."),
+ assertInferenceException(startsWith("""
+ Deviation cannot add substatement (urn:ietf:params:xml:ns:yang:yin:1)config to target node \
+ (bar?revision=2017-01-20)my-leaf because it is already defined in target and can appear only once."""),
"/deviation-resolution-test/deviation-add/foo-invalid.yang",
"/deviation-resolution-test/deviation-add/bar-invalid.yang");
}
@Test
void shouldFailOnInvalidDeviateAdd2() {
- assertInferenceException(startsWith("Deviation cannot add substatement (urn:ietf:params:xml:ns:yang"
- + ":yin:1)default to target node (bar?revision=2017-01-20)my-leaf because it is already defined in"
- + " target and can appear only once."),
+ assertInferenceException(startsWith("""
+ Deviation cannot add substatement (urn:ietf:params:xml:ns:yang:yin:1)default to target node \
+ (bar?revision=2017-01-20)my-leaf because it is already defined in target and can appear only once."""),
"/deviation-resolution-test/deviation-add/foo-invalid-2.yang",
"/deviation-resolution-test/deviation-add/bar-invalid-2.yang");
}
@Test
void shouldFailOnInvalidDeviateAdd3() {
- assertInferenceException(startsWith("Deviation cannot add substatement (urn:ietf:params:xml:ns:yang"
- + ":yin:1)default to target node (bar?revision=2017-02-01)my-used-leaf because it is already "
- + "defined in target and can appear only once."),
+ assertInferenceException(startsWith("""
+ Deviation cannot add substatement (urn:ietf:params:xml:ns:yang:yin:1)default to target node \
+ (bar?revision=2017-02-01)my-used-leaf because it is already defined in target and can appear only once."""),
"/deviation-resolution-test/deviation-add/foo-invalid-4.yang",
"/deviation-resolution-test/deviation-add/bar-invalid-4.yang");
}
@Test
void shouldFailOnInvalidDeviateReplace() {
- assertInferenceException(startsWith("Deviation cannot replace substatement "
- + "(urn:ietf:params:xml:ns:yang:yin:1)units in target node (bar?revision=2017-01-20)my-leaf "
- + "because it does not exist in target node."),
+ assertInferenceException(startsWith("""
+ Deviation cannot replace substatement (urn:ietf:params:xml:ns:yang:yin:1)units in target node \
+ (bar?revision=2017-01-20)my-leaf because it does not exist in target node."""),
"/deviation-resolution-test/deviation-replace/foo-invalid.yang",
"/deviation-resolution-test/deviation-replace/bar-invalid.yang");
}
@Test
@SuppressWarnings("checkstyle:regexpSinglelineJava")
void shouldLogInvalidDeviateReplaceAttempt() throws Exception {
- final PrintStream stdout = System.out;
- final ByteArrayOutputStream output = new ByteArrayOutputStream();
- final String testLog;
+ final var stdout = System.out;
+ final var output = new ByteArrayOutputStream();
System.setOut(new PrintStream(output, true, StandardCharsets.UTF_8));
"/deviation-resolution-test/deviation-replace/foo-invalid-2.yang",
"/deviation-resolution-test/deviation-replace/bar-invalid-2.yang");
- testLog = output.toString();
+ final var testLog = output.toString();
System.setOut(stdout);
- assertThat(testLog, containsString(
- "Deviation cannot replace substatement (urn:ietf:params:xml:ns:yang:yin:1)default in target leaf-list "
- + "(bar?revision=2017-01-20)my-leaf-list because a leaf-list can have multiple "
- + "default statements."));
+ assertThat(testLog, containsString("""
+ Deviation cannot replace substatement (urn:ietf:params:xml:ns:yang:yin:1)default in target leaf-list \
+ (bar?revision=2017-01-20)my-leaf-list because a leaf-list can have multiple default statements."""));
}
@Test
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.DeviateDefinition;
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
import org.opendaylight.yangtools.yang.model.api.Deviation;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
+import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangStatementStreamSource;
class DeviationStmtTest {
-
- private static final StatementStreamSource FOO_MODULE = sourceForResource("/deviation-stmt-test/foo.yang");
- private static final StatementStreamSource FOO_IMP_MODULE = sourceForResource("/deviation-stmt-test/foo-imp.yang");
- private static final StatementStreamSource BAR_MODULE = sourceForResource("/deviation-stmt-test/bar.yang");
- private static final StatementStreamSource BAR_IMP_MODULE = sourceForResource("/deviation-stmt-test/bar-imp.yang");
+ private static final YangStatementStreamSource FOO_MODULE = sourceForResource("/deviation-stmt-test/foo.yang");
+ private static final YangStatementStreamSource FOO_IMP_MODULE =
+ sourceForResource("/deviation-stmt-test/foo-imp.yang");
+ private static final YangStatementStreamSource BAR_MODULE = sourceForResource("/deviation-stmt-test/bar.yang");
+ private static final YangStatementStreamSource BAR_IMP_MODULE =
+ sourceForResource("/deviation-stmt-test/bar-imp.yang");
@Test
- void testDeviationAndDeviate() throws ReactorException {
+ void testDeviationAndDeviate() throws Exception {
final var schemaContext = RFC7950Reactors.defaultReactor().newBuild()
.addSources(FOO_MODULE, FOO_IMP_MODULE, BAR_MODULE, BAR_IMP_MODULE)
.buildEffective();
assertNotNull(schemaContext);
- Module testModule = schemaContext.findModule("foo", Revision.of("2016-06-23")).get();
+ var testModule = schemaContext.findModule("foo", Revision.of("2016-06-23")).orElseThrow();
var deviations = testModule.getDeviations();
assertEquals(4, deviations.size());
- for (Deviation deviation : deviations) {
+ for (var deviation : deviations) {
final var deviates = deviation.getDeviates();
final String targetLocalName = Iterables.getLast(deviation.getTargetPath().getNodeIdentifiers())
assertTrue(deviates.iterator().next().getDeviatedMandatory());
} else if ("test-leaf-list".equals(targetLocalName)) {
assertEquals(3, deviates.size());
- for (DeviateDefinition deviate : deviates) {
+ for (var deviate : deviates) {
if (DeviateKind.ADD.equals(deviate.getDeviateType())) {
assertEquals(12, deviate.getDeviatedMaxElements().intValue());
} else if (DeviateKind.REPLACE.equals(deviate.getDeviateType())) {
}
}
- testModule = schemaContext.findModule("bar", Revision.of("2016-09-22")).get();
+ testModule = schemaContext.findModule("bar", Revision.of("2016-09-22")).orElseThrow();
assertNotNull(testModule);
deviations = testModule.getDeviations();
Deviation deviation6 = null;
Deviation deviation7 = null;
- for (Deviation deviation : deviations) {
+ for (var deviation : deviations) {
final var deviates = deviation.getDeviates();
final String targetLocalName = Iterables.getLast(deviation.getTargetPath().getNodeIdentifiers())
.getLocalName();
assertNotEquals(null, deviation1);
assertNotEquals("str", deviation1);
- DeviateDefinition deviate = deviation1.getDeviates().iterator().next();
+ var deviate = deviation1.getDeviates().iterator().next();
assertEquals(deviate, deviate);
assertNotEquals(null, deviate);
assertNotEquals("str", deviate);
}
private static void getDataChildByNameSubTest(final EffectiveModelContext result, final Module root) {
- final DataSchemaNode containerInRoot = result.getDataChildByName(QName
- .create(root.getQNameModule(), "container-in-root-module"));
- assertNotNull(containerInRoot);
+ final var containerInRoot = result.getDataChildByName(
+ QName.create(root.getQNameModule(), "container-in-root-module"));
assertEquals(Optional.of("desc"), containerInRoot.getDescription());
}
private static void findModulesSubTest(final EffectiveModelContext result, final Module root,
final Module imported) {
- final var foundRoot = result.findModule("root-module").get();
+ final var foundRoot = result.findModule("root-module").orElseThrow();
final var foundRoots = result.findModules(XMLNamespace.of("root-module"));
- final var foundRoot3 = result.findModule(XMLNamespace.of("root-module")).get();
+ final var foundRoot3 = result.findModule(XMLNamespace.of("root-module")).orElseThrow();
assertNotNull(foundRoot);
assertNotNull(foundRoots);
assertEquals(root, foundRoot2);
assertEquals(root, foundRoot3);
- final var foundImported = result.findModule("imported-module").get();
+ final var foundImported = result.findModule("imported-module").orElseThrow();
final var foundImporteds = result.findModules(XMLNamespace.of("imported-module"));
- final var foundImported3 = result.findModule(XMLNamespace.of("imported-module")).get();
+ final var foundImported3 = result.findModule(XMLNamespace.of("imported-module")).orElseThrow();
assertNotNull(foundImported);
assertNotNull(foundImporteds);
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
@Test
void testBinary() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-binary"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-binary")));
assertNotNull(currentLeaf.getType());
- final BinaryTypeDefinition binaryEff = (BinaryTypeDefinition)
- ((TypeEffectiveStatement<?>) ((LeafEffectiveStatement) currentLeaf)
- .effectiveSubstatements().iterator().next()).getTypeDefinition();
+ final var binaryEff = assertInstanceOf(BinaryTypeDefinition.class,
+ assertInstanceOf(TypeEffectiveStatement.class, currentLeaf.asEffectiveStatement()
+ .effectiveSubstatements().iterator().next()).getTypeDefinition());
assertNull(binaryEff.getBaseType());
assertEquals(Optional.empty(), binaryEff.getUnits());
@Test
void testBits() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-bits"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-bits")));
assertNotNull(currentLeaf.getType());
- final var bitsEffIter = ((BitsTypeDefinition) currentLeaf.getType()).getBits().iterator();
- final Bit bitEff = bitsEffIter.next();
- final Bit bitEffSecond = bitsEffIter.next();
+ final var bitsEffIter = assertInstanceOf(BitsTypeDefinition.class, currentLeaf.getType()).getBits().iterator();
+ final var bitEff = bitsEffIter.next();
+ final var bitEffSecond = bitsEffIter.next();
- final BitsTypeDefinition bitsEff = (BitsTypeDefinition) ((TypeDefinitionAware)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ final var bitsEff = assertInstanceOf(BitsTypeDefinition.class, assertInstanceOf(TypeDefinitionAware.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next()).getTypeDefinition());
assertNull(bitsEff.getBaseType());
assertNotNull(bitsEff.getQName());
@Test
void testBoolean() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-boolean"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-boolean")));
assertNotNull(currentLeaf.getType());
- final BooleanTypeDefinition booleanEff = (BooleanTypeDefinition) ((TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ final var booleanEff = assertInstanceOf(BooleanTypeDefinition.class,
+ assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next()).getTypeDefinition());
assertNull(booleanEff.getBaseType());
assertEquals(Optional.empty(), booleanEff.getUnits());
@Test
void testDecimal64() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-decimal64"));
- assertNotNull(currentLeaf.getType());
- final DecimalTypeDefinition decimal64Eff = (DecimalTypeDefinition) ((TypeDefinitionAware)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-decimal64")));
+ final var decimal64Eff = assertInstanceOf(DecimalTypeDefinition.class,
+ assertInstanceOf(TypeDefinitionAware.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next()).getTypeDefinition());
assertNull(decimal64Eff.getBaseType());
assertEquals(Optional.empty(), decimal64Eff.getUnits());
assertEquals(Optional.empty(), decimal64Eff.getReference());
assertEquals(Status.CURRENT, decimal64Eff.getStatus());
- assertEquals(3, decimal64Eff.getRangeConstraint().get().getAllowedRanges().asRanges().size());
+ assertEquals(3, decimal64Eff.getRangeConstraint().orElseThrow().getAllowedRanges().asRanges().size());
assertNotNull(decimal64Eff.toString());
assertNotNull(decimal64Eff.hashCode());
assertEquals(2, decimal64Eff.getFractionDigits());
@Test
void testEmpty() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-empty"));
- assertNotNull(currentLeaf.getType());
- final EmptyTypeDefinition emptyEff = (EmptyTypeDefinition) ((TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-empty")));
+ final var emptyEff = assertInstanceOf(EmptyTypeDefinition.class,
+ assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next()).getTypeDefinition());
assertEquals(Optional.empty(), emptyEff.getUnits());
assertEquals(Optional.empty(), emptyEff.getDefaultValue());
@Test
void testEnum() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-enum"));
- assertNotNull(currentLeaf.getType());
- final var enumEffIter = ((EnumTypeDefinition) currentLeaf.getType()).getValues();
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-enum")));
+ final var enumEffIter = assertInstanceOf(EnumTypeDefinition.class, currentLeaf.getType()).getValues();
final var enumEff = enumEffIter.iterator().next();
final var enumSpecEff = (EnumTypeDefinition) ((TypeDefinitionAware)
@Test
void testIdentityRef() {
- currentLeaf = (LeafSchemaNode) types
- .getDataChildByName(QName.create(types.getQNameModule(), "leaf-identityref"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-identityref")));
assertNotNull(currentLeaf.getType());
- final IdentityrefTypeDefinition identityRefEff = (IdentityrefTypeDefinition) ((TypeDefinitionAware)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ final var identityRefEff = assertInstanceOf(IdentityrefTypeDefinition.class,
+ assertInstanceOf(TypeDefinitionAware.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next())
+ .getTypeDefinition());
assertEquals(Optional.empty(), identityRefEff.getDefaultValue());
assertEquals("identityref", identityRefEff.getQName().getLocalName());
@Test
void testInstanceIdentifier() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
- "leaf-instance-identifier"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-instance-identifier")));
assertNotNull(currentLeaf.getType());
- final InstanceIdentifierTypeDefinition instanceIdentEff = (InstanceIdentifierTypeDefinition)
- ((TypeEffectiveStatement<?>) ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements()
- .iterator().next()).getTypeDefinition();
+ final var instanceIdentEff = assertInstanceOf(InstanceIdentifierTypeDefinition.class,
+ assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next())
+ .getTypeDefinition());
assertNotNull(instanceIdentEff.toString());
assertFalse(instanceIdentEff.requireInstance());
@Test
void testLeafref() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-leafref"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-leafref")));
assertNotNull(currentLeaf.getType());
- final LeafrefTypeDefinition leafrefEff = (LeafrefTypeDefinition) ((TypeDefinitionAware)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ final var leafrefEff = assertInstanceOf(LeafrefTypeDefinition.class,
+ assertInstanceOf(TypeDefinitionAware.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next())
+ .getTypeDefinition());
assertEquals("/container-test/leaf-test", leafrefEff.getPathStatement().getOriginalString());
assertNull(leafrefEff.getBaseType());
@Test
void testLeafrefWithDeref() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName
- .create(types.getQNameModule(), "leaf-leafref-deref"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-leafref-deref")));
assertNotNull(currentLeaf.getType());
- final LeafrefTypeDefinition leafrefEff = (LeafrefTypeDefinition) ((TypeDefinitionAware)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ final var leafrefEff = assertInstanceOf(LeafrefTypeDefinition.class,
+ assertInstanceOf(TypeDefinitionAware.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next())
+ .getTypeDefinition());
assertEquals("deref(../container-test)/leaf-test",
leafrefEff.getPathStatement().getOriginalString());
@Test
void testIntAll() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int8"));
- assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> int8Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int8")));
+ final var int8Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(int8Eff.toString());
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int16"));
- assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> int16Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int16")));
+ final var int16Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(int16Eff.toString());
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int32"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int32")));
assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> int32Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ final var int32Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(int32Eff.toString());
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int64"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-int64")));
assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> int64Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ final var int64Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(int64Eff.toString());
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint8"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint8")));
assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> uint8Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ final var uint8Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(uint8Eff.toString());
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint16"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint16")));
assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> uint16Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ final var uint16Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(uint16Eff.toString());
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint32"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint32")));
assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> uint32Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ final var uint32Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(uint32Eff.toString());
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint64"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-uint64")));
assertNotNull(currentLeaf.getType());
- final TypeEffectiveStatement<?> uint64Eff = (TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next();
+ final var uint64Eff = assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next());
assertNotNull(uint64Eff.toString());
}
@Test
void testUnion() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-union"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-union")));
assertNotNull(currentLeaf.getType());
- final UnionTypeDefinition unionEff = (UnionTypeDefinition) ((TypeDefinitionAware)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ final var unionEff = assertInstanceOf(UnionTypeDefinition.class,
+ assertInstanceOf(TypeDefinitionAware.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next())
+ .getTypeDefinition());
assertEquals(2, unionEff.getTypes().size());
assertEquals("union", unionEff.getQName().getLocalName());
@Test
void testLengthConstraint() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
- "leaf-length-pattern"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-length-pattern")));
- final var leafType = (StringTypeDefinition) currentLeaf.getType();
- assertNotNull(leafType);
- final var lengthConstraint = leafType.getLengthConstraint().get();
+ final var leafType = assertInstanceOf(StringTypeDefinition.class, currentLeaf.getType());
+ final var lengthConstraint = leafType.getLengthConstraint().orElseThrow();
final var span = lengthConstraint.getAllowedRanges().span();
assertEquals(1, span.lowerEndpoint().intValue());
assertNotEquals(null, lengthConstraint);
assertNotEquals("test", lengthConstraint);
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
- "leaf-length-pattern-second"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-length-pattern-second")));
assertNotNull(currentLeaf.getType());
- final LengthConstraint lengthConstraintSecond = ((StringTypeDefinition) currentLeaf.getType())
- .getLengthConstraint().get();
+ final var lengthConstraintSecond = ((StringTypeDefinition) currentLeaf.getType())
+ .getLengthConstraint().orElseThrow();
assertNotEquals(lengthConstraint, lengthConstraintSecond);
}
@Test
void testPatternConstraint() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
- "leaf-length-pattern"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-length-pattern")));
assertNotNull(currentLeaf.getType());
- final PatternConstraint patternConstraint = ((StringTypeDefinition) currentLeaf.getType())
+ final var patternConstraint = assertInstanceOf(StringTypeDefinition.class,
+ currentLeaf.getType()).getPatternConstraints().get(0);
+ // FIXME: 'third' vs get(0)?!
+ final var patternConstraintThird = assertInstanceOf(StringTypeDefinition.class, currentLeaf.getType())
.getPatternConstraints().get(0);
- final PatternConstraint patternConstraintThird = ((StringTypeDefinition) currentLeaf.getType())
- .getPatternConstraints().get(0);
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(),
- "leaf-length-pattern-second"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-length-pattern-second")));
assertNotNull(currentLeaf.getType());
- final PatternConstraint patternConstraintSecond = ((StringTypeDefinition) currentLeaf.getType())
+ final var patternConstraintSecond = assertInstanceOf(StringTypeDefinition.class, currentLeaf.getType())
.getPatternConstraints().get(0);
assertEquals("^(?:[0-9a-fA-F]*)$", patternConstraint.getJavaPatternString());
@Test
void testString() {
- currentLeaf = (LeafSchemaNode) types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-string"));
+ currentLeaf = assertInstanceOf(LeafSchemaNode.class,
+ types.getDataChildByName(QName.create(types.getQNameModule(), "leaf-string")));
assertNotNull(currentLeaf.getType());
- final StringTypeDefinition stringEff = (StringTypeDefinition) ((TypeEffectiveStatement<?>)
- ((LeafEffectiveStatement) currentLeaf).effectiveSubstatements().iterator().next())
- .getTypeDefinition();
+ final var stringEff = assertInstanceOf(StringTypeDefinition.class,
+ assertInstanceOf(TypeEffectiveStatement.class,
+ currentLeaf.asEffectiveStatement().effectiveSubstatements().iterator().next())
+ .getTypeDefinition());
assertEquals("string", stringEff.getQName().getLocalName());
assertEquals(Status.CURRENT, stringEff.getStatus());
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.google.common.collect.Iterables;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
}
private static void checkOriginalContainer(final GroupingEffectiveStatement grp, final QName... qnames) {
- SchemaNode containerInContainerNode = (SchemaNode) grp.findSchemaTreeNode(qnames).orElse(null);
- assertNotNull(containerInContainerNode);
-
- ContainerSchemaNode containerSchemaNode = (ContainerSchemaNode) containerInContainerNode;
+ var containerSchemaNode = assertInstanceOf(ContainerSchemaNode.class,
+ grp.findSchemaTreeNode(qnames).orElseThrow());
assertFalse(containerSchemaNode.getReference().isPresent());
assertFalse(containerSchemaNode.getDescription().isPresent());
assertEquals(Optional.empty(), containerSchemaNode.effectiveConfig());
}
private static void checkOriginalChoice(final GroupingEffectiveStatement grp, final QName... qnames) {
- SchemaNode choiceInContainerNode = (SchemaNode) grp.findSchemaTreeNode(qnames).orElse(null);
- assertNotNull(choiceInContainerNode);
-
- ChoiceSchemaNode choiceSchemaNode = (ChoiceSchemaNode) choiceInContainerNode;
+ var choiceSchemaNode = assertInstanceOf(ChoiceSchemaNode.class, grp.findSchemaTreeNode(qnames).orElseThrow());
assertFalse(choiceSchemaNode.isMandatory());
}
private static void checkOriginalList(final GroupingEffectiveStatement grp, final QName... qnames) {
- SchemaNode listInContainerNode = (SchemaNode) grp.findSchemaTreeNode(qnames).orElse(null);
- assertNotNull(listInContainerNode);
-
- ListSchemaNode listSchemaNode = (ListSchemaNode) listInContainerNode;
+ final var listSchemaNode = assertInstanceOf(ListSchemaNode.class, grp.findSchemaTreeNode(qnames).orElseThrow());
assertEquals(Optional.of("original reference"), listSchemaNode.getReference());
assertEquals(Optional.of("original description"), listSchemaNode.getDescription());
assertEquals(Optional.of(Boolean.FALSE), listSchemaNode.effectiveConfig());
- ElementCountConstraint listConstraints = listSchemaNode.getElementCountConstraint().get();
+ var listConstraints = listSchemaNode.getElementCountConstraint().orElseThrow();
assertEquals((Object) 10, listConstraints.getMinElements());
assertEquals((Object) 20, listConstraints.getMaxElements());
assertEquals(1, listSchemaNode.getMustConstraints().size());
}
private static void checkRefinedContainer(final ModuleEffectiveStatement module, final QName... qnames) {
- final SchemaNode containerInContainerNode = (SchemaNode) module.findSchemaTreeNode(qnames).orElse(null);
- assertNotNull(containerInContainerNode);
-
- ContainerSchemaNode containerSchemaNode = (ContainerSchemaNode) containerInContainerNode;
+ final var containerSchemaNode = assertInstanceOf(ContainerSchemaNode.class,
+ module.findSchemaTreeNode(qnames).orElseThrow());
assertEquals(Optional.of("new reference"), containerSchemaNode.getReference());
assertEquals(Optional.of("new description"), containerSchemaNode.getDescription());
assertEquals(Optional.of(Boolean.TRUE), containerSchemaNode.effectiveConfig());
}
private static void checkRefinedChoice(final ModuleEffectiveStatement module, final QName... qnames) {
- final SchemaNode choiceInContainerNode = (SchemaNode) module.findSchemaTreeNode(qnames).orElse(null);
- assertNotNull(choiceInContainerNode);
-
- ChoiceSchemaNode choiceSchemaNode = (ChoiceSchemaNode) choiceInContainerNode;
+ final var choiceSchemaNode = assertInstanceOf(ChoiceSchemaNode.class,
+ module.findSchemaTreeNode(qnames).orElseThrow());
assertTrue(choiceSchemaNode.isMandatory());
}
private static void checkRefinedList(final ModuleEffectiveStatement module, final QName... qnames) {
- final SchemaNode listInContainerNode = (SchemaNode) module.findSchemaTreeNode(qnames).orElse(null);
- assertNotNull(listInContainerNode);
-
- final ListSchemaNode listSchemaNode = (ListSchemaNode) listInContainerNode;
+ final var listSchemaNode = assertInstanceOf(ListSchemaNode.class,
+ module.findSchemaTreeNode(qnames).orElseThrow());
assertEquals(Optional.of("new reference"), listSchemaNode.getReference());
assertEquals(Optional.of("new description"), listSchemaNode.getDescription());
assertEquals(Optional.of(Boolean.TRUE), listSchemaNode.effectiveConfig());
- final ElementCountConstraint listConstraints = listSchemaNode.getElementCountConstraint().get();
+ final var listConstraints = listSchemaNode.getElementCountConstraint().orElseThrow();
assertEquals((Object) 5, listConstraints.getMinElements());
assertEquals((Object) 7, listConstraints.getMaxElements());
assertEquals(2, listSchemaNode.getMustConstraints().size());
assertEquals(Optional.of("addresses reference added by refine"), refineList.getReference());
assertEquals(Optional.of(Boolean.FALSE), refineList.effectiveConfig());
- final ElementCountConstraint constraint = refineList.getElementCountConstraint().get();
+ final ElementCountConstraint constraint = refineList.getElementCountConstraint().orElseThrow();
assertEquals((Object) 2, constraint.getMinElements());
assertNull(constraint.getMaxElements());
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class IfFeatureResolutionTest extends AbstractYangTest {
@Test
QName.create("foo-namespace", "test-feature-3"),
QName.create("bar-namespace", "imp-feature")));
- final Module testModule = schemaContext.findModule("foo").get();
+ final var testModule = schemaContext.findModule("foo").orElseThrow();
assertEquals(9, testModule.getChildNodes().size());
- final ContainerSchemaNode testContainerA = (ContainerSchemaNode) testModule.dataChildByName(
+ final var testContainerA = (ContainerSchemaNode) testModule.dataChildByName(
QName.create(testModule.getQNameModule(), "test-container-a"));
assertNull(testContainerA);
- final ContainerSchemaNode testContainerB = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerB = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-b"));
assertNotNull(testContainerB);
- final LeafSchemaNode testLeafB = (LeafSchemaNode) testContainerB.getDataChildByName(
+ final var testLeafB = (LeafSchemaNode) testContainerB.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-b"));
assertNotNull(testLeafB);
- final ContainerSchemaNode testContainerC = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerC = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-c"));
assertNotNull(testContainerC);
- final LeafSchemaNode testLeafC = (LeafSchemaNode) testContainerC.getDataChildByName(
+ final var testLeafC = (LeafSchemaNode) testContainerC.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-c"));
assertNotNull(testLeafC);
- final ContainerSchemaNode testContainerD = (ContainerSchemaNode) testModule.dataChildByName(
+ final var testContainerD = (ContainerSchemaNode) testModule.dataChildByName(
QName.create(testModule.getQNameModule(), "test-container-d"));
assertNull(testContainerD);
- final ContainerSchemaNode testContainerE = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerE = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-e"));
assertNotNull(testContainerE);
- final ContainerSchemaNode testSubContainerE = (ContainerSchemaNode) testContainerE.getDataChildByName(
+ final var testSubContainerE = (ContainerSchemaNode) testContainerE.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-subcontainer-e"));
assertNotNull(testSubContainerE);
- final LeafSchemaNode testLeafE = (LeafSchemaNode) testSubContainerE.dataChildByName(
+ final var testLeafE = (LeafSchemaNode) testSubContainerE.dataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-e"));
assertNull(testLeafE);
- final ContainerSchemaNode testContainerF = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerF = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-f"));
assertNotNull(testContainerF);
- final ContainerSchemaNode testSubContainerF = (ContainerSchemaNode) testContainerF.dataChildByName(
+ final var testSubContainerF = (ContainerSchemaNode) testContainerF.dataChildByName(
QName.create(testModule.getQNameModule(), "test-subcontainer-f"));
assertNull(testSubContainerF);
- final ContainerSchemaNode testContainerG = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerG = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-g"));
assertNotNull(testContainerG);
assertEquals(1, testContainerG.getAvailableAugmentations().size());
- final LeafSchemaNode testLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
+ final var testLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-g"));
assertNotNull(testLeafG);
- final LeafSchemaNode augmentingTestLeafG = (LeafSchemaNode) testContainerG.dataChildByName(
+ final var augmentingTestLeafG = (LeafSchemaNode) testContainerG.dataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-leaf-g"));
assertNull(augmentingTestLeafG);
- final AnyxmlSchemaNode augmentingTestAnyxmlG = (AnyxmlSchemaNode) testContainerG.getDataChildByName(
+ final var augmentingTestAnyxmlG = (AnyxmlSchemaNode) testContainerG.getDataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-anyxml-g"));
assertNotNull(augmentingTestAnyxmlG);
- final ContainerSchemaNode testContainerH = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerH = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-h"));
assertNotNull(testContainerH);
assertEquals(0, testContainerH.getChildNodes().size());
assertEquals(0, testContainerH.getUses().size());
- final ContainerSchemaNode testContainerI = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerI = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-i"));
assertNotNull(testContainerI);
assertEquals(1, testContainerI.getUses().size());
- ContainerSchemaNode testGroupingSubContainer = (ContainerSchemaNode) testContainerI.getDataChildByName(
+ var testGroupingSubContainer = (ContainerSchemaNode) testContainerI.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-grouping-subcontainer"));
assertNotNull(testGroupingSubContainer);
- final LeafSchemaNode testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
+ final var testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
QName.create(testModule.getQNameModule(), "test-grouping-leaf"));
assertNull(testGroupingLeaf);
- final ContainerSchemaNode testContainerJ = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerJ = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-j"));
assertNotNull(testContainerJ);
- final LeafSchemaNode testLeafJ = (LeafSchemaNode) testContainerJ.getDataChildByName(
+ final var testLeafJ = (LeafSchemaNode) testContainerJ.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-j"));
assertNotNull(testLeafJ);
- final ContainerSchemaNode testContainerK = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerK = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-k"));
assertNotNull(testContainerK);
assertEquals(1, testContainerK.getUses().size());
QName.create(testModule.getQNameModule(), "test-grouping-subcontainer"));
assertNotNull(testGroupingSubContainer);
assertEquals(1, testGroupingSubContainer.getAvailableAugmentations().size());
- final LeafSchemaNode augmentingTestGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
+ final var augmentingTestGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-grouping-leaf"));
assertNotNull(augmentingTestGroupingLeaf);
- final LeafSchemaNode augmentingTestGroupingLeaf2 = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
+ final var augmentingTestGroupingLeaf2 = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-grouping-leaf-2"));
assertNull(augmentingTestGroupingLeaf2);
}
void testAllFeaturesSupported() {
final var schemaContext = assertEffectiveModelDir("/if-feature-resolution-test");
- final Module testModule = schemaContext.findModules("foo").iterator().next();
+ final var testModule = schemaContext.findModules("foo").iterator().next();
assertNotNull(testModule);
assertEquals(11, testModule.getChildNodes().size());
- final ContainerSchemaNode testContainerA = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerA = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-a"));
assertNotNull(testContainerA);
- final LeafSchemaNode testLeafA = (LeafSchemaNode) testContainerA.getDataChildByName(
+ final var testLeafA = (LeafSchemaNode) testContainerA.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-a"));
assertNotNull(testLeafA);
-
- final ContainerSchemaNode testContainerB = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerB = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-b"));
assertNotNull(testContainerB);
- final LeafSchemaNode testLeafB = (LeafSchemaNode) testContainerB.getDataChildByName(
+ final var testLeafB = (LeafSchemaNode) testContainerB.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-b"));
assertNotNull(testLeafB);
- final ContainerSchemaNode testContainerC = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerC = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-c"));
assertNotNull(testContainerC);
- final LeafSchemaNode testLeafC = (LeafSchemaNode) testContainerC.getDataChildByName(
+ final var testLeafC = (LeafSchemaNode) testContainerC.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-c"));
assertNotNull(testLeafC);
- final ContainerSchemaNode testContainerD = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerD = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-d"));
assertNotNull(testContainerD);
- final LeafSchemaNode testLeafD = (LeafSchemaNode) testContainerD.getDataChildByName(
+ final var testLeafD = (LeafSchemaNode) testContainerD.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-d"));
assertNotNull(testLeafD);
- final ContainerSchemaNode testContainerE = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerE = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-e"));
assertNotNull(testContainerE);
- final ContainerSchemaNode testSubContainerE = (ContainerSchemaNode) testContainerE.getDataChildByName(
+ final var testSubContainerE = (ContainerSchemaNode) testContainerE.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-subcontainer-e"));
assertNotNull(testSubContainerE);
- final LeafSchemaNode testLeafE = (LeafSchemaNode) testSubContainerE.getDataChildByName(
+ final var testLeafE = (LeafSchemaNode) testSubContainerE.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-e"));
assertNotNull(testLeafE);
- final ContainerSchemaNode testContainerF = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerF = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-f"));
assertNotNull(testContainerF);
- final ContainerSchemaNode testSubContainerF = (ContainerSchemaNode) testContainerF.getDataChildByName(
+ final var testSubContainerF = (ContainerSchemaNode) testContainerF.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-subcontainer-f"));
assertNotNull(testSubContainerF);
- final ContainerSchemaNode testSubSubContainerF = (ContainerSchemaNode) testSubContainerF.getDataChildByName(
+ final var testSubSubContainerF = (ContainerSchemaNode) testSubContainerF.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-subsubcontainer-f"));
assertNotNull(testSubSubContainerF);
- final LeafSchemaNode testLeafF = (LeafSchemaNode) testSubSubContainerF.getDataChildByName(
+ final var testLeafF = (LeafSchemaNode) testSubSubContainerF.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-f"));
assertNotNull(testLeafF);
- final ContainerSchemaNode testContainerG = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerG = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-g"));
assertNotNull(testContainerG);
assertEquals(2, testContainerG.getAvailableAugmentations().size());
- final LeafSchemaNode testLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
+ final var testLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-g"));
assertNotNull(testLeafG);
- final LeafSchemaNode augmentingTestLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
+ final var augmentingTestLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-leaf-g"));
assertNotNull(augmentingTestLeafG);
- final AnyxmlSchemaNode augmentingTestAnyxmlG = (AnyxmlSchemaNode) testContainerG.getDataChildByName(
+ final var augmentingTestAnyxmlG = (AnyxmlSchemaNode) testContainerG.getDataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-anyxml-g"));
assertNotNull(augmentingTestAnyxmlG);
- final ContainerSchemaNode testContainerH = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerH = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-h"));
assertNotNull(testContainerH);
assertEquals(1, testContainerH.getUses().size());
- ContainerSchemaNode testGroupingSubContainer = (ContainerSchemaNode) testContainerH.getDataChildByName(
+ var testGroupingSubContainer = (ContainerSchemaNode) testContainerH.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-grouping-subcontainer"));
assertNotNull(testGroupingSubContainer);
- LeafSchemaNode testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
+ var testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-grouping-leaf"));
assertNotNull(testGroupingLeaf);
- final ContainerSchemaNode testContainerI = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerI = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-i"));
assertNotNull(testContainerI);
assertEquals(1, testContainerI.getUses().size());
QName.create(testModule.getQNameModule(), "test-grouping-leaf"));
assertNotNull(testGroupingLeaf);
- final ContainerSchemaNode testContainerJ = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerJ = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-j"));
assertNotNull(testContainerJ);
- final LeafSchemaNode testLeafJ = (LeafSchemaNode) testContainerJ.getDataChildByName(
+ final var testLeafJ = (LeafSchemaNode) testContainerJ.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-j"));
assertNotNull(testLeafJ);
- final ContainerSchemaNode testContainerK = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerK = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-k"));
assertNotNull(testContainerK);
assertEquals(1, testContainerK.getUses().size());
QName.create(testModule.getQNameModule(), "test-grouping-subcontainer"));
assertNotNull(testGroupingSubContainer);
assertEquals(1, testGroupingSubContainer.getAvailableAugmentations().size());
- final LeafSchemaNode augmentingTestGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
+ final var augmentingTestGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-grouping-leaf"));
assertNotNull(augmentingTestGroupingLeaf);
- final LeafSchemaNode augmentingTestGroupingLeaf2 = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
+ final var augmentingTestGroupingLeaf2 = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-grouping-leaf-2"));
assertNotNull(augmentingTestGroupingLeaf2);
testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.getDataChildByName(
void testNoFeaturesSupported() {
final var schemaContext = assertEffectiveModelDir("/if-feature-resolution-test", Set.of());
- final Module testModule = schemaContext.findModules("foo").iterator().next();
+ final var testModule = schemaContext.findModules("foo").iterator().next();
assertNotNull(testModule);
assertEquals(6, testModule.getChildNodes().size());
- final ContainerSchemaNode testContainerE = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerE = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-e"));
assertNotNull(testContainerE);
- final ContainerSchemaNode testSubContainerE = (ContainerSchemaNode) testContainerE.getDataChildByName(
+ final var testSubContainerE = (ContainerSchemaNode) testContainerE.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-subcontainer-e"));
assertNotNull(testSubContainerE);
- final LeafSchemaNode testLeafE = (LeafSchemaNode) testSubContainerE.dataChildByName(
+ final var testLeafE = (LeafSchemaNode) testSubContainerE.dataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-e"));
assertNull(testLeafE);
- final ContainerSchemaNode testContainerF = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerF = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-f"));
assertNotNull(testContainerF);
- final ContainerSchemaNode testSubContainerF = (ContainerSchemaNode) testContainerF.dataChildByName(
+ final var testSubContainerF = (ContainerSchemaNode) testContainerF.dataChildByName(
QName.create(testModule.getQNameModule(), "test-subcontainer-f"));
assertNull(testSubContainerF);
- final ContainerSchemaNode testContainerG = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerG = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-g"));
assertNotNull(testContainerG);
assertEquals(1, testContainerG.getAvailableAugmentations().size());
- final LeafSchemaNode testLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
+ final var testLeafG = (LeafSchemaNode) testContainerG.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-leaf-g"));
assertNotNull(testLeafG);
- final LeafSchemaNode augmentingTestLeafG = (LeafSchemaNode) testContainerG.dataChildByName(
+ final var augmentingTestLeafG = (LeafSchemaNode) testContainerG.dataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-leaf-g"));
assertNull(augmentingTestLeafG);
- final AnyxmlSchemaNode augmentingTestAnyxmlG = (AnyxmlSchemaNode) testContainerG.getDataChildByName(
+ final var augmentingTestAnyxmlG = (AnyxmlSchemaNode) testContainerG.getDataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-anyxml-g"));
assertNotNull(augmentingTestAnyxmlG);
- final ContainerSchemaNode testContainerH = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerH = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-h"));
assertNotNull(testContainerH);
assertEquals(0, testContainerH.getChildNodes().size());
assertEquals(0, testContainerH.getUses().size());
- final ContainerSchemaNode testContainerI = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerI = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-i"));
assertNotNull(testContainerI);
assertEquals(1, testContainerI.getUses().size());
- ContainerSchemaNode testGroupingSubContainer = (ContainerSchemaNode) testContainerI.getDataChildByName(
+ var testGroupingSubContainer = (ContainerSchemaNode) testContainerI.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-grouping-subcontainer"));
assertNotNull(testGroupingSubContainer);
- LeafSchemaNode testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
+ var testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
QName.create(testModule.getQNameModule(), "test-grouping-leaf"));
assertNull(testGroupingLeaf);
- final ContainerSchemaNode testContainerK = (ContainerSchemaNode) testModule.getDataChildByName(
+ final var testContainerK = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "test-container-k"));
assertNotNull(testContainerK);
assertEquals(1, testContainerK.getUses().size());
QName.create(testModule.getQNameModule(), "test-grouping-subcontainer"));
assertNotNull(testGroupingSubContainer);
assertEquals(1, testGroupingSubContainer.getAvailableAugmentations().size());
- final LeafSchemaNode augmentingTestGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
+ final var augmentingTestGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-grouping-leaf"));
assertNull(augmentingTestGroupingLeaf);
- final LeafSchemaNode augmentingTestGroupingLeaf2 = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
+ final var augmentingTestGroupingLeaf2 = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
QName.create(testModule.getQNameModule(), "augmenting-test-grouping-leaf-2"));
assertNull(augmentingTestGroupingLeaf2);
testGroupingLeaf = (LeafSchemaNode) testGroupingSubContainer.dataChildByName(
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class ListTest extends AbstractYangTest {
-
@Test
void listAndLeavesTest() {
final var result = assertEffectiveModel("/list-test/list-test.yang");
+ final var testModule = result.findModules("list-test").iterator().next();
- final Module testModule = result.findModules("list-test").iterator().next();
- assertNotNull(testModule);
-
- final ListSchemaNode list = (ListSchemaNode) testModule.getDataChildByName(
- QName.create(testModule.getQNameModule(), "simple-list"));
- assertNotNull(list);
+ final var list = assertInstanceOf(ListSchemaNode.class,
+ testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "simple-list")));
assertTrue(list.isUserOrdered());
assertEquals(Optional.of(Boolean.TRUE), list.effectiveConfig());
- final List<QName> keys = list.getKeyDefinition();
+ final var keys = list.getKeyDefinition();
assertEquals(2, keys.size());
assertEquals("key1", keys.get(0).getLocalName());
assertEquals("key2", keys.get(1).getLocalName());
- ElementCountConstraint constraint = list.getElementCountConstraint().get();
+ var constraint = list.getElementCountConstraint().orElseThrow();
assertEquals((Object) 1, constraint.getMinElements());
assertEquals((Object) 10, constraint.getMaxElements());
assertEquals(5, list.getChildNodes().size());
- LeafSchemaNode leaf = (LeafSchemaNode) list.getDataChildByName(QName.create(testModule.getQNameModule(),
- "key1"));
- assertNotNull(leaf);
+ var leaf = assertInstanceOf(LeafSchemaNode.class,
+ list.getDataChildByName(QName.create(testModule.getQNameModule(), "key1")));
assertTrue(leaf.isMandatory());
assertEquals("int32", leaf.getType().getQName().getLocalName());
- leaf = (LeafSchemaNode) list.getDataChildByName(QName.create(testModule.getQNameModule(), "key2"));
- assertNotNull(leaf);
+ leaf = assertInstanceOf(LeafSchemaNode.class,
+ list.getDataChildByName(QName.create(testModule.getQNameModule(), "key2")));
assertTrue(leaf.isMandatory());
assertEquals("int16", leaf.getType().getQName().getLocalName());
- leaf = (LeafSchemaNode) list.getDataChildByName(QName.create(testModule.getQNameModule(), "old-leaf"));
- assertNotNull(leaf);
+ leaf = assertInstanceOf(LeafSchemaNode.class,
+ list.getDataChildByName(QName.create(testModule.getQNameModule(), "old-leaf")));
assertFalse(leaf.isMandatory());
assertEquals("string", leaf.getType().getQName().getLocalName());
- leaf = (LeafSchemaNode) list.getDataChildByName(QName.create(testModule.getQNameModule(), "young-leaf"));
- assertNotNull(leaf);
+ leaf = assertInstanceOf(LeafSchemaNode.class,
+ list.getDataChildByName(QName.create(testModule.getQNameModule(), "young-leaf")));
assertFalse(leaf.isMandatory());
assertEquals("young-leaf", leaf.getType().getQName().getLocalName());
assertEquals(Optional.of("default-value"), leaf.getType().getDefaultValue());
- final LeafListSchemaNode leafList = (LeafListSchemaNode) list.getDataChildByName(
- QName.create(testModule.getQNameModule(), "list-of-leaves"));
- assertNotNull(leafList);
+ final var leafList = assertInstanceOf(LeafListSchemaNode.class,
+ list.getDataChildByName(QName.create(testModule.getQNameModule(), "list-of-leaves")));
assertTrue(leafList.isUserOrdered());
- constraint = leafList.getElementCountConstraint().get();
+ constraint = leafList.getElementCountConstraint().orElseThrow();
assertEquals(2, constraint.getMinElements().intValue());
assertEquals(20, constraint.getMaxElements().intValue());
assertEquals("string", leafList.getType().getQName().getLocalName());
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import java.util.Collection;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
class MoreRevisionsTest extends AbstractYangTest {
void readAndParseYangFileTest() {
final var result = assertEffectiveModel("/semantic-statement-parser/revisions/more-revisions-test.yang");
final var moduleByName = result.getModules().iterator().next();
- assertEquals("2015-06-07", moduleByName.getQNameModule().getRevision().get().toString());
+ assertEquals("2015-06-07", moduleByName.getQNameModule().getRevision().orElseThrow().toString());
}
@Test
final QName dateTimeTypeDef20130516 = QName.create(yangTypes20130516, "date-and-time");
final QName dateTimeTypeDef20130715 = QName.create(yangTypes20130715, "date-and-time");
- Module yangTypesModule20100924 = context.findModule("ietf-yang-types", rev20100924).get();
- Module yangTypesModule20130516 = context.findModule("ietf-yang-types", rev20130516).get();
- Module yangTypesModule20130715 = context.findModule("ietf-yang-types", rev20130715).get();
+ var yangTypesModule20100924 = context.findModule("ietf-yang-types", rev20100924).orElseThrow();
+ var yangTypesModule20130516 = context.findModule("ietf-yang-types", rev20130516).orElseThrow();
+ var yangTypesModule20130715 = context.findModule("ietf-yang-types", rev20130715).orElseThrow();
assertTrue(findTypeDef(yangTypesModule20100924, dateTimeTypeDef20100924));
assertTrue(findTypeDef(yangTypesModule20130516, dateTimeTypeDef20130516));
assertTrue(findTypeDef(yangTypesModule20130715, dateTimeTypeDef20130715));
private static void checkInterfacesModuleFullTest(final EffectiveModelContext context, final Revision rev20100924,
final QName dateTimeTypeDef20100924) {
- Revision rev20121115 = Revision.of("2012-11-15");
+ var rev20121115 = Revision.of("2012-11-15");
- Module interfacesModule20121115 = context.findModule("ietf-interfaces", rev20121115).get();
- Collection<? extends ModuleImport> imports = interfacesModule20121115.getImports();
+ var interfacesModule20121115 = context.findModule("ietf-interfaces", rev20121115).orElseThrow();
+ var imports = interfacesModule20121115.getImports();
assertEquals(1, imports.size());
- ModuleImport interfacesImport = imports.iterator().next();
+ var interfacesImport = imports.iterator().next();
assertEquals(Unqualified.of("ietf-yang-types"), interfacesImport.getModuleName());
assertEquals(Optional.of(rev20100924), interfacesImport.getRevision());
}
private static void checkNetconfMonitoringModuleFullTest(final EffectiveModelContext context,
final Revision rev20130715, final QName dateTimeTypeDef20130715) {
- Revision rev20101004 = Revision.of("2010-10-04");
+ var rev20101004 = Revision.of("2010-10-04");
- Module monitoringModule20101004 = context.findModule("ietf-netconf-monitoring", rev20101004).get();
- Collection<? extends ModuleImport> imports = monitoringModule20101004.getImports();
+ var monitoringModule20101004 = context.findModule("ietf-netconf-monitoring", rev20101004).orElseThrow();
+ var imports = monitoringModule20101004.getImports();
assertEquals(2, imports.size());
- for (ModuleImport monitoringImport : imports) {
+ for (var monitoringImport : imports) {
if (monitoringImport.getModuleName().equals("ietf-yang-types")) {
assertEquals(Optional.of(rev20130715), monitoringImport.getRevision());
}
final QName dateTimeTypeDef20130516 = QName.create(yangTypes20130516, "date-and-time");
final QName dateTimeTypeDef20130715 = QName.create(yangTypes20130715, "date-and-time");
- Module yangTypesModule20100924 = context.findModule("ietf-yang-types", rev20100924).get();
- Module yangTypesModule20130516 = context.findModule("ietf-yang-types", rev20130516).get();
- Module yangTypesModule20130715 = context.findModule("ietf-yang-types", rev20130715).get();
+ var yangTypesModule20100924 = context.findModule("ietf-yang-types", rev20100924).orElseThrow();
+ var yangTypesModule20130516 = context.findModule("ietf-yang-types", rev20130516).orElseThrow();
+ var yangTypesModule20130715 = context.findModule("ietf-yang-types", rev20130715).orElseThrow();
assertTrue(findTypeDef(yangTypesModule20100924, dateTimeTypeDef20100924));
assertTrue(findTypeDef(yangTypesModule20130516, dateTimeTypeDef20130516));
assertTrue(findTypeDef(yangTypesModule20130715, dateTimeTypeDef20130715));
final QNameModule interfacesNS20121115 = QNameModule.create(interfacesNS, rev20121115);
QName lastChange = QName.create(interfacesNS20121115, "last-change");
- Module interfacesModule20121115 = context.findModule("ietf-interfaces", rev20121115).get();
- DataSchemaNode leafLastChange = interfacesModule20121115.getDataChildByName(lastChange);
+ var interfacesModule20121115 = context.findModule("ietf-interfaces", rev20121115).orElseThrow();
+ var leafLastChange = interfacesModule20121115.getDataChildByName(lastChange);
QName lastChangeTypeQName = assertInstanceOf(LeafSchemaNode.class, leafLastChange).getType().getQName();
assertEquals(dateTimeTypeDef20100924, lastChangeTypeQName);
- Collection<? extends ModuleImport> imports = interfacesModule20121115.getImports();
+ var imports = interfacesModule20121115.getImports();
assertEquals(1, imports.size());
- ModuleImport interfacesImport = imports.iterator().next();
+ var interfacesImport = imports.iterator().next();
assertEquals(Unqualified.of("ietf-yang-types"), interfacesImport.getModuleName());
assertEquals(Optional.of(rev20100924), interfacesImport.getRevision());
}
final QNameModule monitoring19700101 = QNameModule.create(monitoringNS);
QName lockedTime = QName.create(monitoring19700101, "locked-time");
- Module monitoringModule19700101 = context.findModule("ietf-netconf-monitoring").get();
- DataSchemaNode leafLockedTime = monitoringModule19700101.getDataChildByName(lockedTime);
+ var monitoringModule19700101 = context.findModule("ietf-netconf-monitoring").orElseThrow();
+ var leafLockedTime = monitoringModule19700101.getDataChildByName(lockedTime);
QName lockedTimeTypeQName = assertInstanceOf(LeafSchemaNode.class, leafLockedTime).getType().getQName();
assertEquals(dateTimeTypeDef20130715, lockedTimeTypeQName);
- Collection<? extends ModuleImport> imports = monitoringModule19700101.getImports();
+ var imports = monitoringModule19700101.getImports();
assertEquals(1, imports.size());
- ModuleImport monitoringImport = imports.iterator().next();
+ var monitoringImport = imports.iterator().next();
assertEquals(Unqualified.of("ietf-yang-types"), monitoringImport.getModuleName());
assertEquals(Optional.of(rev20130715), monitoringImport.getRevision());
}
private static boolean findTypeDef(final Module module, final QName typedef) {
- for (TypeDefinition<?> typeDefinition : module.getTypeDefinitions()) {
+ for (var typeDefinition : module.getTypeDefinitions()) {
if (typeDefinition.getQName().equals(typedef)) {
return true;
}
QName root = QName.create("foo", "2016-04-06", "foo-root");
QName container20160404 = QName.create("foo", "2016-04-06", "con20160404");
- DataSchemaNode findDataSchemaNode = context.findDataTreeChild(root, container20160404).orElse(null);
- assertInstanceOf(ContainerSchemaNode.class, findDataSchemaNode);
+ assertInstanceOf(ContainerSchemaNode.class, context.findDataTreeChild(root, container20160404).orElse(null));
QName container20160405 = QName.create("foo", "2016-04-06", "con20160405");
- findDataSchemaNode = context.findDataTreeChild(root, container20160405).orElse(null);
- assertInstanceOf(ContainerSchemaNode.class, findDataSchemaNode);
+ assertInstanceOf(ContainerSchemaNode.class, context.findDataTreeChild(root, container20160405).orElse(null));
QName container20160406 = QName.create("foo", "2016-04-06", "con20160406");
assertEquals(Optional.empty(), context.findDataTreeChild(root, container20160406));
package org.opendaylight.yangtools.yang.stmt;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-import java.util.Collection;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementOrigin;
void rpcTest() {
final var result = assertEffectiveModel("/model/baz.yang", "/model/bar.yang", "/rpc-stmt-test/foo.yang");
- final Module testModule = result.findModules("baz").iterator().next();
+ final var testModule = result.findModules("baz").iterator().next();
assertEquals(1, testModule.getRpcs().size());
- final RpcDefinition rpc = testModule.getRpcs().iterator().next();
+ final var rpc = testModule.getRpcs().iterator().next();
assertEquals("get-config", rpc.getQName().getLocalName());
- final InputSchemaNode input = rpc.getInput();
- assertNotNull(input);
+ final var input = rpc.getInput();
assertEquals(2, input.getChildNodes().size());
- final ContainerSchemaNode container = (ContainerSchemaNode) input.getDataChildByName(
- QName.create(testModule.getQNameModule(), "source"));
- assertNotNull(container);
- AnyxmlSchemaNode anyXml = (AnyxmlSchemaNode) input.getDataChildByName(
- QName.create(testModule.getQNameModule(), "filter"));
- assertNotNull(anyXml);
+ assertInstanceOf(ContainerSchemaNode.class,
+ input.getDataChildByName(QName.create(testModule.getQNameModule(), "source")));
+ assertInstanceOf(AnyxmlSchemaNode.class,
+ input.getDataChildByName(QName.create(testModule.getQNameModule(), "filter")));
- final OutputSchemaNode output = rpc.getOutput();
+ final var output = rpc.getOutput();
assertNotNull(output);
assertEquals(1, output.getChildNodes().size());
- anyXml = (AnyxmlSchemaNode) output.getDataChildByName(QName.create(testModule.getQNameModule(), "data"));
- assertNotNull(anyXml);
+ assertInstanceOf(AnyxmlSchemaNode.class,
+ output.getDataChildByName(QName.create(testModule.getQNameModule(), "data")));
- final Module fooModule = result.findModule("foo", Revision.of("2016-09-23")).get();
- final Collection<? extends RpcDefinition> rpcs = fooModule.getRpcs();
+ final var fooModule = result.findModule("foo", Revision.of("2016-09-23")).orElseThrow();
+ final var rpcs = fooModule.getRpcs();
assertEquals(2, rpcs.size());
RpcDefinition fooRpc1 = null;
RpcDefinition fooRpc2 = null;
- for (RpcDefinition rpcDefinition : rpcs) {
+ for (var rpcDefinition : rpcs) {
if ("foo-rpc-1".equals(rpcDefinition.getQName().getLocalName())) {
fooRpc1 = rpcDefinition;
} else if ("foo-rpc-2".equals(rpcDefinition.getQName().getLocalName())) {
void testImplicitInputAndOutput() {
final var context = assertEffectiveModel("/rpc-stmt-test/bar.yang");
- final Module barModule = context.findModule("bar", Revision.of("2016-11-25")).get();
- final Collection<? extends RpcDefinition> rpcs = barModule.getRpcs();
+ final var barModule = context.findModule("bar", Revision.of("2016-11-25")).orElseThrow();
+ final var rpcs = barModule.getRpcs();
assertEquals(1, rpcs.size());
- final RpcDefinition barRpc = rpcs.iterator().next();
+ final var barRpc = rpcs.iterator().next();
- final InputSchemaNode input = barRpc.getInput();
- assertNotNull(input);
+ final var input = barRpc.getInput();
assertEquals(2, input.getChildNodes().size());
assertEquals(StatementOrigin.CONTEXT, ((EffectiveStatement<?, ?>) input).statementOrigin());
- final OutputSchemaNode output = barRpc.getOutput();
- assertNotNull(output);
+ final var output = barRpc.getOutput();
assertEquals(2, output.getChildNodes().size());
assertEquals(StatementOrigin.CONTEXT, ((EffectiveStatement<?, ?>) output).statementOrigin());
}
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
-import com.google.common.collect.Range;
-import java.util.Collection;
-import java.util.Set;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.TypeDefinitions;
assertNotNull(context);
- final Collection<? extends TypeDefinition<?>> typeDefinitions = context.getTypeDefinitions();
+ final var typeDefinitions = context.getTypeDefinitions();
assertNotNull(typeDefinitions);
assertEquals(1, typeDefinitions.size());
- final TypeDefinition<?> myDecimal = typeDefinitions.iterator().next();
+ final var myDecimal = typeDefinitions.iterator().next();
- final Set<? extends Range<?>> rangeConstraints = assertInstanceOf(DecimalTypeDefinition.class, myDecimal)
+ final var rangeConstraints = assertInstanceOf(DecimalTypeDefinition.class, myDecimal)
.getRangeConstraint()
.orElseThrow().getAllowedRanges().asRanges();
assertNotNull(rangeConstraints);
assertEquals(1, rangeConstraints.size());
- final DataSchemaNode dataNode = context.getDataChildByName(QName.create("urn:opendaylight.foo", "2013-10-08",
+ final var dataNode = context.getDataChildByName(QName.create("urn:opendaylight.foo", "2013-10-08",
"id-decimal64"));
- assertNotNull(dataNode);
- final LeafSchemaNode leafDecimal = assertInstanceOf(LeafSchemaNode.class, dataNode);
+ final var leafDecimal = assertInstanceOf(LeafSchemaNode.class, dataNode);
- final TypeDefinition<?> type = leafDecimal.getType();
+ final var type = leafDecimal.getType();
- final DecimalTypeDefinition decType = assertInstanceOf(DecimalTypeDefinition.class, type);
+ final var decType = assertInstanceOf(DecimalTypeDefinition.class, type);
assertEquals(4, decType.getFractionDigits());
- final Set<? extends Range<Decimal64>> decRangeConstraints = decType.getRangeConstraint().get()
- .getAllowedRanges().asRanges();
+ final var decRangeConstraints = decType.getRangeConstraint().orElseThrow().getAllowedRanges().asRanges();
assertEquals(1, decRangeConstraints.size());
- final Range<Decimal64> range = decRangeConstraints.iterator().next();
+ final var range = decRangeConstraints.iterator().next();
assertEquals(Decimal64.of(4, 15000), range.lowerEndpoint());
assertEquals(4, range.lowerEndpoint().scale());
assertEquals(Decimal64.of(4, 55000), range.upperEndpoint());
*/
package org.opendaylight.yangtools.yang.stmt;
+import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.startsWith;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.google.common.collect.Iterables;
-import com.google.common.collect.Range;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
@Test
void testIPVersion() {
- Module tested = CONTEXT.findModules("ietf-inet-types").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ var tested = CONTEXT.findModules("ietf-inet-types").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
assertEquals(14, typedefs.size());
- TypeDefinition<?> type = TestUtils.findTypedef(typedefs, "ip-version");
- assertTrue(type.getDescription().get().contains("This value represents the version of the IP protocol."));
- assertTrue(type.getReference().get().contains("RFC 2460: Internet Protocol, Version 6 (IPv6) Specification"));
+ var type = TestUtils.findTypedef(typedefs, "ip-version");
+ assertThat(type.getDescription().orElseThrow(),
+ containsString("This value represents the version of the IP protocol."));
+ assertThat(type.getReference().orElseThrow(),
+ containsString("RFC 2460: Internet Protocol, Version 6 (IPv6) Specification"));
- EnumTypeDefinition enumType = (EnumTypeDefinition) type.getBaseType();
- List<EnumPair> values = enumType.getValues();
+ var enumType = assertInstanceOf(EnumTypeDefinition.class, type.getBaseType());
+ var values = enumType.getValues();
assertEquals(3, values.size());
EnumPair value0 = values.get(0);
@Test
void testEnumeration() {
- Module tested = CONTEXT.findModules("custom-types-test").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
+ var tested = CONTEXT.findModules("custom-types-test").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
- TypeDefinition<?> type = TestUtils.findTypedef(typedefs, "ip-version");
- EnumTypeDefinition enumType = (EnumTypeDefinition) type.getBaseType();
- List<EnumPair> values = enumType.getValues();
+ var type = TestUtils.findTypedef(typedefs, "ip-version");
+ var enumType = assertInstanceOf(EnumTypeDefinition.class, type.getBaseType());
+ var values = enumType.getValues();
assertEquals(4, values.size());
- EnumPair value0 = values.get(0);
+ var value0 = values.get(0);
assertEquals("unknown", value0.getName());
assertEquals(0, value0.getValue());
assertEquals(Optional.of("An unknown or unspecified version of the Internet protocol."),
value0.getDescription());
- EnumPair value1 = values.get(1);
+ var value1 = values.get(1);
assertEquals("ipv4", value1.getName());
assertEquals(19, value1.getValue());
assertEquals(Optional.of("The IPv4 protocol as defined in RFC 791."), value1.getDescription());
- EnumPair value2 = values.get(2);
+ var value2 = values.get(2);
assertEquals("ipv6", value2.getName());
assertEquals(7, value2.getValue());
assertEquals(Optional.of("The IPv6 protocol as defined in RFC 2460."), value2.getDescription());
- EnumPair value3 = values.get(3);
+ var value3 = values.get(3);
assertEquals("default", value3.getName());
assertEquals(20, value3.getValue());
assertEquals(Optional.of("default ip"), value3.getDescription());
@Test
void testIpAddress() {
- Module tested = CONTEXT.findModules("ietf-inet-types").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
- TypeDefinition<?> type = TestUtils.findTypedef(typedefs, "ip-address");
- UnionTypeDefinition baseType = (UnionTypeDefinition) type.getBaseType();
- List<TypeDefinition<?>> unionTypes = baseType.getTypes();
+ var tested = CONTEXT.findModules("ietf-inet-types").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
+ var type = TestUtils.findTypedef(typedefs, "ip-address");
+ var baseType = assertInstanceOf(UnionTypeDefinition.class, type.getBaseType());
+ var unionTypes = baseType.getTypes();
- StringTypeDefinition ipv4 = (StringTypeDefinition) unionTypes.get(0);
+ var ipv4 = assertInstanceOf(StringTypeDefinition.class, unionTypes.get(0));
assertNotNull(ipv4.getBaseType());
- String expectedPattern = "^(?:(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}"
- + "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])" + "(%[\\p{N}\\p{L}]+)?)$";
- assertEquals(expectedPattern, ipv4.getPatternConstraints().get(0).getJavaPatternString());
+ assertEquals("""
+ ^(?:(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}\
+ ([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\
+ (%[\\p{N}\\p{L}]+)?)$""", ipv4.getPatternConstraints().get(0).getJavaPatternString());
- StringTypeDefinition ipv6 = (StringTypeDefinition) unionTypes.get(1);
+ var ipv6 = assertInstanceOf(StringTypeDefinition.class, unionTypes.get(1));
assertNotNull(ipv6.getBaseType());
- List<PatternConstraint> ipv6Patterns = ipv6.getPatternConstraints();
- expectedPattern = "^(?:((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}"
- + "((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|" + "(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}"
- + "(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))" + "(%[\\p{N}\\p{L}]+)?)$";
- assertEquals(expectedPattern, ipv6Patterns.get(0).getJavaPatternString());
-
- expectedPattern = "^(?:(([^:]+:){6}(([^:]+:[^:]+)|(.*\\..*)))|" + "((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)"
- + "(%.+)?)$";
- assertEquals(expectedPattern, ipv6Patterns.get(1).getJavaPatternString());
+ var ipv6Patterns = ipv6.getPatternConstraints();
+ assertEquals("""
+ ^(?:((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}\
+ ((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|\
+ (((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}\
+ (25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))\
+ (%[\\p{N}\\p{L}]+)?)$""", ipv6Patterns.get(0).getJavaPatternString());
+ assertEquals("""
+ ^(?:(([^:]+:){6}(([^:]+:[^:]+)|(.*\\..*)))|\
+ ((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)\
+ (%.+)?)$""", ipv6Patterns.get(1).getJavaPatternString());
}
@Test
void testDomainName() {
- Module tested = CONTEXT.findModules("ietf-inet-types").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
- StringTypeDefinition type = (StringTypeDefinition) TestUtils.findTypedef(typedefs, "domain-name");
+ var tested = CONTEXT.findModules("ietf-inet-types").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
+ var type = assertInstanceOf(StringTypeDefinition.class, TestUtils.findTypedef(typedefs, "domain-name"));
assertNotNull(type.getBaseType());
- List<PatternConstraint> patterns = type.getPatternConstraints();
+ var patterns = type.getPatternConstraints();
assertEquals(1, patterns.size());
- String expectedPattern = "^(?:((([a-zA-Z0-9_]([a-zA-Z0-9\\-_]){0,61})?[a-zA-Z0-9]\\.)*"
- + "([a-zA-Z0-9_]([a-zA-Z0-9\\-_]){0,61})?[a-zA-Z0-9]\\.?)" + "|\\.)$";
- assertEquals(expectedPattern, patterns.get(0).getJavaPatternString());
+ assertEquals("""
+ ^(?:((([a-zA-Z0-9_]([a-zA-Z0-9\\-_]){0,61})?[a-zA-Z0-9]\\.)*\
+ ([a-zA-Z0-9_]([a-zA-Z0-9\\-_]){0,61})?[a-zA-Z0-9]\\.?)\
+ |\\.)$""", patterns.get(0).getJavaPatternString());
- LengthConstraint lengths = type.getLengthConstraint().get();
+ var lengths = type.getLengthConstraint().orElseThrow();
assertEquals(1, lengths.getAllowedRanges().asRanges().size());
- Range<Integer> length = lengths.getAllowedRanges().span();
+ var length = lengths.getAllowedRanges().span();
assertEquals(Integer.valueOf(1), length.lowerEndpoint());
assertEquals(Integer.valueOf(253), length.upperEndpoint());
}
@Test
void testInstanceIdentifier1() {
- Module tested = CONTEXT.findModules("custom-types-test").iterator().next();
- LeafSchemaNode leaf = (LeafSchemaNode) tested.getDataChildByName(
- QName.create(tested.getQNameModule(), "inst-id-leaf1"));
- InstanceIdentifierTypeDefinition leafType = (InstanceIdentifierTypeDefinition) leaf.getType();
+ var tested = CONTEXT.findModules("custom-types-test").iterator().next();
+ var leaf = assertInstanceOf(LeafSchemaNode.class,
+ tested.getDataChildByName(QName.create(tested.getQNameModule(), "inst-id-leaf1")));
+ var leafType = assertInstanceOf(InstanceIdentifierTypeDefinition.class, leaf.getType());
assertFalse(leafType.requireInstance());
assertEquals(1,
leaf.asEffectiveStatement().getDeclared().declaredSubstatements(UnrecognizedStatement.class).size());
@Test
void testInstanceIdentifier2() {
- Module tested = CONTEXT.findModules("custom-types-test").iterator().next();
- LeafSchemaNode leaf = (LeafSchemaNode) tested.getDataChildByName(
- QName.create(tested.getQNameModule(), "inst-id-leaf2"));
- InstanceIdentifierTypeDefinition leafType = (InstanceIdentifierTypeDefinition) leaf.getType();
+ var tested = CONTEXT.findModules("custom-types-test").iterator().next();
+ var leaf = assertInstanceOf(LeafSchemaNode.class,
+ tested.getDataChildByName(QName.create(tested.getQNameModule(), "inst-id-leaf2")));
+ var leafType = assertInstanceOf(InstanceIdentifierTypeDefinition.class, leaf.getType());
assertFalse(leafType.requireInstance());
}
@Test
void testIdentity() {
- Module tested = CONTEXT.findModules("custom-types-test").iterator().next();
- Collection<? extends IdentitySchemaNode> identities = tested.getIdentities();
+ var tested = CONTEXT.findModules("custom-types-test").iterator().next();
+ var identities = tested.getIdentities();
assertEquals(5, identities.size());
IdentitySchemaNode cryptoAlg = null;
IdentitySchemaNode cryptoBase = null;
IdentitySchemaNode cryptoId = null;
- for (IdentitySchemaNode id : identities) {
+ for (var id : identities) {
if (id.getQName().getLocalName().equals("crypto-alg")) {
cryptoAlg = id;
} else if ("crypto-base".equals(id.getQName().getLocalName())) {
}
}
assertNotNull(cryptoAlg);
- IdentitySchemaNode baseIdentity = Iterables.getOnlyElement(cryptoAlg.getBaseIdentities());
+ var baseIdentity = Iterables.getOnlyElement(cryptoAlg.getBaseIdentities());
assertEquals("crypto-base", baseIdentity.getQName().getLocalName());
assertEquals(0, CONTEXT.getDerivedIdentities(cryptoAlg).size());
assertEquals(0, baseIdentity.getBaseIdentities().size());
@Test
void testBitsType1() {
- Module tested = CONTEXT.findModules("custom-types-test").iterator().next();
- LeafSchemaNode leaf = (LeafSchemaNode) tested.getDataChildByName(
- QName.create(tested.getQNameModule(), "mybits"));
- BitsTypeDefinition leafType = (BitsTypeDefinition) leaf.getType();
- Iterator<? extends Bit> bits = leafType.getBits().iterator();
+ var tested = CONTEXT.findModules("custom-types-test").iterator().next();
+ var leaf = assertInstanceOf(LeafSchemaNode.class,
+ tested.getDataChildByName(QName.create(tested.getQNameModule(), "mybits")));
+ var leafType = assertInstanceOf(BitsTypeDefinition.class, leaf.getType());
+ var bits = leafType.getBits().iterator();
- Bit bit1 = bits.next();
+ var bit1 = bits.next();
assertEquals("disable-nagle", bit1.getName());
assertEquals(Uint32.ZERO, bit1.getPosition());
- Bit bit2 = bits.next();
+ var bit2 = bits.next();
assertEquals("auto-sense-speed", bit2.getName());
assertEquals(Uint32.ONE, bit2.getPosition());
- Bit bit3 = bits.next();
+ var bit3 = bits.next();
assertEquals("only-10-Mb", bit3.getName());
assertEquals(Uint32.TWO, bit3.getPosition());
@Test
void testBitsType2() {
- Module tested = CONTEXT.findModules("custom-types-test").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
- TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "access-operations-type");
+ var tested = CONTEXT.findModules("custom-types-test").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
+ var testedType = TestUtils.findTypedef(typedefs, "access-operations-type");
- BitsTypeDefinition bitsType = (BitsTypeDefinition) testedType.getBaseType();
- Iterator<? extends Bit> bits = bitsType.getBits().iterator();
+ var bitsType = assertInstanceOf(BitsTypeDefinition.class, testedType.getBaseType());
+ var bits = bitsType.getBits().iterator();
- Bit bit0 = bits.next();
+ var bit0 = bits.next();
assertEquals("create", bit0.getName());
assertEquals(Uint32.ZERO, bit0.getPosition());
- Bit bit1 = bits.next();
+ var bit1 = bits.next();
assertEquals("delete", bit1.getName());
assertEquals(Uint32.valueOf(365), bit1.getPosition());
- Bit bit2 = bits.next();
+ var bit2 = bits.next();
assertEquals("read", bit2.getName());
assertEquals(Uint32.valueOf(500), bit2.getPosition());
- Bit bit3 = bits.next();
+ var bit3 = bits.next();
assertEquals("update", bit3.getName());
assertEquals(Uint32.valueOf(501), bit3.getPosition());
- Bit bit4 = bits.next();
+ var bit4 = bits.next();
assertEquals("exec", bit4.getName());
assertEquals(Uint32.valueOf(502), bit4.getPosition());
@Test
void testIanaTimezones() {
- Module tested = CONTEXT.findModules("iana-timezones").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
- TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "iana-timezone");
+ var tested = CONTEXT.findModules("iana-timezones").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
+ var testedType = TestUtils.findTypedef(typedefs, "iana-timezone");
- String expectedDesc = "A timezone location as defined by the IANA timezone";
- assertTrue(testedType.getDescription().get().contains(expectedDesc));
+ assertThat(testedType.getDescription().orElseThrow(),
+ containsString("A timezone location as defined by the IANA timezone"));
assertFalse(testedType.getReference().isPresent());
assertEquals(Status.CURRENT, testedType.getStatus());
assertEquals(Revision.ofNullable("2012-07-09"), testedTypeQName.getRevision());
assertEquals("iana-timezone", testedTypeQName.getLocalName());
- EnumTypeDefinition enumType = (EnumTypeDefinition) testedType.getBaseType();
- List<EnumPair> values = enumType.getValues();
+ var enumType = assertInstanceOf(EnumTypeDefinition.class, testedType.getBaseType());
+ var values = enumType.getValues();
// 0-414
assertEquals(415, values.size());
- EnumPair enum168 = values.get(168);
+ var enum168 = values.get(168);
assertEquals("America/Danmarkshavn", enum168.getName());
assertEquals(168, enum168.getValue());
assertEquals(Optional.of("east coast, north of Scoresbysund"), enum168.getDescription());
- EnumPair enum374 = values.get(374);
+ var enum374 = values.get(374);
assertEquals("America/Indiana/Winamac", enum374.getName());
assertEquals(374, enum374.getValue());
assertEquals(Optional.of("Eastern Time - Indiana - Pulaski County"), enum374.getDescription());
@Test
void testObjectId128() {
- Module tested = CONTEXT.findModules("ietf-yang-types").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
- StringTypeDefinition testedType = (StringTypeDefinition) TestUtils.findTypedef(typedefs,
- "object-identifier-128");
+ var tested = CONTEXT.findModules("ietf-yang-types").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
+ var testedType = assertInstanceOf(StringTypeDefinition.class,
+ TestUtils.findTypedef(typedefs, "object-identifier-128"));
- List<PatternConstraint> patterns = testedType.getPatternConstraints();
+ var patterns = testedType.getPatternConstraints();
assertEquals(1, patterns.size());
- PatternConstraint pattern = patterns.get(0);
+ var pattern = patterns.get(0);
assertEquals("^(?:\\d*(\\.\\d*){1,127})$", pattern.getJavaPatternString());
QName testedTypeQName = testedType.getQName();
assertEquals(Revision.ofNullable("2010-09-24"), testedTypeQName.getRevision());
assertEquals("object-identifier-128", testedTypeQName.getLocalName());
- StringTypeDefinition testedTypeBase = testedType.getBaseType();
+ var testedTypeBase = testedType.getBaseType();
patterns = testedTypeBase.getPatternConstraints();
assertEquals(1, patterns.size());
@Test
void testIdentityref() {
- Module tested = CONTEXT.findModules("custom-types-test").iterator().next();
- Collection<? extends TypeDefinition<?>> typedefs = tested.getTypeDefinitions();
- TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "service-type-ref");
- IdentityrefTypeDefinition baseType = (IdentityrefTypeDefinition) testedType.getBaseType();
+ var tested = CONTEXT.findModules("custom-types-test").iterator().next();
+ var typedefs = tested.getTypeDefinitions();
+ var testedType = TestUtils.findTypedef(typedefs, "service-type-ref");
+ var baseType = assertInstanceOf(IdentityrefTypeDefinition.class, testedType.getBaseType());
QName identity = baseType.getIdentities().iterator().next().getQName();
assertEquals(XMLNamespace.of("urn:custom.types.demo"), identity.getNamespace());
assertEquals(Revision.ofNullable("2012-04-16"), identity.getRevision());
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.xpath.api.YangExpr;
import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.Relative;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathAxis;
@Test
void testWhenPrefixes() {
- final DataSchemaNode bar = assertEffectiveModelDir("/bugs/YT1201/").getDataChildByName(BAR);
- final YangExpr when = assertInstanceOf(ContainerSchemaNode.class, bar).getWhenCondition().orElseThrow()
+ final var bar = assertEffectiveModelDir("/bugs/YT1201/").getDataChildByName(BAR);
+ final var when = assertInstanceOf(ContainerSchemaNode.class, bar).getWhenCondition().orElseThrow()
.getRootExpr();
assertEquals(List.of(YangXPathAxis.CHILD.asStep(FOO)), assertInstanceOf(Relative.class, when).getSteps());
}
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
class YT911Test extends AbstractYangTest {
private static final QName FOO = QName.create("foo", "2018-10-22", "foo");
assertEquals(Optional.of(Boolean.FALSE), foo.effectiveConfig());
// Instantiated node
- final DataSchemaNode bar = foo.findDataTreeChild(BAR).orElseThrow();
+ final var bar = foo.findDataTreeChild(BAR).orElseThrow();
assertEquals(Optional.of(Boolean.FALSE), bar.effectiveConfig());
// Original augmentation node
- final AugmentationSchemaNode aug = foo.getAvailableAugmentations().iterator().next();
- final DataSchemaNode augBar = aug.findDataTreeChild(BAR).orElseThrow();
+ final var aug = foo.getAvailableAugmentations().iterator().next();
+ final var augBar = aug.findDataTreeChild(BAR).orElseThrow();
assertEquals(Optional.empty(), augBar.effectiveConfig());
}
}
final var another = assertEffectiveModelDir("/bugs/YT956/").getDataChildByName(ANOTHER_CONTAINER);
final var anotherContainer = assertInstanceOf(ContainerSchemaNode.class, another);
- final var first = anotherContainer.findDataChildByName(FIRST_AUGMENT).get();
+ final var first = anotherContainer.getDataChildByName(FIRST_AUGMENT);
final var firstAugment = assertInstanceOf(ContainerSchemaNode.class, first);
// Augmentation needs to be added
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
class YT983Test extends AbstractYangTest {
- private static final QName FOO = QName.create("foo", "2019-04-30", "foo");
-
@Test
void testAugmentationConfig() {
final var context = assertEffectiveModel("/bugs/YT983/foo.yang");
- assertInstanceOf(LeafSchemaNode.class, context.getDataChildByName(FOO));
+ assertInstanceOf(LeafSchemaNode.class, context.getDataChildByName(QName.create("foo", "2019-04-30", "foo")));
}
}
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import com.google.common.collect.Iterables;
import com.google.common.collect.Range;
-import java.util.Map;
import java.util.Optional;
-import java.util.Set;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
-import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
-import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.RFC7950Reactors;
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
class YangParserWithContextTest {
sourceForResource("/ietf/network-topology@2013-10-21.yang")};
@Test
- void testTypeFromContext() throws ReactorException {
- final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
+ void testTypeFromContext() throws Exception {
+ final var context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test1.yang"))
.buildEffective();
- final Module module = context.findModule("test1", Revision.of("2013-06-18")).get();
- final LeafSchemaNode leaf = (LeafSchemaNode) module.getDataChildByName(QName.create(module.getQNameModule(),
- "id"));
+ final var module = context.findModule("test1", Revision.of("2013-06-18")).orElseThrow();
+ final var leaf = assertInstanceOf(LeafSchemaNode.class,
+ module.getDataChildByName(QName.create(module.getQNameModule(), "id")));
- final Uint16TypeDefinition leafType = assertInstanceOf(Uint16TypeDefinition.class, leaf.getType());
+ final var leafType = assertInstanceOf(Uint16TypeDefinition.class, leaf.getType());
QName qname = leafType.getQName();
assertEquals(XMLNamespace.of("urn:simple.demo.test1"), qname.getNamespace());
assertEquals(Revision.ofNullable("2013-06-18"), qname.getRevision());
assertEquals("port-number", qname.getLocalName());
- final Uint16TypeDefinition leafBaseType = leafType.getBaseType();
+ final var leafBaseType = leafType.getBaseType();
qname = leafBaseType.getQName();
assertEquals(XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-inet-types"), qname.getNamespace());
assertEquals(Revision.ofNullable("2010-09-24"), qname.getRevision());
assertEquals("port-number", qname.getLocalName());
- final Uint8TypeDefinition dscpExt = (Uint8TypeDefinition) TestUtils.findTypedef(module.getTypeDefinitions(),
- "dscp-ext");
- final Set<? extends Range<?>> ranges = dscpExt.getRangeConstraint().get().getAllowedRanges().asRanges();
+ final var dscpExt = assertInstanceOf(Uint8TypeDefinition.class,
+ TestUtils.findTypedef(module.getTypeDefinitions(), "dscp-ext"));
+ final var ranges = dscpExt.getRangeConstraint().orElseThrow().getAllowedRanges().asRanges();
assertEquals(1, ranges.size());
final Range<?> range = ranges.iterator().next();
assertEquals(Uint8.valueOf(0), range.lowerEndpoint());
}
@Test
- void testUsesFromContext() throws ReactorException {
- final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
+ void testUsesFromContext() throws Exception {
+ final var context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
.buildEffective();
- final Module testModule = context.findModule("test2", Revision.of("2013-06-18")).get();
- final Module contextModule = context.findModules(XMLNamespace.of("urn:opendaylight.baz")).iterator().next();
+ final var testModule = context.findModule("test2", Revision.of("2013-06-18")).orElseThrow();
+ final var contextModule = context.findModules(XMLNamespace.of("urn:opendaylight.baz")).iterator().next();
assertNotNull(contextModule);
final var groupings = contextModule.getGroupings();
assertEquals(1, groupings.size());
- final GroupingDefinition grouping = groupings.iterator().next();
+ final var grouping = groupings.iterator().next();
// get node containing uses
- final ContainerSchemaNode peer = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(
- testModule.getQNameModule(), "peer"));
- final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
- testModule.getQNameModule(), "destination"));
+ final var peer = assertInstanceOf(ContainerSchemaNode.class,
+ testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "peer")));
+ final var destination = assertInstanceOf(ContainerSchemaNode.class,
+ peer.getDataChildByName(QName.create(testModule.getQNameModule(), "destination")));
// check uses
final var uses = destination.getUses();
assertEquals(1, uses.size());
// check uses process
- final AnyxmlSchemaNode data_u = (AnyxmlSchemaNode) destination.getDataChildByName(QName.create(
- testModule.getQNameModule(), "data"));
- assertNotNull(data_u);
+ final var data_u = assertInstanceOf(AnyxmlSchemaNode.class,
+ destination.getDataChildByName(QName.create(testModule.getQNameModule(), "data")));
assertTrue(data_u.isAddedByUses());
- final AnyxmlSchemaNode data_g = (AnyxmlSchemaNode) grouping.getDataChildByName(QName.create(
- contextModule.getQNameModule(), "data"));
- assertNotNull(data_g);
+ final var data_g = assertInstanceOf(AnyxmlSchemaNode.class,
+ grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "data")));
assertFalse(data_g.isAddedByUses());
assertNotEquals(data_u, data_g);
- final ChoiceSchemaNode how_u = (ChoiceSchemaNode) destination.getDataChildByName(QName.create(
- testModule.getQNameModule(), "how"));
- assertNotNull(how_u);
+ final var how_u = assertInstanceOf(ChoiceSchemaNode.class,
+ destination.getDataChildByName(QName.create(testModule.getQNameModule(), "how")));
assertTrue(how_u.isAddedByUses());
- final ChoiceSchemaNode how_g = (ChoiceSchemaNode) grouping.getDataChildByName(QName.create(
- contextModule.getQNameModule(), "how"));
- assertNotNull(how_g);
+ final var how_g = assertInstanceOf(ChoiceSchemaNode.class,
+ grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "how")));
assertFalse(how_g.isAddedByUses());
assertNotEquals(how_u, how_g);
- final LeafSchemaNode address_u = (LeafSchemaNode) destination.getDataChildByName(QName.create(
- testModule.getQNameModule(), "address"));
- assertNotNull(address_u);
+ final var address_u = assertInstanceOf(LeafSchemaNode.class,
+ destination.getDataChildByName(QName.create(testModule.getQNameModule(), "address")));
assertTrue(address_u.isAddedByUses());
- final LeafSchemaNode address_g = (LeafSchemaNode) grouping.getDataChildByName(QName.create(
- contextModule.getQNameModule(), "address"));
- assertNotNull(address_g);
+ final var address_g = assertInstanceOf(LeafSchemaNode.class,
+ grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "address")));
assertFalse(address_g.isAddedByUses());
assertNotEquals(address_u, address_g);
- final ContainerSchemaNode port_u = (ContainerSchemaNode) destination.getDataChildByName(QName.create(
- testModule.getQNameModule(), "port"));
- assertNotNull(port_u);
+ final var port_u = assertInstanceOf(ContainerSchemaNode.class,
+ destination.getDataChildByName(QName.create(testModule.getQNameModule(), "port")));
assertTrue(port_u.isAddedByUses());
- final ContainerSchemaNode port_g = (ContainerSchemaNode) grouping.getDataChildByName(QName.create(
- contextModule.getQNameModule(), "port"));
+ final var port_g = assertInstanceOf(ContainerSchemaNode.class,
+ grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "port")));
assertNotNull(port_g);
assertFalse(port_g.isAddedByUses());
assertNotEquals(port_u, port_g);
- final ListSchemaNode addresses_u = (ListSchemaNode) destination.getDataChildByName(QName.create(
- testModule.getQNameModule(), "addresses"));
+ final ListSchemaNode addresses_u = assertInstanceOf(ListSchemaNode.class,
+ destination.getDataChildByName(QName.create(testModule.getQNameModule(), "addresses")));
assertNotNull(addresses_u);
assertTrue(addresses_u.isAddedByUses());
- final ListSchemaNode addresses_g = (ListSchemaNode) grouping.getDataChildByName(QName.create(
- contextModule.getQNameModule(), "addresses"));
+ final ListSchemaNode addresses_g = assertInstanceOf(ListSchemaNode.class,
+ grouping.getDataChildByName(QName.create(contextModule.getQNameModule(), "addresses")));
assertNotNull(addresses_g);
assertFalse(addresses_g.isAddedByUses());
assertNotEquals(addresses_u, addresses_g);
// grouping defined in 'grouping' node
final var groupings_g = grouping.getGroupings();
assertEquals(1, groupings_g.size());
- final GroupingDefinition grouping_g = groupings_g.iterator().next();
+ final var grouping_g = groupings_g.iterator().next();
assertFalse(grouping_g.isAddedByUses());
}
@Test
- void testUsesRefineFromContext() throws ReactorException {
- final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
+ void testUsesRefineFromContext() throws Exception {
+ final var context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(BAZ, FOO, BAR, SUBFOO, sourceForResource("/context-test/test2.yang"))
.buildEffective();
- final Module module = context.findModule("test2", Revision.of("2013-06-18")).get();
- final ContainerSchemaNode peer = (ContainerSchemaNode) module.getDataChildByName(QName.create(
- module.getQNameModule(), "peer"));
- final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
- module.getQNameModule(), "destination"));
+ final var module = context.findModule("test2", Revision.of("2013-06-18")).orElseThrow();
+ final var peer = assertInstanceOf(ContainerSchemaNode.class,
+ module.getDataChildByName(QName.create(module.getQNameModule(), "peer")));
+ final var destination = assertInstanceOf(ContainerSchemaNode.class,
+ peer.getDataChildByName(QName.create(module.getQNameModule(), "destination")));
final var usesNodes = destination.getUses();
assertEquals(1, usesNodes.size());
final UsesNode usesNode = usesNodes.iterator().next();
usesNode.getSourceGrouping().getQName());
// test refine
- final Map<Descendant, SchemaNode> refines = usesNode.getRefines();
+ final var refines = usesNode.getRefines();
assertEquals(3, refines.size());
LeafSchemaNode refineLeaf = null;
ContainerSchemaNode refineContainer = null;
ListSchemaNode refineList = null;
- for (final Map.Entry<Descendant, SchemaNode> entry : refines.entrySet()) {
+ for (var entry : refines.entrySet()) {
final SchemaNode value = entry.getValue();
- if (value instanceof LeafSchemaNode) {
- refineLeaf = (LeafSchemaNode) value;
- } else if (value instanceof ContainerSchemaNode) {
- refineContainer = (ContainerSchemaNode) value;
- } else if (value instanceof ListSchemaNode) {
- refineList = (ListSchemaNode) value;
+ if (value instanceof LeafSchemaNode leaf) {
+ refineLeaf = leaf;
+ } else if (value instanceof ContainerSchemaNode container) {
+ refineContainer = container;
+ } else if (value instanceof ListSchemaNode list) {
+ refineList = list;
}
}
assertTrue(refineLeaf.isMandatory());
final var leafMustConstraints = refineLeaf.getMustConstraints();
assertEquals(1, leafMustConstraints.size());
- final MustDefinition leafMust = leafMustConstraints.iterator().next();
+ final var leafMust = leafMustConstraints.iterator().next();
assertEquals("ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)", leafMust.getXpath().toString());
// container port
assertEquals(Optional.of("description of addresses defined by refine"), refineList.getDescription());
assertEquals(Optional.of("addresses reference added by refine"), refineList.getReference());
assertEquals(Optional.of(Boolean.FALSE), refineList.effectiveConfig());
- final ElementCountConstraint constraint = refineList.getElementCountConstraint().get();
+ final var constraint = refineList.getElementCountConstraint().orElseThrow();
assertEquals((Object) 2, constraint.getMinElements());
assertEquals((Object) 12, constraint.getMaxElements());
}
@Test
- void testIdentity() throws ReactorException {
- final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
+ void testIdentity() throws Exception {
+ final var context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test3.yang"))
.buildEffective();
- final Module module = context.findModule("test3", Revision.of("2013-06-18")).get();
+ final var module = context.findModule("test3", Revision.of("2013-06-18")).orElseThrow();
final var identities = module.getIdentities();
assertEquals(1, identities.size());
- final IdentitySchemaNode identity = identities.iterator().next();
+ final var identity = identities.iterator().next();
final QName idQName = identity.getQName();
assertEquals(XMLNamespace.of("urn:simple.demo.test3"), idQName.getNamespace());
assertEquals(Revision.ofNullable("2013-06-18"), idQName.getRevision());
assertEquals("pt", idQName.getLocalName());
- final IdentitySchemaNode baseIdentity = Iterables.getOnlyElement(identity.getBaseIdentities());
+ final var baseIdentity = Iterables.getOnlyElement(identity.getBaseIdentities());
final QName idBaseQName = baseIdentity.getQName();
assertEquals(XMLNamespace.of("urn:custom.types.demo"), idBaseQName.getNamespace());
assertEquals(Revision.ofNullable("2012-04-16"), idBaseQName.getRevision());
}
@Test
- void testUnknownNodes() throws ReactorException {
- final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
+ void testUnknownNodes() throws Exception {
+ final var context = RFC7950Reactors.defaultReactor().newBuild()
.addSources(IETF)
.addSource(sourceForResource("/types/custom-types-test@2012-04-04.yang"))
.addSource(sourceForResource("/context-test/test3.yang"))
.buildEffective();
- final Module module = context.findModule("test3", Revision.of("2013-06-18")).get();
- final ContainerStatement network = ((ContainerSchemaNode) module.getDataChildByName(
- QName.create(module.getQNameModule(), "network"))).asEffectiveStatement().getDeclared();
+ final var module = context.findModule("test3", Revision.of("2013-06-18")).orElseThrow();
+ final var network = assertInstanceOf(ContainerSchemaNode.class,
+ module.getDataChildByName(QName.create(module.getQNameModule(), "network")))
+ .asEffectiveStatement().getDeclared();
final var unknownNodes = network.declaredSubstatements(UnrecognizedStatement.class);
assertEquals(1, unknownNodes.size());
- final UnrecognizedStatement un = unknownNodes.iterator().next();
+ final var un = unknownNodes.iterator().next();
final QName unType = un.statementDefinition().getStatementName();
assertEquals(XMLNamespace.of("urn:custom.types.demo"), unType.getNamespace());
assertEquals(Revision.ofNullable("2012-04-16"), unType.getRevision());
@Test
void testAugment() throws Exception {
- final Module t4 = TestUtils.parseYangSource(
+ final var t4 = TestUtils.parseYangSource(
"/context-augment-test/test1.yang", "/context-augment-test/test2.yang",
"/context-augment-test/test3.yang", "/context-augment-test/test4.yang")
.findModules("test4").iterator().next();
- final ContainerSchemaNode interfaces = (ContainerSchemaNode) t4.getDataChildByName(QName.create(
- t4.getQNameModule(), "interfaces"));
- final ListSchemaNode ifEntry = (ListSchemaNode) interfaces.getDataChildByName(QName.create(t4.getQNameModule(),
- "ifEntry"));
+ final var interfaces = assertInstanceOf(ContainerSchemaNode.class,
+ t4.getDataChildByName(QName.create(t4.getQNameModule(), "interfaces")));
+ final var ifEntry = assertInstanceOf(ListSchemaNode.class,
+ interfaces.getDataChildByName(QName.create(t4.getQNameModule(), "ifEntry")));
// test augmentation process
- final ContainerSchemaNode augmentHolder = (ContainerSchemaNode) ifEntry.getDataChildByName(QName.create(T3_NS,
- REV, "augment-holder"));
- assertNotNull(augmentHolder);
- final DataSchemaNode ds0 = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "ds0ChannelNumber"));
- assertNotNull(ds0);
- final DataSchemaNode interfaceId = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "interface-id"));
+ final var augmentHolder = assertInstanceOf(ContainerSchemaNode.class,
+ ifEntry.getDataChildByName(QName.create(T3_NS, REV, "augment-holder")));
+ final var ds0 = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "ds0ChannelNumber"));
+ final var interfaceId = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "interface-id"));
assertNotNull(interfaceId);
- final DataSchemaNode higherLayerIf = augmentHolder.getDataChildByName(QName.create(T2_NS, REV,
- "higher-layer-if"));
- assertNotNull(higherLayerIf);
- final ContainerSchemaNode schemas = (ContainerSchemaNode) augmentHolder.getDataChildByName(QName.create(T2_NS,
- REV, "schemas"));
- assertNotNull(schemas);
+ final var higherLayerIf = augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "higher-layer-if"));
+ final var schemas = assertInstanceOf(ContainerSchemaNode.class,
+ augmentHolder.getDataChildByName(QName.create(T2_NS, REV, "schemas")));
assertNotNull(schemas.getDataChildByName(QName.create(T1_NS, REV, "id")));
// test augment target after augmentation: check if it is same instance
- final ListSchemaNode ifEntryAfterAugment = (ListSchemaNode) interfaces.getDataChildByName(QName.create(
- t4.getQNameModule(), "ifEntry"));
- assertTrue(ifEntry == ifEntryAfterAugment);
+ final var ifEntryAfterAugment = assertInstanceOf(ListSchemaNode.class,
+ interfaces.getDataChildByName(QName.create(t4.getQNameModule(), "ifEntry")));
+ assertSame(ifEntry, ifEntryAfterAugment);
}
@Test
- void testDeviation() throws ReactorException {
- final SchemaContext context = RFC7950Reactors.defaultReactor().newBuild()
+ void testDeviation() throws Exception {
+ final var context = RFC7950Reactors.defaultReactor().newBuild()
.addSource(sourceForResource("/model/bar.yang"))
.addSource(sourceForResource("/context-test/deviation-test.yang"))
.buildEffective();
- final Module testModule = context.findModule("deviation-test", Revision.of("2013-02-27")).get();
+ final var testModule = context.findModule("deviation-test", Revision.of("2013-02-27")).orElseThrow();
final var deviations = testModule.getDeviations();
assertEquals(1, deviations.size());
- final Deviation dev = deviations.iterator().next();
+ final var dev = deviations.iterator().next();
assertEquals(Optional.of("system/user ref"), dev.getReference());
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
-import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.stmt.AbstractYangTest;
class Bug5200Test extends AbstractYangTest {
- private static final String NS = "foo";
- private static final String REV = "2016-05-05";
-
@Test
void test() {
final var context = assertEffectiveModelDir("/bugs/bug5200");
+ final var root = QName.create("foo", "2016-05-05", "root");
- QName root = QName.create(NS, REV, "root");
- QName myLeaf = QName.create(NS, REV, "my-leaf");
- QName myLeaf2 = QName.create(NS, REV, "my-leaf-2");
-
- SchemaNode myLeafNode = context.findDataTreeChild(root, myLeaf).orElseThrow();
- SchemaNode myLeaf2Node = context.findDataTreeChild(root, myLeaf2).orElseThrow();
+ var myLeafNode = context.findDataTreeChild(root, QName.create(root, "my-leaf")).orElseThrow();
+ var myLeaf2Node = context.findDataTreeChild(root, QName.create(root, "my-leaf-2")).orElseThrow();
final var myLeafType = assertInstanceOf(StringTypeDefinition.class,
assertInstanceOf(LeafSchemaNode.class, myLeafNode).getType());
final var myLeaf2Type = assertInstanceOf(Int32TypeDefinition.class,
assertInstanceOf(LeafSchemaNode.class, myLeaf2Node).getType());
- final LengthConstraint lengthConstraint = myLeafType.getLengthConstraint().orElseThrow();
- final List<PatternConstraint> patternConstraints = myLeafType.getPatternConstraints();
+ final var lengthConstraint = myLeafType.getLengthConstraint().orElseThrow();
+ final var patternConstraints = myLeafType.getPatternConstraints();
assertEquals(1, lengthConstraint.getAllowedRanges().asRanges().size());
assertEquals(1, patternConstraints.size());
assertEquals(Optional.of("lenght constraint error-app-tag"), lengthConstraint.getErrorAppTag());
assertEquals(Optional.of("lenght constraint error-app-message"), lengthConstraint.getErrorMessage());
- PatternConstraint patternConstraint = patternConstraints.iterator().next();
+ final var patternConstraint = patternConstraints.iterator().next();
assertEquals(Optional.of("pattern constraint error-app-tag"), patternConstraint.getErrorAppTag());
assertEquals(Optional.of("pattern constraint error-app-message"), patternConstraint.getErrorMessage());
- RangeConstraint<?> rangeConstraint = myLeaf2Type.getRangeConstraint().orElseThrow();
+ var rangeConstraint = myLeaf2Type.getRangeConstraint().orElseThrow();
assertEquals(1, rangeConstraint.getAllowedRanges().asRanges().size());
assertEquals(Optional.of("range constraint error-app-tag"), rangeConstraint.getErrorAppTag());
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-import java.util.Collection;
-import java.util.Iterator;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class YinFileAugmentStmtTest extends AbstractYinModulesTest {
@Test
void testAugment() {
- final Module testModule = context.findModules("main-impl").iterator().next();
+ final var testModule = context.findModules("main-impl").iterator().next();
assertNotNull(testModule);
- final Collection<? extends AugmentationSchemaNode> augmentations = testModule.getAugmentations();
+ final var augmentations = testModule.getAugmentations();
assertEquals(1, augmentations.size());
- final Iterator<? extends AugmentationSchemaNode> augmentIterator = augmentations.iterator();
- final AugmentationSchemaNode augment = augmentIterator.next();
- assertNotNull(augment);
+ final var augment = augmentations.iterator().next();
assertThat(augment.getTargetPath().toString(), containsString(
"(urn:opendaylight:params:xml:ns:yang:controller:config?revision=2013-04-05)modules, module, "
+ "configuration"));
assertEquals(1, augment.getChildNodes().size());
- final DataSchemaNode caseNode = augment.findDataChildByName(
- QName.create(testModule.getQNameModule(), "main-impl")).get();
- assertInstanceOf(CaseSchemaNode.class, caseNode);
+ assertInstanceOf(CaseSchemaNode.class, augment.getDataChildByName(
+ QName.create(testModule.getQNameModule(), "main-impl")));
}
}
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class YinFileChoiceStmtTest extends AbstractYinModulesTest {
@Test
void testChoiceAndCases() {
- final Module testModule = context.findModules("config").iterator().next();
+ final var testModule = context.findModules("config").iterator().next();
assertNotNull(testModule);
- final ListSchemaNode list = (ListSchemaNode) testModule.findDataChildByName(
+ final var list = assertInstanceOf(ListSchemaNode.class, testModule.findDataChildByName(
QName.create(testModule.getQNameModule(), "modules"),
- QName.create(testModule.getQNameModule(), "module")).get();
+ QName.create(testModule.getQNameModule(), "module")).orElseThrow());
- ChoiceSchemaNode choice = (ChoiceSchemaNode) list.findDataChildByName(QName.create(testModule.getQNameModule(),
- "configuration")).get();
+ var choice = assertInstanceOf(ChoiceSchemaNode.class,
+ list.getDataChildByName(QName.create(testModule.getQNameModule(), "configuration")));
assertEquals("configuration", choice.getQName().getLocalName());
assertTrue(choice.isMandatory());
// this choice is augmented (see main-impl.yang.xml)
final var casesIterator = choice.getCases().iterator();
- final CaseSchemaNode caseNode = casesIterator.next();
+ final var caseNode = casesIterator.next();
assertEquals("main-impl", caseNode.getQName().getLocalName());
assertEquals(13, caseNode.getChildNodes().size());
assertTrue(caseNode.getWhenCondition().isPresent());
- choice = (ChoiceSchemaNode) list.findDataChildByName(QName.create(testModule.getQNameModule(), "state")).get();
+ choice = assertInstanceOf(ChoiceSchemaNode.class,
+ list.getDataChildByName(QName.create(testModule.getQNameModule(), "state")));
assertEquals("state", choice.getQName().getLocalName());
assertFalse(choice.isMandatory());
package org.opendaylight.yangtools.yang.stmt.yin;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import java.util.Collection;
-import java.util.Iterator;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class YinFileGroupingStmtTest extends AbstractYinModulesTest {
@Test
void testGrouping() {
- final Module testModule = context.findModules("config").iterator().next();
- assertNotNull(testModule);
-
- final Collection<? extends GroupingDefinition> groupings = testModule.getGroupings();
+ final var testModule = context.findModules("config").iterator().next();
+ final var groupings = testModule.getGroupings();
assertEquals(1, groupings.size());
- final Iterator<? extends GroupingDefinition> groupingsIterator = groupings.iterator();
- final GroupingDefinition grouping = groupingsIterator.next();
+ final var groupingsIterator = groupings.iterator();
+ final var grouping = groupingsIterator.next();
assertEquals("service-ref", grouping.getQName().getLocalName());
- assertEquals(Optional.of("Type of references to a particular service instance. This type\n"
- + "can be used when defining module configuration to refer to a\n"
- + "particular service instance. Containers using this grouping\n"
- + "should not define anything else. The run-time implementation\n"
- + "is expected to inject a reference to the service as the value\n"
- + "of the container."), grouping.getDescription());
-
- final Collection<? extends DataSchemaNode> children = grouping.getChildNodes();
+ assertEquals(Optional.of("""
+ Type of references to a particular service instance. This type
+ can be used when defining module configuration to refer to a
+ particular service instance. Containers using this grouping
+ should not define anything else. The run-time implementation
+ is expected to inject a reference to the service as the value
+ of the container."""), grouping.getDescription());
+
+ final var children = grouping.getChildNodes();
assertEquals(2, children.size());
- final LeafSchemaNode leaf1 = (LeafSchemaNode) grouping.findDataChildByName(QName.create(
- testModule.getQNameModule(), "type")).get();
+ final var leaf1 = assertInstanceOf(LeafSchemaNode.class,
+ grouping.getDataChildByName(QName.create(testModule.getQNameModule(), "type")));
assertTrue(leaf1.isMandatory());
- final LeafSchemaNode leaf2 = (LeafSchemaNode) grouping.findDataChildByName(QName.create(
- testModule.getQNameModule(), "name")).get();
+ final var leaf2 = assertInstanceOf(LeafSchemaNode.class,
+ grouping.getDataChildByName(QName.create(testModule.getQNameModule(), "name")));
assertTrue(leaf2.isMandatory());
}
}
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
class YinFileLeafListStmtTest extends AbstractYinModulesTest {
@Test
void testLeafList() {
- final Module testModule = context.findModules("ietf-netconf-monitoring").iterator().next();
-
- final LeafListSchemaNode leafList = (LeafListSchemaNode) testModule.findDataChildByName(
+ final var testModule = context.findModules("ietf-netconf-monitoring").iterator().next();
+ final var leafList = assertInstanceOf(LeafListSchemaNode.class, testModule.findDataChildByName(
QName.create(testModule.getQNameModule(), "netconf-state"),
QName.create(testModule.getQNameModule(), "capabilities"),
- QName.create(testModule.getQNameModule(), "capability")).get();
- assertNotNull(leafList);
+ QName.create(testModule.getQNameModule(), "capability")).orElseThrow());
assertEquals("uri", leafList.getType().getQName().getLocalName());
assertEquals(Optional.of("List of NETCONF capabilities supported by the server."), leafList.getDescription());
assertFalse(leafList.isUserOrdered());
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.ri.type.BaseTypes;
class YinFileListStmtTest extends AbstractYinModulesTest {
@Test
void testListAndLeaves() {
- final Module testModule = context.findModules("config").iterator().next();
+ final var testModule = context.findModules("config").iterator().next();
assertNotNull(testModule);
- final ListSchemaNode list = (ListSchemaNode) testModule.findDataChildByName(QName.create(
- testModule.getQNameModule(), "modules"), QName.create(testModule.getQNameModule(), "module")).get();
- final List<QName> keys = list.getKeyDefinition();
+ final var list = assertInstanceOf(ListSchemaNode.class,
+ testModule.findDataChildByName(
+ QName.create(testModule.getQNameModule(), "modules"),
+ QName.create(testModule.getQNameModule(), "module"))
+ .orElseThrow());
+ final var keys = list.getKeyDefinition();
assertEquals(1, keys.size());
assertEquals("name", keys.get(0).getLocalName());
- final Collection<? extends DataSchemaNode> children = list.getChildNodes();
+ final var children = list.getChildNodes();
assertEquals(4, children.size());
- final Iterator<? extends DataSchemaNode> childrenIterator = children.iterator();
- LeafSchemaNode leaf = (LeafSchemaNode) childrenIterator.next();
+ final var childrenIterator = children.iterator();
+ var leaf = assertInstanceOf(LeafSchemaNode.class, childrenIterator.next());
assertEquals("name", leaf.getQName().getLocalName());
assertEquals(Optional.of("Unique module instance name"), leaf.getDescription());
assertEquals(BaseTypes.stringType(), leaf.getType());
assertTrue(leaf.isMandatory());
- leaf = (LeafSchemaNode) childrenIterator.next();
+ leaf = assertInstanceOf(LeafSchemaNode.class, childrenIterator.next());
assertEquals("type", leaf.getQName().getLocalName());
- final IdentityrefTypeDefinition leafType = assertInstanceOf(IdentityrefTypeDefinition.class, leaf.getType());
+ final var leafType = assertInstanceOf(IdentityrefTypeDefinition.class, leaf.getType());
assertEquals("module-type", leafType.getIdentities().iterator().next().getQName().getLocalName());
assertTrue(leaf.isMandatory());
}
package org.opendaylight.yangtools.yang.stmt.yin;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-import java.util.Collection;
-import java.util.Iterator;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
class YinFileUsesStmtTest extends AbstractYinModulesTest {
@Test
void testUses() {
- final Module testModule = context.findModules("main-impl").iterator().next();
+ final var testModule = context.findModules("main-impl").iterator().next();
- final Collection<? extends AugmentationSchemaNode> augmentations = testModule.getAugmentations();
+ final var augmentations = testModule.getAugmentations();
assertEquals(1, augmentations.size());
- final Iterator<? extends AugmentationSchemaNode> augmentIterator = augmentations.iterator();
- final AugmentationSchemaNode augment = augmentIterator.next();
+ final var augmentIterator = augmentations.iterator();
+ final var augment = augmentIterator.next();
- final ContainerSchemaNode container = (ContainerSchemaNode) augment.findDataChildByName(
+ final var container = assertInstanceOf(ContainerSchemaNode.class, augment.findDataChildByName(
QName.create(testModule.getQNameModule(), "main-impl"),
- QName.create(testModule.getQNameModule(), "notification-service")).get();
+ QName.create(testModule.getQNameModule(), "notification-service")).orElseThrow());
assertEquals(1, container.getUses().size());
- final UsesNode usesNode = container.getUses().iterator().next();
+ final var usesNode = container.getUses().iterator().next();
assertNotNull(usesNode);
assertEquals("(urn:opendaylight:params:xml:ns:yang:controller:config?revision=2013-04-05)service-ref",
usesNode.getSourceGrouping().getQName().toString());
public static <T> @NonNull T unwrap(final Optional<T> opt, final @NonNull StatementSourceReference source,
final @NonNull String format, final Object... args) {
throwIf(opt.isEmpty(), source, format, args);
- return opt.get();
+ return opt.orElseThrow();
}
/**
public static <T> @NonNull T unwrap(final Optional<T> opt, final @NonNull CommonStmtCtx stmt,
final @NonNull String format, final Object... args) {
throwIf(opt.isEmpty(), stmt, format, args);
- return opt.get();
+ return opt.orElseThrow();
}
private static String createMessage(final @NonNull String message, final @NonNull StatementSourceReference source) {
final YangBinaryOperator operator = parseOperator(expr.getChild(1));
final YangExpr right = parseMultiplicative(getChild(expr, MultiplicativeExprContext.class, 2));
final Optional<YangExpr> simple = simplifyNumbers(operator, left, right);
- return simple.isPresent() ? simple.get() : operator.exprWith(left, right);
+ return simple.isPresent() ? simple.orElseThrow() : operator.exprWith(left, right);
}
private YangExpr parsePathExpr(final PathExprNoRootContext expr) {
final Optional<SourceIdentifier> si = getSourceIdentifier(fileName);
if (si.isPresent()) {
- LOG.trace("Restoring cached file {} as {}", file, si.get());
- cachedSchemas.add(si.get());
+ LOG.trace("Restoring cached file {} as {}", file, si.orElseThrow());
+ cachedSchemas.add(si.orElseThrow());
} else {
LOG.debug("Skipping cached file {}, cannot restore source identifier from filename: {},"
+ " does not match {}", file, fileName, CACHED_FILE_PATTERN);
Code Review / yangtools.git / commitdiff