import java.io.File;

@ServiceScope(Scope.Global.class)
public class DaemonDir {
    private final File baseDir;
    private final File versionedDir;
    private final File registryFile;

    public DaemonDir(File baseDir) {
        this.baseDir = baseDir;
        this.versionedDir = new File(baseDir, GradleVersion.current().getVersion());
        this.registryFile = new File(versionedDir, "registry.bin");

        }

        if (!file.isAbsolute()) {
            File baseDir = getBaseDir();
            if (!GUtil.isTrue(baseDir)) {
                throw new IllegalArgumentException(String.format("baseDir may not be null or empty string. basedir='%s'", baseDir));
            }

            file = new File(baseDir, file.getPath());
        }

        return file;
    }

    @Override

    }

    def "touches all subdirectories for depth #depth"() {
        given:
        def file1 = baseDir.file("a/aa/aaa/1")
        def file2 = baseDir.file("b/bb/bbb/2")
        def expectedTouchedFiles = touchedPaths.collect { baseDir.file(it) }

        def tracker = new SingleDepthFileAccessTracker(journal, baseDir, depth)

        when:
        tracker.markAccessed(file1)
        tracker.markAccessed(file2)

        this.serializedParameters = serializedParameters;
        this.classLoaderStructure = classLoaderStructure;
        this.baseDir = baseDir;
        this.projectCacheDir = projectCacheDir;
        this.usesInternalServices = usesInternalServices;
    }

    public File getBaseDir() {
        return baseDir;
    }

    public boolean isInternalServicesRequired() {
        return usesInternalServices;
    }

        then:
        1 * fileAccessTimeJournal.setLastAccessTime(baseDir.file('group'), _)
    }

    def "allows to mark files accessed externally"() {
        when:
        fileStore.getFileAccessTracker().markAccessed(baseDir.file('group/1.txt'))

        then:
        1 * fileAccessTimeJournal.setLastAccessTime(baseDir.file('group'), _)
    }

                    echo(message: 'Basedir is: ${basedir}')
                }
            }
        }
    }

    private void "test basedir"(String buildFileContents, File expectedBasedir, String taskName) {
        // given
        buildFile << buildFileContents
        // when
        succeeds(taskName)
        // then
        outputContains("[ant:echo] Basedir is: " + expectedBasedir.getAbsolutePath())
    }

    private final File baseDir;
    private final ChecksumService checksumService;

    public GroupedAndNamedUniqueFileStore(File baseDir, TemporaryFileProvider temporaryFileProvider, FileAccessTimeJournal fileAccessTimeJournal, Grouper<K> grouper, Namer<K> namer, ChecksumService checksumService) {
        this.delegate = new UniquePathKeyFileStore(checksumService, baseDir);

      if [ -d "${arg}" ]; then
        basedir=`cd "${arg}" && pwd -P`
      elif [ -f "${arg}" ]; then
        basedir=`dirname "${arg}"`
        basedir=`cd "$basedir" && pwd -P`
        if [ ! -d "$basedir" ]; then
          echo "Directory $basedir extracted from the -f/--file command-line argument ${arg} does not exist" >&2
          exit 1
        fi
      else

 */
class TestWorkspaceBuilder {
    def TestFile baseDir

    def TestWorkspaceBuilder(TestFile baseDir) {
        this.baseDir = baseDir
    }

    def apply(Closure cl) {
        cl.delegate = this
        cl.resolveStrategy = Closure.DELEGATE_FIRST
        cl()
    }

    TestFile dir(String name) {
        baseDir.file(name).createDir()
    }

                <mkdir dir="${basedir}/target/test-classes/${test.projects.repository}/${test.projects.target.directory}/" />

                <jar destfile="${basedir}/target/test-classes/${test.projects.repository}/${test.projects.target.directory}/${test.projects.archetype}.jar" basedir="${basedir}/src/test/archetypes/${test.projects.source.directory}/" />
              </tasks>