2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.model.util;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertTrue;
12 import static org.mockito.ArgumentMatchers.any;
13 import static org.mockito.Mockito.doReturn;
14 import static org.mockito.Mockito.mock;
16 import com.google.common.collect.ImmutableSet;
18 import java.util.Arrays;
19 import java.util.Collection;
20 import java.util.Collections;
21 import java.util.HashSet;
22 import java.util.List;
23 import java.util.Optional;
25 import org.junit.Test;
26 import org.opendaylight.yangtools.concepts.SemVer;
27 import org.opendaylight.yangtools.yang.common.QName;
28 import org.opendaylight.yangtools.yang.common.QNameModule;
29 import org.opendaylight.yangtools.yang.common.Revision;
30 import org.opendaylight.yangtools.yang.common.XMLNamespace;
31 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
34 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
35 import org.opendaylight.yangtools.yang.model.api.Module;
36 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
37 import org.opendaylight.yangtools.yang.model.api.ModuleLike;
38 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
39 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
41 import org.opendaylight.yangtools.yang.model.api.Submodule;
42 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
43 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
45 import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId;
47 public class SchemaContextProxyTest {
49 private static final URI NAMESPACE = URI.create("urn:opendaylight:params:xml:ns:yang:controller:config");
50 private static final Revision REVISION = Revision.of("2015-01-01");
51 private static final Revision REVISION2 = Revision.of("2015-01-15");
53 private static final String CONFIG_NAME = "config";
54 private static final String ROOT_NAME = "root";
55 private static final String MODULE2_NAME = "module2";
56 private static final String MODULE3_NAME = "module3";
57 private static final String MODULE4_NAME = "module4";
58 private static final String MODULE41_NAME = "module41";
59 private static final String MODULE5_NAME = "module5";
61 private static SchemaContext mockSchema(final Module... modules) {
62 final List<Module> sortedModules = Arrays.asList(modules);
63 sortedModules.sort(AbstractSchemaContext.NAME_REVISION_COMPARATOR);
64 SchemaContext mock = mock(SchemaContext.class);
65 doReturn(ImmutableSet.copyOf(sortedModules)).when(mock).getModules();
76 public void testBasic() {
77 Module moduleConfig = mockModule(CONFIG_NAME);
78 Module module2 = mockModule(MODULE2_NAME);
79 Module module3 = mockModule(MODULE3_NAME);
81 mockModuleImport(module2, moduleConfig);
82 mockModuleImport(module3, module2, moduleConfig);
84 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
86 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
88 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
92 * No root or additional modules
98 public void testNull() {
99 Module moduleConfig = mockModule(CONFIG_NAME);
100 Module module2 = mockModule(MODULE2_NAME);
101 Module module3 = mockModule(MODULE3_NAME);
103 mockModuleImport(module2, moduleConfig);
104 mockModuleImport(module3, module2, moduleConfig);
106 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
108 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
109 assertProxyContext(filteringSchemaContextProxy, null);
119 public void testConfigDifferentRevisions() {
120 Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
121 Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
122 Module moduleConfig2 = mockModule(CONFIG_NAME, REVISION2);
123 Module module2 = mockModule(MODULE2_NAME);
124 Module module3 = mockModule(MODULE3_NAME);
126 mockModuleImport(module2, moduleConfig);
127 mockModuleImport(module3, module2, moduleConfigNullRevision);
129 SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
131 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
133 assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
143 public void testBasicNullRevision() throws Exception {
144 final Module moduleConfig = mockModule(CONFIG_NAME, Revision.of("2013-04-05"));
145 final Module module2 = mockModule(MODULE2_NAME, Revision.of("2014-06-17"));
146 final Module module20 = mockModule(MODULE2_NAME, null);
147 final Module module3 = mockModule(MODULE3_NAME, Revision.of("2014-06-12"));
148 final Module module30 = mockModule(MODULE3_NAME, null);
150 mockModuleImport(module20, moduleConfig);
151 mockModuleImport(module2, moduleConfig);
152 mockModuleImport(module3, module20, moduleConfig);
153 mockModuleImport(module30, module20, moduleConfig);
155 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
157 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
160 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
170 public void testBasicMoreRootModules() {
171 final Module moduleConfig = mockModule(CONFIG_NAME);
172 final Module moduleRoot = mockModule(ROOT_NAME);
173 final Module module2 = mockModule(MODULE2_NAME);
174 final Module module3 = mockModule(MODULE3_NAME);
176 mockModuleImport(module2, moduleConfig);
177 mockModuleImport(module3, moduleRoot);
179 SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
181 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
183 assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
193 public void testChainNotDepend() {
194 Module moduleConfig = mockModule(CONFIG_NAME);
195 Module module2 = mockModule(MODULE2_NAME);
196 Module module3 = mockModule(MODULE3_NAME);
198 mockModuleImport(module2, moduleConfig);
199 mockModuleImport(module3, module2);
201 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
203 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
205 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
212 * M2 -> M3 -> M4 -> M5
215 public void testChainDependMulti() {
216 Module moduleConfig = mockModule(CONFIG_NAME);
217 Module module2 = mockModule(MODULE2_NAME);
218 Module module3 = mockModule(MODULE3_NAME);
219 Module module4 = mockModule(MODULE4_NAME);
220 Module module5 = mockModule(MODULE5_NAME);
222 mockModuleImport(module2, moduleConfig, module3);
223 mockModuleImport(module3, module4);
224 mockModuleImport(module4, module5);
226 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
228 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
230 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
240 public void testChainNotDependMulti() {
241 Module moduleConfig = mockModule(CONFIG_NAME);
242 Module module2 = mockModule(MODULE2_NAME);
243 Module module3 = mockModule(MODULE3_NAME);
244 Module module4 = mockModule(MODULE4_NAME);
246 mockModuleImport(module2, moduleConfig, module3);
247 mockModuleImport(module4, module3);
249 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
251 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
253 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
263 public void testChainNotMulti() {
264 final Module moduleConfig = mockModule(CONFIG_NAME);
265 final Module module2 = mockModule(MODULE2_NAME);
266 final Module module3 = mockModule(MODULE3_NAME);
267 final Module module4 = mockModule(MODULE4_NAME);
268 final Module module5 = mockModule(MODULE5_NAME);
270 mockModuleImport(module2, moduleConfig);
271 mockModuleImport(module3, moduleConfig);
272 mockModuleImport(module4, moduleConfig);
273 mockModuleImport(module5, moduleConfig);
275 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
277 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
279 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
286 * M2 <- M3 M4=M3(Different revision)
289 public void testBasicRevisionChange() throws Exception {
290 Module moduleConfig = mockModule(CONFIG_NAME);
291 Module module2 = mockModule(MODULE2_NAME);
292 Module module3 = mockModule(MODULE3_NAME);
293 Module module4 = mockModule(MODULE3_NAME, Revision.of("2015-10-10"));
295 mockModuleImport(module2, moduleConfig);
296 mockModuleImport(module3, module2, moduleConfig);
298 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
300 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
302 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
308 * M2 -(no revision)-> M3(R2) ... M3(R1)
311 public void testImportNoRevision() {
312 Module moduleConfig = mockModule(CONFIG_NAME, REVISION);
313 Module module2 = mockModule(MODULE2_NAME, REVISION);
315 Module module3 = mockModule(MODULE3_NAME, null);
316 Module module30 = mockModule(MODULE3_NAME, REVISION);
317 Module module31 = mockModule(MODULE3_NAME, REVISION2);
318 mockModuleImport(module2, moduleConfig, module3);
320 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
322 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
325 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
337 public void testBasicSubmodule() {
338 Module moduleConfig = mockModule(CONFIG_NAME);
339 Module module2 = mockModule(MODULE2_NAME);
340 Module module3 = mockModule(MODULE3_NAME);
341 Module module4 = mockModule(MODULE4_NAME);
342 Submodule module41 = mockSubmodule(MODULE41_NAME);
344 mockSubmodules(module4, module41);
345 mockModuleImport(module2, moduleConfig, module3);
346 mockModuleImport(module41, moduleConfig);
348 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
350 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
352 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
356 * M2 -> M3 -> M4 -> M5
359 public void testChainAdditionalModules() {
360 Module module2 = mockModule(MODULE2_NAME);
361 Module module3 = mockModule(MODULE3_NAME);
362 Module module4 = mockModule(MODULE4_NAME);
363 Module module5 = mockModule(MODULE5_NAME);
365 mockModuleImport(module2, module3);
366 mockModuleImport(module3, module4);
367 mockModuleImport(module4, module5);
369 SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
371 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
372 Collections.singleton(module2), null);
373 assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
386 public void testChainAdditionalModulesConfig() {
387 Module moduleConfig = mockModule(CONFIG_NAME);
388 Module module2 = mockModule(MODULE2_NAME);
390 Module module3 = mockModule(MODULE3_NAME);
391 Module module4 = mockModule(MODULE4_NAME);
392 Module module5 = mockModule(MODULE5_NAME);
394 mockModuleImport(module2, moduleConfig);
395 mockModuleImport(module3, module4);
397 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
399 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
400 Collections.singleton(module3), moduleConfig);
401 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
405 public void testGetDataDefinitions() {
406 final Module moduleConfig = mockModule(CONFIG_NAME);
407 final SchemaContext schemaContext = mockSchema(moduleConfig);
408 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
409 new HashSet<>(), moduleConfig);
411 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
412 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
413 doReturn(childNodes).when(moduleConfig).getChildNodes();
415 final Collection<? extends DataSchemaNode> dataDefinitions =
416 filteringSchemaContextProxy.getDataDefinitions();
417 assertTrue(dataDefinitions.contains(mockedContainer));
421 public void testGetNotifications() {
422 final Module moduleConfig = mockModule(CONFIG_NAME);
423 final SchemaContext schemaContext = mockSchema(moduleConfig);
424 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
425 new HashSet<>(), moduleConfig);
427 final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
428 final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
429 doReturn(notifications).when(moduleConfig).getNotifications();
431 final Collection<? extends NotificationDefinition> schemaContextProxyNotifications =
432 filteringSchemaContextProxy.getNotifications();
433 assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
437 public void testGetOperations() {
438 final Module moduleConfig = mockModule(CONFIG_NAME);
439 final SchemaContext schemaContext = mockSchema(moduleConfig);
440 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
441 new HashSet<>(), moduleConfig);
443 final RpcDefinition mockedRpc = mock(RpcDefinition.class);
444 final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
445 doReturn(rpcs).when(moduleConfig).getRpcs();
447 final Collection<? extends RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
448 assertTrue(operations.contains(mockedRpc));
452 public void testGetExtensions() {
453 final Module moduleConfig = mockModule(CONFIG_NAME);
454 final SchemaContext schemaContext = mockSchema(moduleConfig);
455 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
456 new HashSet<>(), moduleConfig);
458 final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
459 final List<ExtensionDefinition> extensions = Collections.singletonList(mockedExtension);
460 doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
462 final Collection<? extends ExtensionDefinition> schemaContextProxyExtensions =
463 filteringSchemaContextProxy.getExtensions();
464 assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
468 public void testGetUnknownSchemaNodes() {
469 final Module moduleConfig = mockModule(CONFIG_NAME);
470 final SchemaContext schemaContext = mockSchema(moduleConfig);
471 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
472 new HashSet<>(), moduleConfig);
474 final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
475 final List<UnknownSchemaNode> unknownSchemaNodes = Collections.singletonList(mockedUnknownSchemaNode);
476 doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
478 final Collection<? extends UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
479 filteringSchemaContextProxy.getUnknownSchemaNodes();
480 assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
484 public void testGetTypeDefinitions() {
485 final Module moduleConfig = mockModule(CONFIG_NAME);
486 final SchemaContext schemaContext = mockSchema(moduleConfig);
487 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
488 new HashSet<>(), moduleConfig);
490 final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
491 final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
492 doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
494 final Collection<? extends TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
495 .getTypeDefinitions();
496 assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
500 public void testGetChildNodes() {
501 final Module moduleConfig = mockModule(CONFIG_NAME);
502 final SchemaContext schemaContext = mockSchema(moduleConfig);
503 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
504 new HashSet<>(), moduleConfig);
506 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
507 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
508 doReturn(childNodes).when(moduleConfig).getChildNodes();
510 final Collection<? extends DataSchemaNode> schemaContextProxyChildNodes =
511 filteringSchemaContextProxy.getChildNodes();
512 assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
516 public void testGetGroupings() {
517 final Module moduleConfig = mockModule(CONFIG_NAME);
518 final SchemaContext schemaContext = mockSchema(moduleConfig);
519 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
520 new HashSet<>(), moduleConfig);
522 final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
523 final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
524 doReturn(groupings).when(moduleConfig).getGroupings();
526 final Collection<? extends GroupingDefinition> schemaContextProxyGroupings =
527 filteringSchemaContextProxy.getGroupings();
528 assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
532 public void testGetDataChildByName() {
533 final Module moduleConfig = mockModule(CONFIG_NAME);
534 final SchemaContext schemaContext = mockSchema(moduleConfig);
535 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
536 new HashSet<>(), moduleConfig);
538 final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
539 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
540 doReturn(mockedContainer).when(moduleConfig).dataChildByName(any(QName.class));
542 final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
543 assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
546 private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
547 final Module... expected) {
549 final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
550 Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
552 assertEquals(modSet, modSetFiltering);
554 //asserting collections
555 if (expected != null) {
556 for (final Module module : expected) {
557 assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
560 Collection<? extends Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
561 assertTrue(mod.contains(module));
562 assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
563 module.getRevision().orElse(null)).get());
568 private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
569 final Set<Module> additionalModules, final Module... modules) {
570 Set<Module> modulesSet = new HashSet<>();
571 if (modules != null) {
572 modulesSet = ImmutableSet.copyOf(modules);
575 return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
576 createModuleIds(additionalModules));
579 private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
580 Set<ModuleId> moduleIds = new HashSet<>();
581 if (modules != null) {
582 for (Module module : modules) {
583 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
590 private static void mockSubmodules(final Module mainModule, final Submodule... submodules) {
591 Set<Submodule> submodulesSet = new HashSet<>();
592 submodulesSet.addAll(Arrays.asList(submodules));
594 doReturn(submodulesSet).when(mainModule).getSubmodules();
597 private static void mockModuleImport(final ModuleLike importer, final Module... imports) {
598 Set<ModuleImport> mockedImports = new HashSet<>();
599 for (final Module module : imports) {
600 mockedImports.add(new ModuleImport() {
602 public String getModuleName() {
603 return module.getName();
607 public Optional<Revision> getRevision() {
608 return module.getRevision();
612 public String getPrefix() {
613 return module.getName();
617 public Optional<SemVer> getSemanticVersion() {
618 return module.getSemanticVersion();
622 public Optional<String> getDescription() {
623 return module.getDescription();
627 public Optional<String> getReference() {
628 return module.getReference();
632 public String toString() {
633 return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
637 public ImportEffectiveStatement asEffectiveStatement() {
638 throw new UnsupportedOperationException();
642 doReturn(mockedImports).when(importer).getImports();
645 //mock module with revision
646 private static Module mockModule(final String name, final Revision rev) {
648 final Module mod = mockModule(name);
650 doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
651 doReturn(Optional.ofNullable(rev)).when(mod).getRevision();
652 doReturn(mod.getQNameModule().toString()).when(mod).toString();
657 //mock module with default revision
658 private static Module mockModule(final String name) {
659 Module mockedModule = mock(Module.class);
660 mockModuleLike(mockedModule, name);
664 private static Submodule mockSubmodule(final String name) {
665 Submodule mockedModule = mock(Submodule.class);
666 mockModuleLike(mockedModule, name);
670 private static void mockModuleLike(final ModuleLike mockedModule, final String name) {
671 doReturn(name).when(mockedModule).getName();
672 doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
673 final XMLNamespace newNamespace = XMLNamespace.of(NAMESPACE.toString() + ":" + name);
674 doReturn(newNamespace).when(mockedModule).getNamespace();
675 doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
676 doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
677 doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
678 mockModuleImport(mockedModule);