*
     * @return this
     */
    ExecutionFailure assertHasFailure(String description, Consumer<? super Failure> action);

    /**
     * Asserts that there is a failure present with the given cause (ie the bit after the description).
     *
     * <p>Error messages are normalized to use new-line char as line separator.
     */

// license that can be found in the LICENSE file.

package filepathlite

import (
	"internal/bytealg"
	"internal/stringslite"
	"syscall"
)

const (
	Separator     = '\\' // OS-specific path separator
	ListSeparator = ';'  // OS-specific path list separator
)

func IsPathSeparator(c uint8) bool {
	return c == '\\' || c == '/'
}

func isLocal(path string) bool {
	if path == "" {
		return false
	}

internal
fun compactStringFor(files: Iterable<File>) =
    compactStringFor(files.map { it.path }, File.separatorChar)


internal
fun compactStringFor(paths: Iterable<String>, separator: Char) =
    CompactTree.of(paths.map { it.splitIncluding(separator).toList() }).toString()


private
sealed class CompactTree {

    companion object {

        fun of(paths: Iterable<List<String>>): CompactTree =
            paths

	// Key indicates that the content of this path element is a key value map
	Key = "k"

	// Separator separates the type of a path element from the contents
	Separator = ":"
)

// NewPathElement parses a serialized path element
func NewPathElement(s string) (fieldpath.PathElement, error) {
	split := strings.SplitN(s, Separator, 2)
	if len(split) < 2 {
		return fieldpath.PathElement{}, fmt.Errorf("missing colon: %v", s)
	}

    private static final String SEPARATOR = ".";
    private final String value;

    public DefaultPluginId(String value) {
        this.value = value;
    }

    private boolean isQualified() {
        return value.contains(SEPARATOR);
    }

    @Nullable
    public String getNamespace() {
        return isQualified() ? value.substring(0, value.lastIndexOf(SEPARATOR)) : null;
    }

        }

        if (path.startsWith(SEPARATOR)) {
            throw new InvalidPathException(String.format("Model path '%s' cannot start with name separator '%s'.", path, SEPARATOR), null);
        }

        if (path.endsWith(SEPARATOR)) {
            throw new InvalidPathException(String.format("Model path '%s' cannot end with name separator '%s'.", path, SEPARATOR), null);
        }

 */
public class PathUtil {

    /**
     * The Unix separator character.
     */
    private static final char UNIX_SEPARATOR = '/';

    /**
     * The Windows separator character.
     */
    private static final char WINDOWS_SEPARATOR = '\\';

    /**
     * The system separator character.
     */
    private static final char SYSTEM_SEPARATOR = File.separatorChar;

        "/"                                                       | ""
        "C:${File.separator}some-name"                            | "some-name"
        ""                                                        | ""
        "C:${File.separator}Windows/system${File.separator}win32" | "win32"
    }

	VSPLTH   $3, V25, V31 // Splat mask
	VSPLTH   $0, V0, V1   // Splat 1st 2 bytes of sep
	VSPLTISB $0, V10      // Clear V10

	// First case: 2 byte separator
	// V1: 2 byte separator splatted
	// V2: 16 bytes at addr
	// V4: 16 bytes at addr+1
	// Compare 2 byte separator at start
	// and at start+1. Use VSEL to combine
	// those results to find the first
	// matching start byte, returning
	// that value when found. Loop as

            printCollectionIfNotEmpty(arguments, separator = ", ", prefix = "<", postfix = ">") {
                renderTypeProjection(it, printer)
            }
        }
    }

    private fun renderFqName(fqName: FqName, printer: PrettyPrinter) {
        printer.printCollection(fqName.pathSegments(), separator = ".") {
            append(it.render())
        }
    }