A project name with kebab case (`some-lib`) or snake case (`some_lib`) will be converted to camel case in accessors: `projects.someLib`.

=== Local forks of module dependencies

A module dependency can be substituted by a dependency to a local fork of the sources of that module, if the module itself is built with Gradle.

Adding a dependency using the `libs.someLib` notation works exactly like if you had hardcoded the group, artifact and version directly in the build script.

            }
        }

        when:
        allowFileSystemAccess(true)
        def snapshot = read(someDir)
        then:
        assertIsDirectorySnapshot(snapshot, someDir)

        when:
        allowFileSystemAccess(false)
        def subDir = someDir.file("sub")
        snapshot = read(subDir)
        then:
        assertIsDirectorySnapshot(snapshot, subDir)
    }

'''
        when:
        run 'copy'
        then:
        file('dest').assertHasDescendants('someDir/1.txt')
    }

    @Issue("GRADLE-3310")
    def "handles gzip compressed tars from resources.gzip"() {
        given:
        TestFile tar = file('tar-contents')
        tar.create {
            someDir {
                file '1.txt'
                file '2.txt'
            }
        }

        File someDir = new TestFile(testDirectoryProvider.testDirectory, "testFile")
        someDir.createDir()

        when:
        publisher.publish(publication, repository)

        then:
        ivyArtifact.name >> "name"
        ivyArtifact.type >> "type"
        ivyArtifact.extension >> "ext"
        ivyArtifact.file >> someDir

        and:

        childResolver.dirMode == 0x4
    }

    def canWalkDownTreeCreatedUsingFromIntegrationTest() {

        CopySpec child = parentSpec.from('somedir') { into 'child' }
        child.from('somedir') { into 'grandchild' }
        child.from('somedir') { into '/grandchild' }

        when:
        List<RelativePath> paths = new ArrayList<RelativePath>()

        settingsFile << """
            include ':exe', ':some:lib', ':other:lib'
        """
        buildFile << """
            project(":exe") {
                apply plugin: "cpp-application"

                dependencies {
                    implementation project(':some:lib')
                }
            }
            project(":some:lib") {
                apply plugin: "cpp-library"

                                PropertyExpression fullExpression = hasSinglePropertyExpressionArgument(call);
                                if (fullExpression != null) {
                                    // <versionCatalog>.plugins.someId
                                    // or <versionCatalog>.plugins.some.id
                                    // because the expression might be complex we rely on its textual representation

                    def input = inputArtifact.get().asFile
                    println "processing \${input.name} using \${parameters.someDir.get().asFile.name}"
                    def output = outputs.file(input.name + ".green")
                    output.text = input.text + parameters.someDir.get().asFile.list().length + ".green"
                }
            }
        """

        when:
        run(":a:resolve")

        runEclipseTask """
apply plugin: "java"
apply plugin: "eclipse"

repositories {
	flatDir { dirs "${TextUtil.escapeString(repoDir)}" }
}

dependencies {
	implementation "some:lib:1.0"
}
        """
    }

    @Test
    @Issue("GRADLE-1706") // doesn't prove that the issue is fixed because the test also passes with 1.0-milestone-4
    @ToBeFixedForConfigurationCache