log-dump-ssh "${node_name}" "sudo journalctl --output=short-precise" > "${dir}/systemd.log" || true
        fi
    else
        local tmpfiles=()
        for f in "${kern_logfile}" "${initd_logfiles}" "${supervisord_logfiles}"; do
	    IFS=' ' read -r -a tmpfiles <<< "$f"
	    files+=("${tmpfiles[@]}")
        done
    fi

    # log where we pull the images from

		<packaging.fess.systemd.dir>/usr/lib/systemd/system</packaging.fess.systemd.dir>
		<packaging.fess.systemd.sysctl.dir>/usr/lib/sysctl.d</packaging.fess.systemd.sysctl.dir>
		<packaging.fess.tmpfilesd.dir>/usr/lib/tmpfiles.d</packaging.fess.tmpfilesd.dir>
		<packaging.fess.dictionary.dir>/var/lib/fess/config</packaging.fess.dictionary.dir>
	</properties>
	<profiles>
		<profile>
			<id>build</id>
			<activation>

func createTempFile(prefix, content string) (tempFile string, err error) {
	var tmpfile *os.File

	if tmpfile, err = os.CreateTemp("", prefix); err != nil {
		return tempFile, err
	}

	if _, err = tmpfile.Write([]byte(content)); err != nil {
		return tempFile, err
	}

	if err = tmpfile.Close(); err != nil {
		return tempFile, err
	}

	tempFile = tmpfile.Name()
	return tempFile, err
}

	}{
		{
			name: "Valid domain socket is detected as such",
			proc: func(t *testing.T) {
				tmpFile, err := os.CreateTemp("", tempPrefix)
				if err != nil {
					t.Fatalf("unexpected error by TempFile: %v", err)
				}
				theSocket := tmpFile.Name()
				os.Remove(theSocket)
				tmpFile.Close()

				con, err := net.Listen("unix", theSocket)
				if err != nil {

            }

            if (includeContent) {
                File tempFile = null;
                File outputFile = null;
                try {
                    tempFile = File.createTempFile("ftp-", ".tmp");
                    try (OutputStream out = new BufferedOutputStream(new FileOutputStream(tempFile))) {
                        if (!client.retrieveFile(ftpInfo.getName(), out)) {

		}
	}
}

func TestOffsetWriter_Seek(t *testing.T) {
	tmpfilename := "TestOffsetWriter_Seek"
	tmpfile, err := os.CreateTemp(t.TempDir(), tmpfilename)
	if err != nil || tmpfile == nil {
		t.Fatalf("CreateTemp(%s) failed: %v", tmpfilename, err)
	}
	defer tmpfile.Close()
	w := NewOffsetWriter(tmpfile, 0)

	// Should throw error errWhence if whence is not valid
	t.Run("errWhence", func(t *testing.T) {

        when:
        def cpFiles = cp.collect { new File("$it-1.0.jar") }
        def mpFiles = mp.collect { new File("$it-1.0.jar") }

        def framework = newFramework(true, ["a", "b"], ["c", "d"], ["e", "f"], ["g", "h"])
        def classpath = underTest.create(cpFiles, mpFiles, framework, true)

        then:
        if (loadsAll) {

        }

        final File tempFile;
        final boolean isByteStream = inputStream instanceof ByteArrayInputStream;
        if (isByteStream) {
            inputStream.mark(0);
            tempFile = null;
        } else {
            try {
                tempFile = File.createTempFile("tikaExtractor-", ".out");
            } catch (final IOException e) {

            case 1:
                importSystemProperties(fileName, tempFile);
                break;
            case 2:
                importGsaXml(fileName, tempFile);
                break;
            case 3:
                importBulk(fileName, tempFile);
                break;
            case 4:
                importFessJson(fileName, tempFile);
                break;
            case 5:

                final File tempFile = ComponentUtil.getSystemHelper().createTempFile("tmp-adminplugin-", ".jar");
                try (final InputStream is = form.jarFile.getInputStream(); final OutputStream os = new FileOutputStream(tempFile)) {
                    CopyUtil.copy(is, os);
                } catch (final Exception e) {
                    if (tempFile.exists() && !tempFile.delete()) {