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.Lists;
17 import com.google.common.collect.Sets;
19 import java.net.URISyntaxException;
20 import java.text.ParseException;
21 import java.util.Arrays;
22 import java.util.Date;
23 import java.util.HashSet;
24 import java.util.List;
26 import org.junit.BeforeClass;
27 import org.junit.Test;
28 import org.opendaylight.yangtools.concepts.SemVer;
29 import org.opendaylight.yangtools.yang.common.QName;
30 import org.opendaylight.yangtools.yang.common.QNameModule;
31 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
32 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
35 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
36 import org.opendaylight.yangtools.yang.model.api.Module;
37 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
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.TypeDefinition;
42 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
43 import org.opendaylight.yangtools.yang.model.util.FilteringSchemaContextProxy.ModuleId;
45 public class SchemaContextProxyTest {
47 private static URI namespace;
48 private static Date revision;
49 private static Date revision2;
51 private static final String CONFIG_NAME = "config";
52 private static final String ROOT_NAME = "root";
53 private static final String MODULE2_NAME = "module2";
54 private static final String MODULE3_NAME = "module3";
55 private static final String MODULE4_NAME = "module4";
56 private static final String MODULE41_NAME = "module41";
57 private static final String MODULE5_NAME = "module5";
58 private static final String TEST_SOURCE = "test source";
61 public static void setUp() throws ParseException, URISyntaxException {
63 namespace = new URI("urn:opendaylight:params:xml:ns:yang:controller:config");
65 revision = SimpleDateFormatUtil.getRevisionFormat().parse("2015-01-01");
66 revision2 = SimpleDateFormatUtil.getRevisionFormat().parse("2015-01-15");
69 private static SchemaContext mockSchema(final Module... module) {
70 SchemaContext mock = mock(SchemaContext.class);
71 doReturn(Sets.newHashSet(module)).when(mock).getModules();
84 public void testBasic() {
85 Module moduleConfig = mockModule(CONFIG_NAME);
86 Module module2 = mockModule(MODULE2_NAME);
87 Module module3 = mockModule(MODULE3_NAME);
89 mockModuleImport(module2, moduleConfig);
90 mockModuleImport(module3, module2, moduleConfig);
92 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
94 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
95 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
100 * No root or additional modules
107 public void testNull() {
108 Module moduleConfig = mockModule(CONFIG_NAME);
109 Module module2 = mockModule(MODULE2_NAME);
110 Module module3 = mockModule(MODULE3_NAME);
112 mockModuleImport(module2, moduleConfig);
113 mockModuleImport(module3, module2, moduleConfig);
115 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
117 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, null);
118 assertProxyContext(filteringSchemaContextProxy, null);
130 public void testConfigDifferentRevisions() {
131 Module moduleConfigNullRevision = mockModule(CONFIG_NAME, null);
132 Module moduleConfig = mockModule(CONFIG_NAME, revision);
133 Module moduleConfig2 = mockModule(CONFIG_NAME, revision2);
134 Module module2 = mockModule(MODULE2_NAME);
135 Module module3 = mockModule(MODULE3_NAME);
137 mockModuleImport(module2, moduleConfig);
138 mockModuleImport(module3, module2, moduleConfigNullRevision);
140 SchemaContext schemaContext = mockSchema(moduleConfig, moduleConfig2, module2, module3);
142 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
143 assertProxyContext(filteringSchemaContextProxy, moduleConfig, moduleConfig2, module2, module3);
155 public void testBasicNullRevision() throws Exception {
156 Module moduleConfig = mockModule(CONFIG_NAME,SimpleDateFormatUtil.getRevisionFormat().parse("2013-04-05"));
157 Module module2 = mockModule(MODULE2_NAME, SimpleDateFormatUtil.getRevisionFormat().parse("2014-06-17"));
158 Module module20 = mockModule(MODULE2_NAME, null);
159 Module module3 = mockModule(MODULE3_NAME, SimpleDateFormatUtil.getRevisionFormat().parse("2014-06-12"));
160 Module module30 = mockModule(MODULE3_NAME, null);
162 mockModuleImport(module20, moduleConfig);
163 mockModuleImport(module2, moduleConfig);
164 mockModuleImport(module3, module20, moduleConfig);
165 mockModuleImport(module30, module20, moduleConfig);
167 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
169 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
171 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
183 public void testBasicMoreRootModules() {
184 Module moduleConfig = mockModule(CONFIG_NAME);
185 Module moduleRoot = mockModule(ROOT_NAME);
186 Module module2 = mockModule(MODULE2_NAME);
187 Module module3 = mockModule(MODULE3_NAME);
189 mockModuleImport(module2, moduleConfig);
190 mockModuleImport(module3, moduleRoot);
192 SchemaContext schemaContext = mockSchema(moduleConfig, moduleRoot, module2, module3);
194 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleRoot, moduleConfig);
195 assertProxyContext(filteringSchemaContextProxy, moduleRoot, module3, moduleConfig, module2);
207 public void testChainNotDepend() {
208 Module moduleConfig = mockModule(CONFIG_NAME);
209 Module module2 = mockModule(MODULE2_NAME);
210 Module module3 = mockModule(MODULE3_NAME);
212 mockModuleImport(module2, moduleConfig);
213 mockModuleImport(module3, module2);
215 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3);
217 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
218 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2);
226 * M2 -> M3 -> M4 -> M5
230 public void testChainDependMulti() {
231 Module moduleConfig = mockModule(CONFIG_NAME);
232 Module module2 = mockModule(MODULE2_NAME);
233 Module module3 = mockModule(MODULE3_NAME);
234 Module module4 = mockModule(MODULE4_NAME);
235 Module module5 = mockModule(MODULE5_NAME);
237 mockModuleImport(module2, moduleConfig, module3);
238 mockModuleImport(module3, module4);
239 mockModuleImport(module4, module5);
241 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
243 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
244 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
252 * M2 -> M3 <- M4
256 public void testChainNotDependMulti() {
257 Module moduleConfig = mockModule(CONFIG_NAME);
258 Module module2 = mockModule(MODULE2_NAME);
259 Module module3 = mockModule(MODULE3_NAME);
260 Module module4 = mockModule(MODULE4_NAME);
262 mockModuleImport(module2, moduleConfig, module3);
263 mockModuleImport(module4, module3);
265 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
267 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
268 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
280 public void testChainNotMulti() {
281 Module moduleConfig = mockModule(CONFIG_NAME);
282 Module module2 = mockModule(MODULE2_NAME);
283 Module module3 = mockModule(MODULE3_NAME);
284 Module module4 = mockModule(MODULE4_NAME);
285 Module module5 = mockModule(MODULE5_NAME);
287 mockModuleImport(module2, moduleConfig);
288 mockModuleImport(module3, moduleConfig);
289 mockModuleImport(module4, moduleConfig);
290 mockModuleImport(module5, moduleConfig);
292 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
294 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
295 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4, module5);
303 * M2 <- M3 M4=M3(Different revision)
307 public void testBasicRevisionChange() throws Exception {
308 Module moduleConfig = mockModule(CONFIG_NAME);
309 Module module2 = mockModule(MODULE2_NAME);
310 Module module3 = mockModule(MODULE3_NAME);
312 Date dat = SimpleDateFormatUtil.getRevisionFormat().parse("2015-10-10");
313 Module module4 = mockModule(MODULE3_NAME, dat);
315 mockModuleImport(module2, moduleConfig);
316 mockModuleImport(module3, module2, moduleConfig);
318 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
320 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
321 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3);
328 * M2 -(no revision)-> M3(R2) ... M3(R1)
332 public void testImportNoRevision() {
333 Module moduleConfig = mockModule(CONFIG_NAME, revision);
334 Module module2 = mockModule(MODULE2_NAME, revision);
336 Module module3 = mockModule(MODULE3_NAME, null);
337 Module module30 = mockModule(MODULE3_NAME, revision);
338 Module module31 = mockModule(MODULE3_NAME, revision2);
339 mockModuleImport(module2, moduleConfig, module3);
341 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module30, module31);
343 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
345 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module31);
359 public void testBasicSubmodule() {
360 Module moduleConfig = mockModule(CONFIG_NAME);
361 Module module2 = mockModule(MODULE2_NAME);
362 Module module3 = mockModule(MODULE3_NAME);
363 Module module4 = mockModule(MODULE4_NAME);
364 Module module41 = mockModule(MODULE41_NAME);
366 mockSubmodules(module4, module41);
367 mockModuleImport(module2, moduleConfig, module3);
368 mockModuleImport(module41, moduleConfig);
370 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4);
372 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, null, moduleConfig);
373 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
379 * M2 -> M3 -> M4 -> M5
384 public void testChainAdditionalModules() {
385 Module module2 = mockModule(MODULE2_NAME);
386 Module module3 = mockModule(MODULE3_NAME);
387 Module module4 = mockModule(MODULE4_NAME);
388 Module module5 = mockModule(MODULE5_NAME);
390 mockModuleImport(module2, module3);
391 mockModuleImport(module3, module4);
392 mockModuleImport(module4, module5);
394 SchemaContext schemaContext = mockSchema(module2, module3, module4, module5);
396 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Sets.newHashSet(module2), null);
397 assertProxyContext(filteringSchemaContextProxy, module2, module3, module4, module5);
413 public void testChainAdditionalModulesConfig() {
414 Module moduleConfig = mockModule(CONFIG_NAME);
415 Module module2 = mockModule(MODULE2_NAME);
417 Module module3 = mockModule(MODULE3_NAME);
418 Module module4 = mockModule(MODULE4_NAME);
419 Module module5 = mockModule(MODULE5_NAME);
421 mockModuleImport(module2, moduleConfig);
422 mockModuleImport(module3, module4);
424 SchemaContext schemaContext = mockSchema(moduleConfig, module2, module3, module4, module5);
426 FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext, Sets.newHashSet(module3), moduleConfig);
427 assertProxyContext(filteringSchemaContextProxy, moduleConfig, module2, module3, module4);
431 public void testGetDataDefinitions() {
432 final Module moduleConfig = mockModule(CONFIG_NAME);
433 final SchemaContext schemaContext = mockSchema(moduleConfig);
434 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
435 Sets.newHashSet(), moduleConfig);
437 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
438 final Set<DataSchemaNode> childNodes = Sets.newHashSet(mockedContainer);
439 doReturn(childNodes).when(moduleConfig).getChildNodes();
441 final Set<DataSchemaNode> dataDefinitions = filteringSchemaContextProxy.getDataDefinitions();
442 assertTrue(dataDefinitions.contains(mockedContainer));
446 public void testGetNotifications() {
447 final Module moduleConfig = mockModule(CONFIG_NAME);
448 final SchemaContext schemaContext = mockSchema(moduleConfig);
449 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
450 Sets.newHashSet(), moduleConfig);
452 final NotificationDefinition mockedNotification = mock(NotificationDefinition.class);
453 final Set<NotificationDefinition> notifications = Sets.newHashSet(mockedNotification);
454 doReturn(notifications).when(moduleConfig).getNotifications();
456 final Set<NotificationDefinition> schemaContextProxyNotifications = filteringSchemaContextProxy.getNotifications();
457 assertTrue(schemaContextProxyNotifications.contains(mockedNotification));
461 public void testGetOperations() {
462 final Module moduleConfig = mockModule(CONFIG_NAME);
463 final SchemaContext schemaContext = mockSchema(moduleConfig);
464 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
465 Sets.newHashSet(), moduleConfig);
467 final RpcDefinition mockedRpc = mock(RpcDefinition.class);
468 final Set<RpcDefinition> rpcs = Sets.newHashSet(mockedRpc);
469 doReturn(rpcs).when(moduleConfig).getRpcs();
471 final Set<RpcDefinition> operations = filteringSchemaContextProxy.getOperations();
472 assertTrue(operations.contains(mockedRpc));
476 public void testGetExtensions() {
477 final Module moduleConfig = mockModule(CONFIG_NAME);
478 final SchemaContext schemaContext = mockSchema(moduleConfig);
479 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
480 Sets.newHashSet(), moduleConfig);
482 final ExtensionDefinition mockedExtension = mock(ExtensionDefinition.class);
483 final List<ExtensionDefinition> extensions = Lists.newArrayList(mockedExtension);
484 doReturn(extensions).when(moduleConfig).getExtensionSchemaNodes();
486 final Set<ExtensionDefinition> schemaContextProxyExtensions = filteringSchemaContextProxy.getExtensions();
487 assertTrue(schemaContextProxyExtensions.contains(mockedExtension));
491 public void testGetUnknownSchemaNodes() {
492 final Module moduleConfig = mockModule(CONFIG_NAME);
493 final SchemaContext schemaContext = mockSchema(moduleConfig);
494 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
495 Sets.newHashSet(), moduleConfig);
497 final UnknownSchemaNode mockedUnknownSchemaNode = mock(UnknownSchemaNode.class);
498 final List<UnknownSchemaNode> unknownSchemaNodes = Lists.newArrayList(mockedUnknownSchemaNode);
499 doReturn(unknownSchemaNodes).when(moduleConfig).getUnknownSchemaNodes();
501 final List<UnknownSchemaNode> schemaContextProxyUnknownSchemaNodes =
502 filteringSchemaContextProxy.getUnknownSchemaNodes();
503 assertTrue(schemaContextProxyUnknownSchemaNodes.contains(mockedUnknownSchemaNode));
507 public void testGetTypeDefinitions() {
508 final Module moduleConfig = mockModule(CONFIG_NAME);
509 final SchemaContext schemaContext = mockSchema(moduleConfig);
510 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
511 Sets.newHashSet(), moduleConfig);
513 final TypeDefinition<?> mockedTypeDefinition = mock(TypeDefinition.class);
514 final Set<TypeDefinition<?>> typeDefinitions = Sets.newHashSet(mockedTypeDefinition);
515 doReturn(typeDefinitions).when(moduleConfig).getTypeDefinitions();
517 final Set<TypeDefinition<?>> schemaContextProxyTypeDefinitions = filteringSchemaContextProxy.getTypeDefinitions();
518 assertTrue(schemaContextProxyTypeDefinitions.contains(mockedTypeDefinition));
522 public void testGetChildNodes() {
523 final Module moduleConfig = mockModule(CONFIG_NAME);
524 final SchemaContext schemaContext = mockSchema(moduleConfig);
525 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
526 Sets.newHashSet(), moduleConfig);
528 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
529 final Set<DataSchemaNode> childNodes = Sets.newHashSet(mockedContainer);
530 doReturn(childNodes).when(moduleConfig).getChildNodes();
532 final Set<DataSchemaNode> schemaContextProxyChildNodes = filteringSchemaContextProxy.getChildNodes();
533 assertTrue(schemaContextProxyChildNodes.contains(mockedContainer));
537 public void testGetGroupings() {
538 final Module moduleConfig = mockModule(CONFIG_NAME);
539 final SchemaContext schemaContext = mockSchema(moduleConfig);
540 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
541 Sets.newHashSet(), moduleConfig);
543 final GroupingDefinition mockedGrouping = mock(GroupingDefinition.class);
544 final Set<GroupingDefinition> groupings = Sets.newHashSet(mockedGrouping);
545 doReturn(groupings).when(moduleConfig).getGroupings();
547 final Set<GroupingDefinition> schemaContextProxyGroupings = filteringSchemaContextProxy.getGroupings();
548 assertTrue(schemaContextProxyGroupings.contains(mockedGrouping));
552 public void testGetDataChildByName() {
553 final Module moduleConfig = mockModule(CONFIG_NAME);
554 final SchemaContext schemaContext = mockSchema(moduleConfig);
555 final FilteringSchemaContextProxy filteringSchemaContextProxy = createProxySchemaCtx(schemaContext,
556 Sets.newHashSet(), moduleConfig);
558 final QName qName = QName.create("config-namespace", "2016-08-11", "cont");
559 final ContainerSchemaNode mockedContainer = mock(ContainerSchemaNode.class);
560 doReturn(mockedContainer).when(moduleConfig).getDataChildByName(any(QName.class));
562 final DataSchemaNode dataSchemaNode = filteringSchemaContextProxy.getDataChildByName(qName);
563 assertTrue(dataSchemaNode instanceof ContainerSchemaNode);
566 private static void assertProxyContext(final FilteringSchemaContextProxy filteringSchemaContextProxy, final Module... expected) {
568 Set<Module> modSet = Sets.newHashSet();
570 if (expected!=null) {
572 modSet = Sets.newHashSet(expected);
575 Set<Module> modSetFiltering = filteringSchemaContextProxy.getModules();
577 assertEquals(modSet, modSetFiltering);
579 //asserting collections
580 if (expected!=null) {
581 for (final Module module : expected) {
582 assertEquals(module, filteringSchemaContextProxy.findModuleByName(module.getName(), module.getRevision()));
584 Set<Module> mod = filteringSchemaContextProxy.findModuleByNamespace(module.getNamespace());
585 assertTrue(mod.contains(module));
587 assertEquals(module, filteringSchemaContextProxy.findModuleByNamespaceAndRevision(module.getNamespace(), module.getRevision()));
589 assertEquals(module.getSource(), filteringSchemaContextProxy.getModuleSource(module).get());
594 private static FilteringSchemaContextProxy createProxySchemaCtx(final SchemaContext schemaContext,
595 final Set<Module> additionalModules, final Module... modules) {
597 Set<Module> modulesSet = new HashSet<>();
601 modulesSet = Sets.newHashSet(modules);
605 return new FilteringSchemaContextProxy(schemaContext, createModuleIds(modulesSet) , createModuleIds(additionalModules));
608 private static Set<ModuleId> createModuleIds(final Set<Module> modules) {
610 Set<ModuleId> moduleIds = Sets.newHashSet();
612 if (modules!=null && modules.size()>0) {
614 for (Module module : modules) {
616 moduleIds.add(new ModuleId(module.getName(), module.getRevision()));
623 private static void mockSubmodules(final Module mainModule, final Module... submodules) {
625 Set<Module> submodulesSet = new HashSet<>();
626 submodulesSet.addAll(Arrays.asList(submodules));
628 doReturn(submodulesSet).when(mainModule).getSubmodules();
631 private static void mockModuleImport(final Module importer, final Module... imports) {
632 Set<ModuleImport> mockedImports = Sets.newHashSet();
633 for (final Module module : imports) {
634 mockedImports.add(new ModuleImport() {
636 public String getModuleName() {
637 return module.getName();
641 public Date getRevision() {
642 return module.getRevision();
646 public String getPrefix() {
647 return module.getName();
651 public SemVer getSemanticVersion() {
652 return module.getSemanticVersion();
656 public String toString() {
658 return String.format("Module: %s, revision:%s", module.getName(), module.getRevision());
662 doReturn(mockedImports).when(importer).getImports();
665 //mock module with revision
666 private static Module mockModule(final String name, final Date rev) {
668 final Module mod = mockModule(name);
670 doReturn(QNameModule.create(mod.getNamespace(), rev)).when(mod).getQNameModule();
671 doReturn(rev).when(mod).getRevision();
672 doReturn(mod.getQNameModule().toString()).when(mod).toString();
677 //mock module with default revision
678 private static Module mockModule(final String mName) {
680 Module mockedModule = mock(Module.class);
681 doReturn(mName).when(mockedModule).getName();
682 doReturn(revision).when(mockedModule).getRevision();
683 final URI newNamespace = URI.create(namespace.toString() + ":" + mName);
684 doReturn(newNamespace).when(mockedModule).getNamespace();
685 doReturn(QNameModule.create(newNamespace, revision)).when(mockedModule).getQNameModule();
686 doReturn(TEST_SOURCE).when(mockedModule).getSource();
687 doReturn(Sets.newHashSet()).when(mockedModule).getSubmodules();
688 doReturn(mockedModule.getQNameModule().toString()).when(mockedModule).toString();
689 mockModuleImport(mockedModule);