}
}

type testCase struct {
	method, host, path string
	wantPat            string // "" for nil (no match)
	wantMatches        []string
}

func TestRoutingNodeMatch(t *testing.T) {

	test := func(tree *routingNode, tests []testCase) {
		t.Helper()
		for _, test := range tests {
			gotNode, gotMatches := tree.match(test.host, test.method, test.path)
			got := ""
			if gotNode != nil {

    } // -- Object getConfiguration()

    /**
     * Method getGoals.
     *
     * @return List
     */
    public java.util.List<String> getGoals() {
        if (this.goals == null) {
            this.goals = new java.util.ArrayList<String>();
        }

        return this.goals;
    } // -- java.util.List<String> getGoals()

    /**
     * Method removeGoal.
     *
     * @param string a string object.

    } // -- String getId()

    /**
     * Method getPhases.
     *
     * @return List
     */
    public java.util.List<Phase> getPhases() {
        if (this.phases == null) {
            this.phases = new java.util.ArrayList<Phase>();
        }

        return this.phases;
    } // -- java.util.List<Phase> getPhases()

    /**
     * Method removePhase.
     *
     * @param phase a phase object.

import org.gradle.api.Project
import org.gradle.internal.cc.impl.AbstractConfigurationCacheIntegrationTest

class SystemPropertyInstrumentationInStaticGroovyIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "#method is instrumented in static Groovy"() {
        def configurationCache = newConfigurationCacheFixture()

        given:

 * <p>
 * A default version range is defined on the ToolingApiSpecification, which can be overridden by a separate annotation placed on a test task or test method.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Inherited
public @interface TargetGradleVersion {
    /**

 * <p>
 * A default version range is defined on the ToolingApiSpecification, which can be overridden by a separate annotation placed on a test task or test method.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Inherited
public @interface ToolingApiVersion {
    /**

import org.gradle.api.Project
import org.gradle.internal.cc.impl.AbstractConfigurationCacheIntegrationTest

class SystemPropertyInstrumentationInJavaIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "#method is instrumented in Java"() {
        def configurationCache = newConfigurationCacheFixture()

        given:
        file("buildSrc/src/main/java/SomePlugin.java") << """
            import ${Plugin.name};

 * {@code Iterable}. Except as noted, each method has a corresponding {@link Iterator}-based method
 * in the {@link Iterators} class.
 *
 * <p><b>Java 8+ users:</b> several common uses for this class are now more comprehensively
 * addressed by the new {@link java.util.stream.Stream} library. Read the method documentation below

        return this;
    }

    /**
     * Appends a method name to the current node.
     */
    public TreeFormatter appendMethod(Method method) {
        // Implementation is currently dumb, can be made smarter
        append(method.getDeclaringClass().getSimpleName());
        append(".");
        append(method.getName());
        append("()");
        return this;
    }

    /**

   * despite the @IgnoreJRERequirement annotation there. My assumption is that, because javac
   * generates a synthetic method for the body of the lambda, the actual method calls that Animal
   * Sniffer is flagging don't appear inside toImmutableSortedMultiset but rather inside that
   * synthetic method. By moving those calls to a named method, we're able to apply
   * @IgnoreJRERequirement somewhere that it will help.
   */