*/
        AGENT_INSTRUMENTATION_MARKER(".gradle-agent-instrumented.marker"),
        /**
         * A marker file put next to the instrumented entry to indicate that it is using legacy instrumentation.
         */
        LEGACY_INSTRUMENTATION_MARKER(".gradle-legacy-instrumented.marker"),
        /**
         * A marker file put next to the instrumented entry to indicate that original file doesn't exist so there was no instrumentation.

    }

    private
    fun assertParserConsumes(parser: Parser<Any>, input: String) {
        val whitespace = "   "
        assertThat(
            parser.consumeFrom(input + whitespace + "something more"),
            equalTo(input)
        )

        assertThat(
            parser.consumeFrom(input + "\nsomething"),
            equalTo(input)
        )
    }
}

        given:
        def markerFile = file("input/marker")
        markerFile.text = "original"

        file(buildFileName) << """
            tasks.register("myTask") {
              ${variableDefinition} inputFile = file("input/marker")
              inputs.files(inputFile)
              outputs.files("build/marker")
              doLast {
                println("value: " + inputFile.${readTextMethod})

    }

    val statements: Parser<Any> by debug {
        optional(statement * zeroOrMore(semis * statement)) * optional(semis)
    }

    val indexingSuffix by debug {
        bracket(
            expression * zeroOrMore(token(COMMA) * expression * optional(token(COMMA)))
        )
    }

    val navigationSuffix: Parser<Any> by debug {

                }
                return target;
            }

            @Override
            public void configure(CommandLineParser parser) {
                for (BuildOption<? super T> option : getAllOptions()) {
                    option.configure(parser);
                }
            }
        };
    }

    /**
     * Returns a {@link PropertiesConverter} that can extract the options defined by this set.

     * TransformReplacer throws upon opening a multi-release JAR without the marker resource.
     */
    public enum MarkerResource {
        // The transformed marker resource is an empty file to reduce archive size in the most common case.
        TRANSFORMED(new byte[0]),
        // Not transformed marker resource is a 1-byte file with a single "N" symbol.

    implementation(project(":integration-testing"))
    implementation(project(":cleanup"))
    implementation(project(":build-update-utils"))

    implementation("org.openmbee.junit:junit-xml-parser") {
        exclude(module = "lombok") // don't need it at runtime
    }
    implementation("com.google.guava:guava")
    implementation("com.google.code.gson:gson")
    implementation("commons-io:commons-io")

 */

package org.gradle.internal.instrumentation.api.types;

public interface FilterableBytecodeInterceptorFactory {

    BytecodeInterceptorType getType();

    /**
     * A marker interface that indicates that a class is used for generating bytecode upgrades.
     */
    interface BytecodeUpgradeInterceptorFactory extends FilterableBytecodeInterceptorFactory {
        @Override

        }
    }

    private static String errorMessageFor(String factory) {
        return "Unable to create secure " + factory + ", please make sure that your build does not depend on an old XML parser.";
    }

    private XmlFactories() {}

 *
 * The {@link #unprovenHierarchies()} stream returns any hierarchies that were armed, but never received
 * a file system event.
 * These locations cannot be trusted to receive file system events in a timely manner.
 *
 * Note: a probe needs to be armed only once, if it receives an event, we will trust that location until
 * the registry is closed.
 */
public interface FileWatcherProbeRegistry {