stderr 'go: downloading go1.18beta2 '

# go1.X is okay for path lookups
env GOTOOLCHAIN=go1.20+path
! go version
stderr 'go: cannot find "go1.20" in PATH'

env GOTOOLCHAIN=go1.21+path
! go version
stderr 'go: cannot find "go1.21" in PATH'

env GOTOOLCHAIN=go1.22+path
! go version
stderr 'go: cannot find "go1.22" in PATH'

# When a toolchain download takes place, download 1.X.0
env GOTOOLCHAIN=auto
rm go.mod
go mod init m

    createTakk('do-stuff')
"""
        when:
        fails()

        then:
        failure.assertHasDescription("A problem occurred evaluating root project 'ProjectError'.")
                .assertHasCause("Could not find method createTakk() for arguments [do-stuff] on root project 'ProjectError")
                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(2)
    }

        buildFile << """
            apply plugin: 'java'
            apply plugin: 'eclipse'

            eclipse.classpath.file.whenMerged {
                entries.find { entry -> entry.path == 'src/test/java' }.output = null
                entries.find { entry -> entry.path == 'src/test/resources' }.output = 'out/test-resources'
            }
        """

        file('src/test/java').mkdirs()

Use the https://github.com/gradle/gradle-profiler[Gradle Profiler] to find these kinds of bottlenecks.
With the Gradle Profiler, you can define scenarios like "Running 'assemble' after making an ABI-breaking change"
and run your build several times to collect profiling data.
Use the Profiler to produce build scans. Or combine it with method profilers like JProfiler and YourKit.
These profilers can help you find inefficient algorithms in custom plugins.

        then:
        def allNames = project.modules*.name
        allNames.unique().size() == 6

        IdeaModule impl = project.modules.find { it.name == 'root-impl' }
        IdeaModule contribImpl = project.modules.find { it.name == 'contrib-impl' }

        impl.dependencies[0].targetModuleName == 'root-api'
        contribImpl.dependencies[0].targetModuleName == 'contrib-api'
    }

                }
            }
        """

        when:
        succeeds "loadClasses"

        then:
        def lines = output.readLines()
        if (lines.find { it == noInfoHeading }) { return }

        lines.find { it == heading } // here for nicer output if the output isn't what we expect
        def headingIndex = lines.indexOf(heading)
        def classpathSize = Integer.parseInt(lines[headingIndex + 1])

		if !strings.EqualFold(workload.Namespace, wf.Namespace) {
			return false
		}
	}

	if wf.Address != "" {
		var find bool
		for _, ip := range workload.WorkloadIPs {
			if strings.EqualFold(ip, wf.Address) {
				find = true
				break
			}
		}
		if !find {
			return false
		}
	}
	if wf.Node != "" && !strings.EqualFold(workload.Node, wf.Node) {
		return false
	}
	return true
}

using Source = PointerUnion<Operation *, BlockArgument *>;

// We use union-find algorithm to build clusters of connected operations based
// on the user provided policy. If an operation can be clustered (one of the
// user provided policies accepts it under given constraints), it will become
// a "member" that will participate in the union-find cluster construction.
//

    EXPECT_NE(explanation.find("ctrl_deps, which has 2 elements"),
              std::string::npos);
    EXPECT_NE(explanation.find("does not match expected: is empty"),
              std::string::npos);
  }
  {
    const std::string explanation =
        Explain(placeholder_d.node(), NodeWith(CtrlDeps(NodeWith())));
    EXPECT_NE(explanation.find("ctrl_deps"), std::string::npos);

            def task = testEvents.find {
                it.jvmTestKind == JvmTestKind.SUITE &&
                    (it.parent instanceof TaskOperationDescriptor) &&
                    it.parent.taskPath == path
            }
            if (task == null) {
                throw new AssertionError("Expected to find a test task $path but none was found")
            }