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.Matchers.any;
13 import static org.mockito.Mockito.doReturn;
14 import static org.mockito.Mockito.mock;
16 import com.google.common.collect.ImmutableSet;
17 import com.google.common.collect.Lists;
19 import java.net.URISyntaxException;
20 import java.text.ParseException;
21 import java.util.Arrays;
22 import java.util.Collections;
23 import java.util.Date;
24 import java.util.HashSet;
25 import java.util.List;
27 import org.junit.BeforeClass;
28 import org.junit.Test;
29 import org.opendaylight.yangtools.concepts.SemVer;
30 import org.opendaylight.yangtools.yang.common.QName;
31 import org.opendaylight.yangtools.yang.common.QNameModule;
32 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
33 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
36 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
37 import org.opendaylight.yangtools.yang.model.api.Module;
38 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
39 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
40 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
41 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.util.FilteringSchemaContextProxy.ModuleId;
46 public class SchemaContextProxyTest {
48 private static URI namespace;
49 private static Date revision;
50 private static Date revision2;
52 private static final String CONFIG_NAME = "config";
53 private static final String ROOT_NAME = "root";
54 private static final String MODULE2_NAME = "module2";
55 private static final String MODULE3_NAME = "module3";
56 private static final String MODULE4_NAME = "module4";
57 private static final String MODULE41_NAME = "module41";
58 private static final String MODULE5_NAME = "module5";
59 private static final String TEST_SOURCE = "test source";
62 public static void setUp() throws ParseException, URISyntaxException {
64 namespace = new URI("urn:opendaylight:params:xml:ns:yang:controller:config");
66 revision = SimpleDateFormatUtil.getRevisionFormat().parse("2015-01-01");
67 revision2 = SimpleDateFormatUtil.getRevisionFormat().parse("2015-01-15");
70 private static SchemaContext mockSchema(final Module... module) {
71 SchemaContext mock = mock(SchemaContext.class);
72 doReturn(ImmutableSet.copyOf(module)).when(mock).getModules();
83 public void testBasic() {
84 Module moduleConfig = mockModule(CONFIG_NAME);
85 Module module2 = mockModule(MODULE2_NAME);
86 Module module3 = mockModule(MODULE3_NAME);
88 mockModuleImport(module2, moduleConfig);
89 mockModuleImport(module3, module2, moduleConfig);
91 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
93 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
95 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
99 * No root or additional modules
105 public void testNull() {
106 Module moduleConfig = mockModule(CONFIG_NAME);
107 Module module2 = mockModule(MODULE2_NAME);
108 Module module3 = mockModule(MODULE3_NAME);
110 mockModuleImport(module2, moduleConfig);
111 mockModuleImport(module3, module2, moduleConfig);
113 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
115 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
116 assertProxyContext(filteringSchemaContextProxy, null);
126 public void testConfigDifferentRevisions() {
127 Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
128 Module moduleConfig = mockModule(CONFIG_NAME, revision);
129 Module moduleConfig2 = mockModule(CONFIG_NAME, revision2);
130 Module module2 = mockModule(MODULE2_NAME);
131 Module module3 = mockModule(MODULE3_NAME);
133 mockModuleImport(module2, moduleConfig);
134 mockModuleImport(module3, module2, moduleConfigNullRevision);
136 SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
138 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
140 assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
150 public void testBasicNullRevision() throws Exception {
151 final Module moduleConfig = mockModule(CONFIG_NAME,SimpleDateFormatUtil.getRevisionFormat()
152 .parse("2013-04-05"));
153 final Module module2 = mockModule(MODULE2_NAME, SimpleDateFormatUtil.getRevisionFormat().parse("2014-06-17"));
154 final Module module20 = mockModule(MODULE2_NAME, null);
155 final Module module3 = mockModule(MODULE3_NAME, SimpleDateFormatUtil.getRevisionFormat().parse("2014-06-12"));
156 final Module module30 = mockModule(MODULE3_NAME, null);
158 mockModuleImport(module20, moduleConfig);
159 mockModuleImport(module2, moduleConfig);
160 mockModuleImport(module3, module20, moduleConfig);
161 mockModuleImport(module30, module20, moduleConfig);
163 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
165 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
168 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
178 public void testBasicMoreRootModules() {
179 final Module moduleConfig = mockModule(CONFIG_NAME);
180 final Module moduleRoot = mockModule(ROOT_NAME);
181 final Module module2 = mockModule(MODULE2_NAME);
182 final Module module3 = mockModule(MODULE3_NAME);
184 mockModuleImport(module2, moduleConfig);
185 mockModuleImport(module3, moduleRoot);
187 SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
189 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot,
191 assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
201 public void testChainNotDepend() {
202 Module moduleConfig = mockModule(CONFIG_NAME);
203 Module module2 = mockModule(MODULE2_NAME);
204 Module module3 = mockModule(MODULE3_NAME);
206 mockModuleImport(module2, moduleConfig);
207 mockModuleImport(module3, module2);
209 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
211 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
213 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
220 * M2 -> M3 -> M4 -> M5
223 public void testChainDependMulti() {
224 Module moduleConfig = mockModule(CONFIG_NAME);
225 Module module2 = mockModule(MODULE2_NAME);
226 Module module3 = mockModule(MODULE3_NAME);
227 Module module4 = mockModule(MODULE4_NAME);
228 Module module5 = mockModule(MODULE5_NAME);
230 mockModuleImport(module2, moduleConfig, module3);
231 mockModuleImport(module3, module4);
232 mockModuleImport(module4, module5);
234 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
236 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
238 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
248 public void testChainNotDependMulti() {
249 Module moduleConfig = mockModule(CONFIG_NAME);
250 Module module2 = mockModule(MODULE2_NAME);
251 Module module3 = mockModule(MODULE3_NAME);
252 Module module4 = mockModule(MODULE4_NAME);
254 mockModuleImport(module2, moduleConfig, module3);
255 mockModuleImport(module4, module3);
257 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
259 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
261 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
271 public void testChainNotMulti() {
272 final Module moduleConfig = mockModule(CONFIG_NAME);
273 final Module module2 = mockModule(MODULE2_NAME);
274 final Module module3 = mockModule(MODULE3_NAME);
275 final Module module4 = mockModule(MODULE4_NAME);
276 final Module module5 = mockModule(MODULE5_NAME);
278 mockModuleImport(module2, moduleConfig);
279 mockModuleImport(module3, moduleConfig);
280 mockModuleImport(module4, moduleConfig);
281 mockModuleImport(module5, moduleConfig);
283 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
285 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
287 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
294 * M2 <- M3 M4=M3(Different revision)
297 public void testBasicRevisionChange() throws Exception {
298 Module moduleConfig = mockModule(CONFIG_NAME);
299 Module module2 = mockModule(MODULE2_NAME);
300 Module module3 = mockModule(MODULE3_NAME);
302 Date dat = SimpleDateFormatUtil.getRevisionFormat().parse("2015-10-10");
303 Module module4 = mockModule(MODULE3_NAME, dat);
305 mockModuleImport(module2, moduleConfig);
306 mockModuleImport(module3, module2, moduleConfig);
308 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
310 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
312 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
318 * M2 -(no revision)-> M3(R2) ... M3(R1)
321 public void testImportNoRevision() {
322 Module moduleConfig = mockModule(CONFIG_NAME, revision);
323 Module module2 = mockModule(MODULE2_NAME, revision);
325 Module module3 = mockModule(MODULE3_NAME, null);
326 Module module30 = mockModule(MODULE3_NAME, revision);
327 Module module31 = mockModule(MODULE3_NAME, revision2);
328 mockModuleImport(module2, moduleConfig, module3);
330 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
332 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
335 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
347 public void testBasicSubmodule() {
348 Module moduleConfig = mockModule(CONFIG_NAME);
349 Module module2 = mockModule(MODULE2_NAME);
350 Module module3 = mockModule(MODULE3_NAME);
351 Module module4 = mockModule(MODULE4_NAME);
352 Module module41 = mockModule(MODULE41_NAME);
354 mockSubmodules(module4, module41);
355 mockModuleImport(module2, moduleConfig, module3);
356 mockModuleImport(module41, moduleConfig);
358 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
360 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null,
362 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
366 * M2 -> M3 -> M4 -> M5
369 public void testChainAdditionalModules() {
370 Module module2 = mockModule(MODULE2_NAME);
371 Module module3 = mockModule(MODULE3_NAME);
372 Module module4 = mockModule(MODULE4_NAME);
373 Module module5 = mockModule(MODULE5_NAME);
375 mockModuleImport(module2, module3);
376 mockModuleImport(module3, module4);
377 mockModuleImport(module4, module5);
379 SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
381 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
382 Collections.singleton(module2), null);
383 assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
396 public void testChainAdditionalModulesConfig() {
397 Module moduleConfig = mockModule(CONFIG_NAME);
398 Module module2 = mockModule(MODULE2_NAME);
400 Module module3 = mockModule(MODULE3_NAME);
401 Module module4 = mockModule(MODULE4_NAME);
402 Module module5 = mockModule(MODULE5_NAME);
404 mockModuleImport(module2, moduleConfig);
405 mockModuleImport(module3, module4);
407 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
409 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
410 Collections.singleton(module3), moduleConfig);
411 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
415 public void testGetDataDefinitions() {
416 final Module moduleConfig = mockModule(CONFIG_NAME);
417 final SchemaContext schemaContext = mockSchema(moduleConfig);
418 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
419 new HashSet<>(), moduleConfig);
421 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
422 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
423 doReturn(childNodes).when(moduleConfig).getChildNodes();
425 final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
426 assertTrue(dataDefinitions.contains(mockedContainer));
430 public void testGetNotifications() {
431 final Module moduleConfig = mockModule(CONFIG_NAME);
432 final SchemaContext schemaContext = mockSchema(moduleConfig);
433 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
434 new HashSet<>(), moduleConfig);
436 final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
437 final Set<NotificationDefinition> notifications = Collections.singleton(mockedNotification);
438 doReturn(notifications).when(moduleConfig).getNotifications();
440 final Set<NotificationDefinition> schemaContextProxyNotifications =
441 filteringSchemaContextProxy.getNotifications();
442 assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
446 public void testGetOperations() {
447 final Module moduleConfig = mockModule(CONFIG_NAME);
448 final SchemaContext schemaContext = mockSchema(moduleConfig);
449 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
450 new HashSet<>(), moduleConfig);
452 final RpcDefinition mockedRpc = mock(RpcDefinition.class);
453 final Set<RpcDefinition> rpcs = Collections.singleton(mockedRpc);
454 doReturn(rpcs).when(moduleConfig).getRpcs();
456 final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
457 assertTrue(operations.contains(mockedRpc));
461 public void testGetExtensions() {
462 final Module moduleConfig = mockModule(CONFIG_NAME);
463 final SchemaContext schemaContext = mockSchema(moduleConfig);
464 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
465 new HashSet<>(), moduleConfig);
467 final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
468 final List<ExtensionDefinition> extensions = Lists.newArrayList(mockedExtension);
469 doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
471 final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
472 assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
476 public void testGetUnknownSchemaNodes() {
477 final Module moduleConfig = mockModule(CONFIG_NAME);
478 final SchemaContext schemaContext = mockSchema(moduleConfig);
479 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
480 new HashSet<>(), moduleConfig);
482 final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
483 final List<UnknownSchemaNode> unknownSchemaNodes = Lists.newArrayList(mockedUnknownSchemaNode);
484 doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
486 final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
487 filteringSchemaContextProxy.getUnknownSchemaNodes();
488 assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
492 public void testGetTypeDefinitions() {
493 final Module moduleConfig = mockModule(CONFIG_NAME);
494 final SchemaContext schemaContext = mockSchema(moduleConfig);
495 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
496 new HashSet<>(), moduleConfig);
498 final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
499 final Set<TypeDefinition<?>> typeDefinitions = Collections.singleton(mockedTypeDefinition);
500 doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
502 final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy
503 .getTypeDefinitions();
504 assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
508 public void testGetChildNodes() {
509 final Module moduleConfig = mockModule(CONFIG_NAME);
510 final SchemaContext schemaContext = mockSchema(moduleConfig);
511 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
512 new HashSet<>(), moduleConfig);
514 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
515 final Set<DataSchemaNode> childNodes = Collections.singleton(mockedContainer);
516 doReturn(childNodes).when(moduleConfig).getChildNodes();
518 final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
519 assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
523 public void testGetGroupings() {
524 final Module moduleConfig = mockModule(CONFIG_NAME);
525 final SchemaContext schemaContext = mockSchema(moduleConfig);
526 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
527 new HashSet<>(), moduleConfig);
529 final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
530 final Set<GroupingDefinition> groupings = Collections.singleton(mockedGrouping);
531 doReturn(groupings).when(moduleConfig).getGroupings();
533 final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
534 assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
538 public void testGetDataChildByName() {
539 final Module moduleConfig = mockModule(CONFIG_NAME);
540 final SchemaContext schemaContext = mockSchema(moduleConfig);
541 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
542 new HashSet<>(), moduleConfig);
544 final QName qname = QName.create("config-namespace", "2016-08-11", "cont");
545 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
546 doReturn(mockedContainer).when(moduleConfig).getDataChildByName(any(QName.class));
548 final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qname);
549 assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
552 private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy,
553 final Module... expected) {
555 final Set<Module> modSet = expected != null ? ImmutableSet.copyOf(expected) : new HashSet<>();
556 Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
558 assertEquals(modSet, modSetFiltering);
560 //asserting collections
561 if (expected != null) {
562 for (final Module module : expected) {
563 assertEquals(module, filteringSchemaContextProxy.findModuleByName(module.getName(),
564 module.getRevision()));
566 Set<Module> mod = filteringSchemaContextProxy.findModuleByNamespace(module.getNamespace());
567 assertTrue(mod.contains(module));
569 assertEquals(module, filteringSchemaContextProxy.findModuleByNamespaceAndRevision(module.getNamespace(),
570 module.getRevision()));
572 assertEquals(module.getSource(), filteringSchemaContextProxy.getModuleSource(module).get());
577 private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
578 final Set<Module> additionalModules, final Module... modules) {
579 Set<Module> modulesSet = new HashSet<>();
580 if (modules != null) {
581 modulesSet = ImmutableSet.copyOf(modules);
584 return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet),
585 createModuleIds(additionalModules));
588 private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
589 Set<ModuleId> moduleIds = new HashSet<>();
590 if (modules != null) {
591 for (Module module : modules) {
592 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
599 private static void mockSubmodules(final Module mainModule, final Module... submodules) {
600 Set<Module> submodulesSet = new HashSet<>();
601 submodulesSet.addAll(Arrays.asList(submodules));
603 doReturn(submodulesSet).when(mainModule).getSubmodules();
606 private static void mockModuleImport(final Module importer, final Module... imports) {
607 Set<ModuleImport> mockedImports = new HashSet<>();
608 for (final Module module : imports) {
609 mockedImports.add(new ModuleImport() {
611 public String getModuleName() {
612 return module.getName();
616 public Date getRevision() {
617 return module.getRevision();
621 public String getPrefix() {
622 return module.getName();
626 public SemVer getSemanticVersion() {
627 return module.getSemanticVersion();
631 public String toString() {
632 return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
636 doReturn(mockedImports).when(importer).getImports();
639 //mock module with revision
640 private static Module mockModule(final String name, final Date rev) {
642 final Module mod = mockModule(name);
644 doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
645 doReturn(rev).when(mod).getRevision();
646 doReturn(mod.getQNameModule().toString()).when(mod).toString();
651 //mock module with default revision
652 private static Module mockModule(final String name) {
654 Module mockedModule = mock(Module.class);
655 doReturn(name).when(mockedModule).getName();
656 doReturn(revision).when(mockedModule).getRevision();
657 final URI newNamespace = URI.create(namespace.toString() + ":" + name);
658 doReturn(newNamespace).when(mockedModule).getNamespace();
659 doReturn(QNameModule.create(newNamespace, revision)).when(mockedModule).getQNameModule();
660 doReturn(TEST_SOURCE).when(mockedModule).getSource();
661 doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
662 doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
663 mockModuleImport(mockedModule);