# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

moduleName=dependency-management
moduleVersion=1.0

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

moduleName=model-core-tests
moduleVersion=1.0

    abstract String getProjectPath();

    abstract String dependsOnMechanism(String projectName, String taskName);

    abstract String declareDependency(String moduleName, String moduleVersion);

    abstract String declaredDependencyId(String moduleName, String moduleVersion);

    abstract void moduleDefinition(String name, String definition);

    /**

    /**
     * Visit graph independent details of the component.
     */
    void visitComponentDetails(ComponentIdentifier componentId, ModuleVersionIdentifier moduleVersion);

    /**
     * Visit a selected variant of the component.
     */
    void visitSelectedVariant(Long id, ResolvedVariantResult variant);

    /**
     * Visit variants of the component.
     */

                    println "scriptTask - " + this.getClass().classLoader.getResource('d/v.txt').text
                }
            }

            task buildscriptDependencies {
                def moduleVersion = buildscript.configurations.classpath.incoming.artifacts.artifacts
                    .collect { it.id }
                    .findAll { it.componentIdentifier instanceof ModuleComponentIdentifier }

    // https://github.com/gradle/configuration-cache/issues/183
    val modules = provider {
        embeddedKotlinBaseDependencies.incoming.resolutionResult.allComponents
            .asSequence()
            .mapNotNull { it.moduleVersion }
            .filter { it.name !in skippedModules }
            .associate { "${it.group}:${it.name}" to it.version }
    }

    doLast {
        ReproduciblePropertiesWriter.store(
            modules.get(),

            """
        }
        file("groovy-lib/src/main/resources/META-INF/groovy/org.codehaus.groovy.runtime.ExtensionModule") << """
            moduleName=Test module
            moduleVersion=1.0-test
            extensionClasses=support.FrenchStrings
        """
        file("groovy-lib/src/main/groovy/support/FrenchStrings.groovy") << """
            package support

        def result = deserialize(serialized)

        then:
        result.id == componentIdentifier
        result.selectionReason == ComponentSelectionReasons.requested()
        result.moduleVersion == newId('org', 'foo', '2.0')
        for (def variants : [result.selectedVariants, result.availableVariants]) {
            variants.size() == 2
            variants[0] == v1Result
            variants[1] == v2Result

            it.children.each { transitive ->
                assert transitive.moduleGroup == "org.gradle.111"
                assert transitive.moduleName == "module_111"
                assert transitive.moduleVersion == "v_111"
            }
        }
        assert configurations.compile.collect { it.name } == ['test-1.45.jar', 'module_111-v_111.jar']
    }
}
"""
        resolve.prepare()

        when:

    def repo = Mock(ExternalResourceRepository)
    def module = new DefaultModuleIdentifier("org.acme", "testproject")
    def result = new DefaultBuildableModuleVersionListingResolveResult()
    def moduleVersion = new DefaultModuleVersionIdentifier(module, "1.0")
    def artifact = new DefaultIvyArtifactName("testproject", "jar", "jar")

    def resourceAccessor = Mock(CacheAwareExternalResourceAccessor)