// 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);
        }

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

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

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

// Match reports whether name matches the shell file name pattern.
// The pattern syntax is:
//
//	pattern:
//		{ term }
//	term:
//		'*'         matches any sequence of non-Separator characters
//		'?'         matches any single non-Separator character
//		'[' [ '^' ] { character-range } ']'
//		            character class (must be non-empty)
//		c           matches character c (c != '*', '?', '\\', '[')

   * the operating system's default line separator. This method is equivalent to {@code
   * writeLines(lines, System.getProperty("line.separator"))}.
   *
   * @throws IOException if an I/O error occurs while writing to this sink
   */
  public void writeLines(Iterable<? extends CharSequence> lines) throws IOException {
    writeLines(lines, System.getProperty("line.separator"));
  }

  /**

DocumentationComponent 'docs'
-----------------------------

Source sets
    Markdown source 'docs:userguide'
        srcDir: src${File.separator}docs${File.separator}userguide
    Text source 'docs:reference'
        srcDir: src${File.separator}docs${File.separator}reference

Binaries
    DocumentationBinary 'docs:exploded'
        build using task: :docsExploded
"""
    }

    def "can build binary"() {

     */
    private
    fun File.injectAgentOptions(separator: String) {
        if (agentJarNames.isEmpty()) {
            return
        }
        var replacementsCount = 0
        // readLines eats EOLs, so we need to use postfix to make sure the last line ends with EOL too.
        writeBytes(readLines().joinToString(separator = separator, postfix = separator) { line ->
            when {

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.internal.sharedruntime.support


/**
 * Appends value to the given Appendable and simple `\n` line separator after it.
 *
 * Always using the same line separator on all systems to allow for reproducible outputs.
 */
fun Appendable.appendReproducibleNewLine(value: CharSequence = ""): Appendable {
    assert('\r' !in value) {