}
            }
        """

        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])

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.

		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
}

    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);

    mlir::StringRef id = aggregator_op.getId();
    auto iter = statistics_map.find(id);
    if (iter == statistics_map.end()) {
      status = absl::InternalError(
          absl::StrFormat("Calibrated data does not exist. Cannot find "
                          "statistics. value for id: %s",
                          id));
      return;
    }

        then:
        publications.publications.size() == 2

        and:
        def pub1 = publications.publications.find { it.id.group == "test.org" }
        pub1 != null
        pub1.id.name == "test-module"
        pub1.id.version == "1.1"

        and:
        def pub2 = publications.publications.find { it.id.group == "test.groupId" }
        pub2 != null
        pub2.id.name == "test-artifactId"

	fi

	for ((i = 0; i < 20; i++)); do
		test -f ${WORK_DIR}/$1/1/.minio.sys/format.json
		v1=$?
		nextInES=$(($1 + 1)) && [ $nextInES -gt 3 ] && nextInES=1
		foundFiles1=$(find ${WORK_DIR}/$1/1/ | grep -v .minio.sys | grep xl.meta | wc -l)
		foundFiles2=$(find ${WORK_DIR}/$nextInES/1/ | grep -v .minio.sys | grep xl.meta | wc -l)
		test $foundFiles1 -eq $foundFiles2
		v2=$?
		[ $v1 == 0 -a $v2 == 0 ] && return 0
		sleep 10
	done

                is KtParameter -> psi.destructuringDeclaration
                    ?: errorWithAttachment("Expected to find lambda ${KtParameter::class} with ${KtDestructuringDeclaration::class}") {
                        withPsiEntry("psi", psi)
                    }
                else -> errorWithAttachment("Expected to find ${KtDestructuringDeclaration::class} or ${KtParameter::class} but ${psi?.let { it::class }} found") {

        printReflection(result)

        val pluginsProp = schema.topLevelReceiverType.properties.find { it.name == "plugins" }

        val plugins = (result as DataObjectReflection).properties[pluginsProp]!!.value as DataObjectReflection

        val kotlinKaptPlugin = plugins.addedObjects
            .find {
                val properties = (it as? DataObjectReflection)?.properties ?: error("unexpected object")

                           classpath.entries.find { it.kind == "lib" }.entryAttributes['customkey'] = 'whenMerged'
                       }
                   }
               }
            }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        def attributes = project.classpath[0].classpathAttributes

        then: