String resourceName = getClasspathManifestName(moduleName);
        Set<File> implementationClasspath = new LinkedHashSet<>();
        findImplementationClasspath(moduleName, implementationClasspath);
        for (File file : implementationClasspath) {
            if (file.isDirectory()) {
                File propertiesFile = new File(file, resourceName);
                if (propertiesFile.isFile()) {

 */

package org.gradle.internal.file.nio;

import org.gradle.internal.file.FileCanonicalizer;
import org.gradle.internal.file.FileException;

import java.io.File;
import java.io.IOException;

// Used via FQCN
@SuppressWarnings("unused")
public class Jdk7FileCanonicalizer implements FileCanonicalizer {
    @SuppressWarnings("Since15")
    @Override
    public File canonicalize(File file) throws FileException {

 * limitations under the License.
 */

package org.gradle.internal.file.nio

import org.gradle.internal.file.AbstractFileMetadataAccessorTest
import org.gradle.internal.file.FileMetadata
import org.gradle.internal.file.FileMetadataAccessor
import org.gradle.util.UsesNativeServices

import java.nio.file.Files
import java.nio.file.LinkOption
import java.nio.file.attribute.BasicFileAttributeView

@UsesNativeServices

        this.owner = owner;
        this.artifact = artifact;
        this.artifactId = artifactId;
        this.file = file;
        this.fileSource = calculatedValueFactory.create(Describables.of(artifactId), file);
        this.builtBy = builtBy;

        assert !filteredContents

        def tmpDir = dir.file(".tmp")
        if (tmpDir.exists()) {
            tmpDir.assertIsEmptyDir()
        }
    }

    private void printFileTree(File dir) {
        def list = []
        if (dir.exists()) {
            dir.eachFileRecurse { file ->
                list << file
            }
        }

            String getJavaExpression() {
                "new File(\"$directoryPath\").listFiles((File f) -> true)"
            }

            @Override
            String getGroovyExpression() {
                "new File(\"$directoryPath\").listFiles((FileFilter) (File file) -> true)"
            }
        }
    }

    static UndeclaredFileAccess directoryContentWithFilenameFilter(String directoryPath) {

            }
        }
    }

    public boolean isSelfOrDescendant(File file) {
        if (file.getAbsolutePath().equals(getAbsolutePath())) {
            return true;
        }
        return isDescendant(file);
    }

    public boolean isDescendant(File file) {
        return file.getAbsolutePath().startsWith(getAbsolutePath() + File.separatorChar);
    }

    public TestFile createDir() {

        File basedir = new File(System.getProperty("java.io.tmpdir"), "test").getAbsoluteFile();

        String aligned = new DefaultPathTranslator().alignToBaseDirectory("${basedir}/dir", basedir);

        assertEquals(new File(basedir, "dir").getAbsolutePath(), aligned);
    }

    @Test
    void testUnalignToBasedirWherePathEqualsBasedir() {

import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import org.gradle.test.fixtures.file.TestFile

import java.util.concurrent.locks.ReentrantLock
import java.util.function.Consumer
import java.util.function.Supplier

class LockOnDemandCrossProcessCacheAccessTest extends ConcurrentSpec {
    def file = new TestFile("some-file.lock")
    def lockManager = Mock(FileLockManager)

        }

        ActivationFile file = activation.getFile();

        if (file == null) {
            return false;
        }

        String path;
        boolean missing;

        if (file.getExists() != null && !file.getExists().isEmpty()) {
            path = file.getExists();
            missing = false;
        } else if (file.getMissing() != null && !file.getMissing().isEmpty()) {