while (true) {
        val line = source.readUtf8Line() ?: break
        if (line.isEmpty() || line.startsWith("#")) continue

        var i = 0
        val parts = line.split(Regex(" ")).toTypedArray()

        val element = WebPlatformUrlTestData()
        element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =

        final String value = config.getInitParameter(ENCODING_MAP);
        if (StringUtil.isNotBlank(value)) {
            final String[] encodingPairs = value.split(",");
            for (final String pair : encodingPairs) {
                final String[] encInfos = pair.trim().split(":");
                if (encInfos.length == 2) {
                    encodingMap.put("/" + encInfos[0] + "/", encInfos[1]);
                }
            }

import java.net.InetAddress
import okhttp3.internal.interleave

/**
 * Implementation of HappyEyeballs Sorting Addresses.
 *
 * The current implementation does not address any of:
 *  - Async DNS split by IP class
 *  - Stateful handling of connectivity results
 *  - The prioritisation of addresses
 *
 * https://datatracker.ietf.org/doc/html/rfc8305#section-4
 */

		}

		slices.SortFunc(r.fileList, func(a, b fileListEntry) int {
			return fileEntryCompare(a.name, b.name)
		})
	})
}

func fileEntryCompare(x, y string) int {
	xdir, xelem, _ := split(x)
	ydir, yelem, _ := split(y)
	if xdir != ydir {
		return strings.Compare(xdir, ydir)
	}
	return strings.Compare(xelem, yelem)
}

// Open opens the named file in the ZIP archive,
// using the semantics of fs.FS.Open:

        if (UNICODE_TRAVERSAL.matcher(path).find()) {
            return true;
        }

        // Check for standalone double dots that could be dangerous
        String[] parts = path.split("[\\\\/]");
        for (String part : parts) {
            if (".".equals(part) || "..".equals(part)) {
                return true;
            }
        }

        return false;
    }

    /**

    steps {
        script {
            name = "CLEAN_UP_GIT_UNTRACKED_FILES_AND_DIRECTORIES"
            executionMode = BuildStep.ExecutionMode.RUN_ONLY_ON_FAILURE
            scriptContent = "git clean -fdx -e test-splits/ -e .gradle/workspace-id.txt -e \"*.psoutput\""
            skipConditionally()
            onlyRunOnGitHubMergeQueueBranch()
        }
    }
}

fun BuildSteps.removeSubstDirOnWindows(os: Os) {

    public void init() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        webProtocols = split(fessConfig.getCrawlerWebProtocols(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> s.trim() + ":").toArray(n -> new String[n]));
        fileProtocols = split(fessConfig.getCrawlerFileProtocols(), ",")

			if err != nil {
				return err
			}
			split, err := rs.Split(m.mapped)
			if err != nil {
				return err
			}
			splitFilled, err := rs.Split(m.filled)
			if err != nil {
				return err
			}
			ok := len(splitFilled)
			for i, sh := range splitFilled {
				if slices.Contains(sh, 0) {
					split[i] = nil
					ok--
				}
			}
			hasParity := 0

        InputStreamThread thread = new InputStreamThread(is, StandardCharsets.UTF_8, 10, null);
        thread.start();
        thread.join(1000);

        String output = thread.getOutput();
        String[] lines = output.split("\n");

        assertTrue("Buffer should be limited to 10 items", lines.length <= 10);
        assertTrue("Last lines should be kept", output.contains("line15"));
    }

	uploadBytes, err := base64.RawURLEncoding.DecodeString(uploadID)
	if err != nil {
		return "", fmt.Errorf("error parsing uploadID %s (%w)", uploadID, err)
	}
	slc := strings.SplitN(string(uploadBytes), ".", 2)
	if len(slc) != 2 {
		return "", fmt.Errorf("uploadID %s has incorrect format", uploadID)
	}
	return slc[0], nil