ModuleVersionIdentifier possibleMatch = entry.left;
                        return depSelector.getGroup().equals(possibleMatch.getGroup())
                            && depSelector.getModule().equals(possibleMatch.getName());
                    }
                });
                if (entry == null) {

            this.dependencyArtifact = dependencyArtifact;
        }

        @Override
        public String getGroup() {
            return group;
        }

        @Override
        public String getModule() {
            return module;
        }

        @Override
        public VersionConstraint getVersionConstraint() {
            return versionConstraint;
        }

        @Override

        publishJavaModule('moda')
        consumingModuleInfo('requires moda')
        def mainClass = consumingModuleClass('moda.ModaClass')
        mainClass.text = mainClass.text.replace('.run()', '.run(); MainModule.class.getModule().getResourceAsStream("data.txt").readAllBytes()')
        file('src/main/resources/data.txt').text = "some data"

        when:
        succeeds ':run'

        then:
        outputContains("Module Name: consumer")

            ModuleVersionSelector failureSelector = failure.getSelector();
            ModuleComponentSelector failureComponentSelector = DefaultModuleComponentSelector.newSelector(failureSelector.getModule(), failureSelector.getVersion());
            root.addDependency(dependencyResultFactory.createUnresolvedDependency(failureComponentSelector, root, true,
                ComponentSelectionReasons.of(DEPENDENCY_LOCKING),

            if (unmatchedVersions.isEmpty() && rejectedVersions.isEmpty()) {
                builder.node(String.format("Could not find any matches for %s as no versions of %s:%s are available.", selector, selector.getGroup(), selector.getModule()));
            } else {
                builder.node(String.format("Could not find any version that matches %s.", selector));
                if (!unmatchedVersions.isEmpty()) {

            } else {
                return newSelector(dependency.getModule(), dependency.getVersionConstraint().getRequiredVersion());
            }
        }

        @SuppressWarnings("ConstantConditions")
        private Class<?> getProviderTargetClass(Provider<?> notation) {

        }

        @Override
        public boolean matches(ModuleComponentIdentifier id) {
            return groupMatches(id.getGroup())
                && (module == null || module.equals(id.getModule()))
                && (version == null || version.equals(id.getVersion()) || versionSelector.accept(id.getVersion()));
        }

        @Nullable

                EmptyResults.INSTANCE, resolvedConfiguration
            )
        );
    }

    private VisitedGraphResults emptyGraphResults(ResolveContext resolveContext) {
        Module module = resolveContext.getModule();
        ModuleVersionIdentifier id = moduleIdentifierFactory.moduleWithVersion(module.getGroup(), module.getName(), module.getVersion());

            return Collections.emptySet();
        }

        ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) module.getId();
        IvyArtifactName ivyArtifactName = new DefaultIvyArtifactName(moduleId.getModule(), type, "jar", classifier);

        ModuleComponentArtifactMetadata artifact = new DefaultModuleComponentArtifactMetadata(moduleId, ivyArtifactName);

            } else {
                ExternalDependency extDep = (ExternalDependency) dep;
                dependenciesBuilder.dependency(dep.getConfiguration(), null, BuildInitDependency.of(extDep.getGroupId(), extDep.getModule(), extDep.getVersion()));
            }
        }
    }

    private void globalExclusions(MavenProject project, BuildScriptBuilder builder) {