*
     * <p>A node will be selected if its path equals the specified path.
     */
    @Nullable
    public ModelPath getPath() {
        return null;
    }

    /**
     * Returns the parent path of the nodes to select, or null if parent is not relevant.
     *
     * <p>A node will be selected if its parent's path equals the specified path.
     */
    @Nullable

    boolean canStore();

    /**
     * Stores the file to the local cache.
     *
     * If canStore() returns false, then this method will do nothing and will return false.
     *
     * Returns true if store was completed.
     */
    boolean maybeStore(BuildCacheKey key, File file);

    getByName(name)


/**
 * Looks for the extension of a given name and casts it to the expected type [T].
 *
 * If none found it will throw an [UnknownDomainObjectException].
 * If the extension is found but cannot be cast to the expected type it will throw an [IllegalStateException].
 *
 * @param name extension name
 * @return extension, never null

package org.gradle.kotlin.dsl.resolver

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class CompactTreeTest {

    @Test
    fun `it will compact common prefixes`() {
        assertThat(
            compactStringFor(listOf("/a/b/c", "/a/b/d", "/a/e/c"), separator = '/'),
            equalTo("/a/{b/{c, d}, e/c}")
        )
    }

 *  will query all bindings to find which one knows how to encode the type at hand,
 *  by invoking {@link org.gradle.internal.serialize.graph.codecs.Binding#encodingForType(java.lang.Class)} on each binding. If a binding supports the type,
 *  it will return the proper {@link org.gradle.internal.serialize.graph.EncodingProvider} (or null, otherwise).
 *  </p><p>

#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
#     and any embedded shellness will be escaped.
#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
#     treated as '${Hostname}' itself on the command line.

set -- \
        "-Dorg.gradle.appname=$APP_BASE_NAME" \
        -classpath "$CLASSPATH" \

import org.jetbrains.kotlin.lexer.KotlinLexer
import org.junit.Test


class KotlinGrammarTest {

    @Test
    fun `will not parse empty annotation`() {
        kotlinGrammar.annotation.failToConsumeFrom("""@""")
        kotlinGrammar.annotation.failToConsumeFrom("""@ \n """)
    }

    @Test
    fun `will not parse @ followed by whitespace`() {
        kotlinGrammar.annotation.failToConsumeFrom("@ something")

        This is also problematic because it means we have to serialize this information into some form that fits into annotations.

        Later, we will extract all the “up-front” information we need to know during compile time.
        This will mean that we only need to execute the rules themselves, and not any code to actually register the rules.
     */

    @Override

/**
 * A file tree which maintains a local copy of itself on the filesystem.
 */
public interface FileSystemMirroringFileTree extends MinimalFileTree {
    /**
     * Returns the directory tree that will contain the copy of this file tree, after all elements of this tree have been visited. It is the caller's responsibility to visit the
     * elements of this tree before using the returned directory tree.
     */

             *
             * Note: Even though 'jump to declaration' in IJ will show this to be the 'DefaultImportsReader' from
             * the plugin Gradle distribution, this is only true at compile time.
             *
             * At runtime, the 'DefaultImportsReader' will be the version from the distribution actively being built/tested.
             */