*/
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;
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");
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;
}
* M2 <- M3
*/
@Test
- public void testBasic() {
+ void testBasic() {
Module moduleConfig = mockModule(CONFIG_NAME);
Module module2 = mockModule(MODULE2_NAME);
Module module3 = mockModule(MODULE3_NAME);
* M2 <- M3
*/
@Test
- public void testNull() {
+ void testNull() {
Module moduleConfig = mockModule(CONFIG_NAME);
Module module2 = mockModule(MODULE2_NAME);
Module module3 = mockModule(MODULE3_NAME);
* 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);
* 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);
* 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);
* M2 <- M3
*/
@Test
- public void testChainNotDepend() {
+ void testChainNotDepend() {
Module moduleConfig = mockModule(CONFIG_NAME);
Module module2 = mockModule(MODULE2_NAME);
Module module3 = mockModule(MODULE3_NAME);
* 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);
* M2 -> M3 <- M4
*/
@Test
- public void testChainNotDependMulti() {
+ void testChainNotDependMulti() {
Module moduleConfig = mockModule(CONFIG_NAME);
Module module2 = mockModule(MODULE2_NAME);
Module module3 = mockModule(MODULE3_NAME);
* 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);
* 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);
* 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);
* M41(S) => M4
*/
@Test
- public void testBasicSubmodule() {
+ void testBasicSubmodule() {
Module moduleConfig = mockModule(CONFIG_NAME);
Module module2 = mockModule(MODULE2_NAME);
Module module3 = mockModule(MODULE3_NAME);
* 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);
SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Set.of(module2),
- null);
+ null);
assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
}
* M3 -> M4
*/
@Test
- public void testChainAdditionalModulesConfig() {
+ void testChainAdditionalModulesConfig() {
Module moduleConfig = mockModule(CONFIG_NAME);
Module module2 = mockModule(MODULE2_NAME);
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);
//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()));
}
}
}
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() {
//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();
//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;
}
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();
Code Review / yangtools.git / blobdiff