box.write(buffer, 1)
      result.write(box.copy(), 1)
    }
    return result
  }

  tailrec fun File.isDescendentOf(directory: File): Boolean {
    val parentFile = parentFile ?: return false
    if (parentFile == directory) return true
    return parentFile.isDescendentOf(directory)
  }

  /**
   * See FinalizationTester for discussion on how to best trigger GC in tests.

        1 * invocationContext.getArgAction() >> Actions.doNothing()
        1 * invocationContext.createInvocation("linking lib", outputFile.parentFile, expectedArgs, operationLogger) >> invocation
        1 * queue.add(invocation)
        1 * queue.setLogLocation(LOG_LOCATION)
        0 * _

        where:

    }

    public static Transformer<String, File> from(File file) {
        if (file.isFile()) {
            File parentFile = file.getParentFile();
            return new RelativeFileNameTransformer(parentFile, parentFile);
        }
        return new RelativeFileNameTransformer(file, file);
    }

    @Override
    public String transform(File file) {
        String canonicalRoot;

            // complete distribution is used from 'build/bin distribution'
            distributionDir.parentFile.parentFile.name
        } else {
            // gradle-runtime-api-info.jar in 'build/libs'
            testTask.classpath.filter { it.name.startsWith("gradle-runtime-api-info") }.singleFile.parentFile.parentFile.parentFile.name
        }
        return (

            }
            return true;
        }

        final File parentFile = outputFile.getParentFile();
        if (!parentFile.exists()) {
            parentFile.mkdirs();
        }
        if (!parentFile.isDirectory()) {
            logger.warn("Not found: {}", parentFile.getAbsolutePath());
            return false;
        }

        return process(thumbnailId, responseData -> {

        def existingOutputFolder = childProject.ideaModule.outputFile.parentFile

        when:
        childProject.idea.module.name = "foo"

        then:
        childProject.idea.module.name == "foo"
        childProject.ideaModule.outputFile.name == "foo.iml"
        childProject.ideaModule.outputFile.parentFile == existingOutputFolder
    }

    private applyPluginToProjects() {

}

// lower returns the ASCII lowercase version of b.
func lower(b byte) byte {
	if 'A' <= b && b <= 'Z' {
		return b + ('a' - 'A')
	}
	return b
}

// IsPrint returns whether s is ASCII and printable according to
// https://tools.ietf.org/html/rfc20#section-4.2.
func IsPrint(s string) bool {
	for i := 0; i < len(s); i++ {
		if s[i] < ' ' || s[i] > '~' {
			return false
		}
	}
	return true
}

        assertEquals('..', baseDirConverter.resolveAsRelativePath(baseDir.parentFile))
        assertEquals('..', baseDirConverter.resolveAsRelativePath('..'))

        assertEquals('..', baseDirConverter.resolveForDisplay(baseDir.parentFile))
    }

    @Test public void testAncestorToRelativePath() {
        def ancestor = baseDir.parentFile.parentFile

                    switch (type) {
                        case FILE:
                            File parentFile = root.getParentFile();
                            if (parentFile != null) {
                                outputDirectoriesToPreserve.add(parentFile);
                            }
                            break;
                        case DIRECTORY:

            getTempDir() >> tempDir
        }

        when:
        def generated = PCHUtils.generatePCHSourceFile(spec, sourceFile)

        then:
        generated.name == "test.${extension}"
        generated.parentFile == pchSourceDir
        generated.text == "#include \"test.h\""
        pchSourceDir.assertContainsDescendants("test.h", "test.${extension}")

        where:
        type              | extension