X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=model%2Fyang-model-util%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Futil%2FSchemaContextProxyTest.java;fp=model%2Fyang-model-util%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Futil%2FSchemaContextProxyTest.java;h=757968f13301a72eeb7df2e7f678cfa6449942cc;hb=5fc55b1efda449b013489039fbf0997de5d76b84;hp=839ea2cb3888c287d5980dd9e72d3c9e28527385;hpb=38d6983faa6925abb7ebfbafde6528a35403b0d1;p=yangtools.git

diff --git a/model/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java b/model/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java
index 839ea2cb38..757968f133 100644
--- a/model/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java
+++ b/model/yang-model-util/src/test/java/org/opendaylight/yangtools/yang/model/util/SchemaContextProxyTest.java
@@ -7,21 +7,19 @@
  */
 package org.opendaylight.yangtools.yang.model.util;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 
 import com.google.common.collect.ImmutableSet;
-import java.net.URI;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.common.Revision;
@@ -44,9 +42,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.spi.AbstractSchemaContext;
 import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId;
 
-public class SchemaContextProxyTest {
+class SchemaContextProxyTest {
 
-    private static final URI NAMESPACE = URI.create("urn:opendaylight:params:xml:ns:yang:controller:config");
+    private static final String NAMESPACE = "urn:opendaylight:params:xml:ns:yang:controller:config";
     private static final Revision REVISION = Revision.of("2015-01-01");
     private static final Revision REVISION2 = Revision.of("2015-01-15");
 
@@ -59,10 +57,9 @@ public class SchemaContextProxyTest {
     private static final String MODULE5_NAME = "module5";
 
     private static SchemaContext mockSchema(final Module... modules) {
-        final List<Module> sortedModules = Arrays.asList(modules);
-        sortedModules.sort(AbstractSchemaContext.NAME_REVISION_COMPARATOR);
+        Arrays.sort(modules, AbstractSchemaContext.NAME_REVISION_COMPARATOR);
         SchemaContext mock = mock(SchemaContext.class);
-        doReturn(ImmutableSet.copyOf(sortedModules)).when(mock).getModules();
+        doReturn(ImmutableSet.copyOf(modules)).when(mock).getModules();
         return mock;
     }
 
@@ -73,7 +70,7 @@ public class SchemaContextProxyTest {
      * M2 <- M3
      */
     @Test
-    public void testBasic() {
+    void testBasic() {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
@@ -95,7 +92,7 @@ public class SchemaContextProxyTest {
      * M2 <- M3
      */
     @Test
-    public void testNull() {
+    void testNull() {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
@@ -116,7 +113,7 @@ public class SchemaContextProxyTest {
      * M2 <- M3
      */
     @Test
-    public void testConfigDifferentRevisions() {
+    void testConfigDifferentRevisions() {
         Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
         Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
         Module moduleConfig2 = mockModule(CONFIG_NAME, REVISION2);
@@ -140,7 +137,7 @@ public class SchemaContextProxyTest {
      * M2<-(NullRev)M3
      */
     @Test
-    public void testBasicNullRevision() throws Exception {
+    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);
@@ -167,7 +164,7 @@ public class SchemaContextProxyTest {
      * M2          M3
      */
     @Test
-    public void testBasicMoreRootModules() {
+    void testBasicMoreRootModules() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final Module moduleRoot = mockModule(ROOT_NAME);
         final Module module2 = mockModule(MODULE2_NAME);
@@ -190,7 +187,7 @@ public class SchemaContextProxyTest {
      * M2 <- M3
      */
     @Test
-    public void testChainNotDepend() {
+    void testChainNotDepend() {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
@@ -212,7 +209,7 @@ public class SchemaContextProxyTest {
      * M2 -> M3 -> M4 -> M5
      */
     @Test
-    public void testChainDependMulti() {
+    void testChainDependMulti() {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
@@ -237,7 +234,7 @@ public class SchemaContextProxyTest {
      * M2 -> M3 <- M4
      */
     @Test
-    public void testChainNotDependMulti() {
+    void testChainNotDependMulti() {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
@@ -260,7 +257,7 @@ public class SchemaContextProxyTest {
      * M2 M3 M4 M5
      */
     @Test
-    public void testChainNotMulti() {
+    void testChainNotMulti() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final Module module2 = mockModule(MODULE2_NAME);
         final Module module3 = mockModule(MODULE3_NAME);
@@ -286,7 +283,7 @@ public class SchemaContextProxyTest {
      * M2 <- M3 M4=M3(Different revision)
      */
     @Test
-    public void testBasicRevisionChange() throws Exception {
+    void testBasicRevisionChange() throws Exception {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
@@ -308,11 +305,11 @@ public class SchemaContextProxyTest {
      * M2 -(no revision)-> M3(R2) ... M3(R1)
      */
     @Test
-    public void testImportNoRevision() {
+    void testImportNoRevision() {
         Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
         Module module2 = mockModule(MODULE2_NAME, REVISION);
 
-        Module module3  = mockModule(MODULE3_NAME, null);
+        Module module3 = mockModule(MODULE3_NAME, null);
         Module module30 = mockModule(MODULE3_NAME, REVISION);
         Module module31 = mockModule(MODULE3_NAME, REVISION2);
         mockModuleImport(module2, moduleConfig, module3);
@@ -334,7 +331,7 @@ public class SchemaContextProxyTest {
      * M41(S) => M4
      */
     @Test
-    public void testBasicSubmodule() {
+    void testBasicSubmodule() {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
@@ -356,7 +353,7 @@ public class SchemaContextProxyTest {
      * M2 -> M3 -> M4 -> M5
      */
     @Test
-    public void testChainAdditionalModules() {
+    void testChainAdditionalModules() {
         Module module2 = mockModule(MODULE2_NAME);
         Module module3 = mockModule(MODULE3_NAME);
         Module module4 = mockModule(MODULE4_NAME);
@@ -369,7 +366,7 @@ public class SchemaContextProxyTest {
         SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
 
         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(module2),
-            null);
+                null);
         assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
     }
 
@@ -383,7 +380,7 @@ public class SchemaContextProxyTest {
      * M3 -> M4
      */
     @Test
-    public void testChainAdditionalModulesConfig() {
+    void testChainAdditionalModulesConfig() {
         Module moduleConfig = mockModule(CONFIG_NAME);
         Module module2 = mockModule(MODULE2_NAME);
 
@@ -397,134 +394,128 @@ public class SchemaContextProxyTest {
         SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
 
         FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(module3),
-            moduleConfig);
+                moduleConfig);
         assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
     }
 
     @Test
-    public void testGetDataDefinitions() {
+    void testGetDataDefinitions() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
         doReturn(Set.of(mockedContainer)).when(moduleConfig).getChildNodes();
 
-        final Collection<? extends DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
+        final var dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
         assertTrue(dataDefinitions.contains(mockedContainer));
     }
 
     @Test
-    public void testGetNotifications() {
+    void testGetNotifications() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
         doReturn(Set.of(mockedNotification)).when(moduleConfig).getNotifications();
 
-        final Collection<? extends NotificationDefinition> schemaContextProxyNotifications =
-            filteringSchemaContextProxy.getNotifications();
+        final var schemaContextProxyNotifications = filteringSchemaContextProxy.getNotifications();
         assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
     }
 
     @Test
-    public void testGetOperations() {
+    void testGetOperations() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final RpcDefinition mockedRpc = mock(RpcDefinition.class);
         doReturn(Set.of(mockedRpc)).when(moduleConfig).getRpcs();
 
-        final Collection<? extends RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
+        final var operations = filteringSchemaContextProxy.getOperations();
         assertTrue(operations.contains(mockedRpc));
     }
 
     @Test
-    public void testGetExtensions() {
+    void testGetExtensions() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
         doReturn(List.of(mockedExtension)).when(moduleConfig).getExtensionSchemaNodes();
 
-        final Collection<? extends ExtensionDefinition> schemaContextProxyExtensions =
-                filteringSchemaContextProxy.getExtensions();
+        final var schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
         assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
     }
 
     @Test
-    public void testGetUnknownSchemaNodes() {
+    void testGetUnknownSchemaNodes() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
         doReturn(List.of(mockedUnknownSchemaNode)).when(moduleConfig).getUnknownSchemaNodes();
 
-        final Collection<? extends UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
-                filteringSchemaContextProxy.getUnknownSchemaNodes();
+        final var schemaContextProxyUnknownSchemaNodes = filteringSchemaContextProxy.getUnknownSchemaNodes();
         assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
     }
 
     @Test
-    public void testGetTypeDefinitions() {
+    void testGetTypeDefinitions() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
         doReturn(Set.of(mockedTypeDefinition)).when(moduleConfig).getTypeDefinitions();
 
-        final Collection<? extends TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
-            .getTypeDefinitions();
+        final var schemaContextProxyTypeDefinitions = filteringSchemaContextProxy.getTypeDefinitions();
         assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
     }
 
     @Test
-    public void testGetChildNodes() {
+    void testGetChildNodes() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
         doReturn(Set.of(mockedContainer)).when(moduleConfig).getChildNodes();
 
-        final Collection<? extends DataSchemaNode> schemaContextProxyChildNodes =
-                filteringSchemaContextProxy.getChildNodes();
+        final var schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
         assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
     }
 
     @Test
-    public void testGetGroupings() {
+    void testGetGroupings() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
         doReturn(Set.of(mockedGrouping)).when(moduleConfig).getGroupings();
 
-        final Collection<? extends GroupingDefinition> schemaContextProxyGroupings =
-                filteringSchemaContextProxy.getGroupings();
+        final var schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
         assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
     }
 
     @Test
-    public void testGetDataChildByName() {
+    void testGetDataChildByName() {
         final Module moduleConfig = mockModule(CONFIG_NAME);
         final SchemaContext schemaContext = mockSchema(moduleConfig);
         final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(),
-            moduleConfig);
+                moduleConfig);
 
         final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
         final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
@@ -545,28 +536,28 @@ public class SchemaContextProxyTest {
         //asserting collections
         if (expected != null) {
             for (final Module module : expected) {
-                assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
-                    .get());
+                assertEquals(Optional.of(module),
+                    filteringSchemaContextProxy.findModule(module.getName(), module.getRevision()));
 
-                Collection<? extends Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
+                final var mod = filteringSchemaContextProxy.findModules(module.getNamespace());
                 assertTrue(mod.contains(module));
-                assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
-                    module.getRevision().orElse(null)).get());
+                assertEquals(Optional.of(module),
+                    filteringSchemaContextProxy.findModule(module.getNamespace(), module.getRevision().orElse(null)));
             }
         }
     }
 
     private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
             final Set<Module> additionalModules, final Module... modules) {
-        Set<Module> modulesSet = modules != null ? ImmutableSet.copyOf(modules) : Set.of();
+        final var modulesSet = modules != null ? ImmutableSet.copyOf(modules) : Set.<Module>of();
         return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
                 createModuleIds(additionalModules));
     }
 
     private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
-        Set<ModuleId> moduleIds = new HashSet<>();
+        final var moduleIds = new HashSet<ModuleId>();
         if (modules != null) {
-            for (Module module : modules) {
+            for (var module : modules) {
                 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
             }
         }
@@ -579,8 +570,8 @@ public class SchemaContextProxyTest {
     }
 
     private static void mockModuleImport(final ModuleLike importer, final Module... imports) {
-        Set<ModuleImport> mockedImports = new HashSet<>();
-        for (final Module module : imports) {
+        final var mockedImports = new HashSet<ModuleImport>();
+        for (final var module : imports) {
             mockedImports.add(new ModuleImport() {
                 @Override
                 public Unqualified getModuleName() {
@@ -623,8 +614,7 @@ public class SchemaContextProxyTest {
 
     //mock module with revision
     private static Module mockModule(final String name, final Revision rev) {
-
-        final Module mod = mockModule(name);
+        final var mod = mockModule(name);
 
         doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
         doReturn(Optional.ofNullable(rev)).when(mod).getRevision();
@@ -635,13 +625,13 @@ public class SchemaContextProxyTest {
 
     //mock module with default revision
     private static Module mockModule(final String name) {
-        Module mockedModule = mock(Module.class);
+        final var mockedModule = mock(Module.class);
         mockModuleLike(mockedModule, name);
         return mockedModule;
     }
 
     private static Submodule mockSubmodule(final String name) {
-        Submodule mockedModule = mock(Submodule.class);
+        final var mockedModule = mock(Submodule.class);
         mockModuleLike(mockedModule, name);
         return mockedModule;
     }
@@ -649,7 +639,7 @@ public class SchemaContextProxyTest {
     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.toString() + ":" + name);
+        final XMLNamespace newNamespace = XMLNamespace.of(NAMESPACE + ":" + name);
         doReturn(newNamespace).when(mockedModule).getNamespace();
         doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
         doReturn(Set.of()).when(mockedModule).getSubmodules();