def assertCleanTasksRunBeforeGenerationTasks() {
        [":", ":foo", ":foo:bar"].each { projectPath ->
            getGenerationTaskNames(projectPath).each { taskName ->
                result.assertTaskOrder(getCleanTaskName(taskName), taskName)
            }
        }
    }

    def assertGenerationTasksRunBeforeCleanTasks() {
        [":", ":foo", ":foo:bar"].each { projectPath ->

        path(':foo:bar').takeFirstSegments(1) == path(':foo')
        path(':foo:bar').takeFirstSegments(2) == path(':foo:bar')
        path(':foo:bar:baz').takeFirstSegments(2) == path(':foo:bar')
    }

    def "can take first n segments without incurring unnecessary copies"() {
        given:
        def path = path(':foo:bar')

        expect:

        given:
        boolean expectedTransitive = false;
        final Map<String, Object> mapNotation = GUtil.map("path", ":foo:bar", "configuration", "compile", "transitive", expectedTransitive);

        and:
        projectFinder.getProject(':foo:bar') >> projectDummy

        when:
        def projectDependency = factory.createFromMap(projectFinder, mapNotation);

        then:

                    }
                }
                task fooJar(type: Jar) {
                   archiveBaseName = 'b-foo'
                }
                task barJar(type: Jar) {
                   archiveBaseName = 'b-bar'
                }
                artifacts {
                    'default' file('b-default.jar')
                    foo fooJar
                    bar barJar
                }
            }

	}
	cmd := iptablesCommand(protocol)
	if !sets.New(fcmd.CombinedOutputLog[1]...).HasAll(cmd, "-t", "nat", "-N", "FOOBAR") {
		t.Errorf("%s new chain: Expected cmd containing '%s -t nat -N FOOBAR', got %s", protocol, cmd, fcmd.CombinedOutputLog[2])
	}
	// Exists.
	exists, err = runner.EnsureChain(TableNAT, Chain("FOOBAR"))
	if err != nil {
		t.Errorf("%s existing chain: Expected success, got %v", protocol, err)
	}
	if !exists {

            public class DeprecatedTask extends DefaultTask {
                @TaskAction
                void causeDeprecationWarning() {
                    DeprecationLogger.deprecateTask("thisIsADeprecatedTask").replaceWith("foobar").willBeRemovedInGradle9().undocumented().nagUser();
                    System.out.println("DeprecatedTask.causeDeprecationWarning() executed.");
                }

                public static void someFeature() {

import (
	"fmt"
	"time"
)

var (
	units = []struct {
		divisor time.Duration
		unit    rune
	}{
		{1000000, 's'},
		{60, 'm'},
		{60, 'h'},
		{24, 'd'},
		{7, 'w'},
	}
)

func foobar(d time.Duration) string {
	d /= time.Microsecond
	unit := 'u'

	for _, f := range units {
		if d%f.divisor != 0 {
			break
		}
		d /= f.divisor
		unit = f.unit
	}
	return fmt.Sprintf("%d%c", d, unit)

	Boolean   bool              `json:"boolean,omitempty"`
	NamedStr  namedString       `json:"namedStr,omitempty"`
	NamedBool namedBool         `json:"namedBool,omitempty"`
	Foobar    bar               `json:"foobar,omitempty"`
	Testmap   map[string]string `json:"testmap,omitempty"`
}

func (obj *foo) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }

type baz struct {
	Ptr  *int  `json:"ptr"`

        where:
        notation << [
                "foo:bar",
                "foo:bar:",
                "foo::1.0",
                ":bar:1.0"
        ]
    }

    def "invalid string notation #notation is reported for lenient parser"() {
        when:

  }

  public void testFindClassesToTest_ignoreUnderscores() {
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, Foo_Bar.class)))
        .containsExactly(Foo.class, Foo_Bar.class);
    sanityTests.ignoreClasses(AbstractPackageSanityTests.UNDERSCORE_IN_NAME);
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, Foo_Bar.class)))
        .containsExactly(Foo.class);
  }