*/

 package ${packageString(sourceFile)};

 public class ${sourceFile.getName() - ".java"} {
 }
 """
    }

    private File unknownSourceFile(String filePath = "src/main/java/org/acme/UnknownLicensed.java") {
        File sourceFile = file(filePath);
        sourceFile << """
/*
 * Blubb my custom license shrug!
 */

 package ${packageString(sourceFile)};

        member.jApiClass.let { declaringClass ->
            sources.sourceFileAndSourceRootFor(declaringClass.sourceFilePath).let { (sourceFile, sourceRoot) ->
                if (declaringClass.isKotlin) ApiSourceFile.Kotlin(sourceFile, sourceRoot)
                else ApiSourceFile.Java(sourceFile, sourceRoot)
            }
        }

    private
    val JApiClass.sourceFilePath: String

import org.w3c.dom.Document
import org.w3c.dom.Element
import org.w3c.dom.Node

class XIncludeAwareXmlProvider {

    Document root

    Element parse(File sourceFile) {
        root = parseSourceFile(sourceFile)
        root.documentElement
    }

    Node emptyDoc() {
        root = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()
    }

                }
            }
        )
    }
}


fun JarOutputStream.addJarEntry(entryName: String, sourceFile: File) {
    val entry = ZipEntry(entryName)
    entry.time = zipEntryBaseTimestamp
    putNextEntry(entry)
    BufferedInputStream(FileInputStream(sourceFile)).use { inputStream -> inputStream.copyTo(this) }
    closeEntry()
}


fun File.getClassSuperTypes(): Set<String> {

        for (File sourceFile : sources.getFiles()) {
            boolean isPackageInfo = sourceFile.getName().equals("package-info.java");
            boolean foundNotice = false;
            boolean inNotice = false;
            StringBuilder header = new StringBuilder();
            String packageDeclaration = null;

            for (String line : FileUtils.readLines(sourceFile, "UTF-8")) {

    @Input
    abstract Property<String> getVersion();

    @TaskAction
    def transform() {
        XIncludeAwareXmlProvider provider = new XIncludeAwareXmlProvider()
        provider.parse(sourceFile.get().asFile)

        use(BuildableDOMCategory) {
            addVersionInfo(provider.document)
            transformApiLinks(provider.document)
            transformWebsiteLinks(provider.document)

        }

        return sequenceOf(directory)
    }

    private
    fun aJar(sourceFiles: Sequence<Path>): Sequence<Path> {
        val outputPath = projectDir.resolve("mylib.jar")
        Files.newOutputStream(outputPath).use { outputStream ->
            JarOutputStream(outputStream).use { jarStream ->
                sourceFiles.forEach { dir ->
                    check(Files.isDirectory(dir)) { "Must be a directory" }

func verifyChecksum(sclnt *minio.Client, srcSha256, tgtSha256 hash.Hash, srcCtnt, tgtCtnt minio.ObjectInfo) (allgood bool) {
	opts := minio.GetObjectOptions{}
	if srcCtnt.Size != tgtCtnt.Size {
		fmt.Printf("differ in size sourceSize: %d, targetSize: %d\n", srcCtnt.Size, tgtCtnt.Size)
		return false
	} else if srcCtnt.ContentType != tgtCtnt.ContentType {
		fmt.Printf("differ in contentType source: %s, target: %s\n", srcCtnt.ContentType, tgtCtnt.ContentType)