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")
            }

            String failureMethodName = EXECUTION_FAILURE
            def testCase = testsFailures.find { it.name == failureMethodName }
            assert testCase

            String causeLinePrefix = "Caused by: "
            def cause = testCase.messages.first().readLines().find { it.startsWith causeLinePrefix }?.substring(causeLinePrefix.length())

            assertThat(cause, causeMatcher)

  auto signatures_iter =
      revived_objects_.signatures_map.find(signature_def_key);
  if (signatures_iter == revived_objects_.signatures_map.end()) {
    return errors::NotFound("No signature with key ", signature_def_key,
                            " was found");
  }
  int node = signatures_iter->second;

  auto function_iter = revived_objects_.signature_def_functions.find(node);

    auto new_operands = llvm::to_vector<8>(call.getOperands());
    for (int64_t i = 0; i < call.getNumOperands(); ++i) {
      auto arg_it = info.stack_var_arg_to_size_arg.find(i);
      if (arg_it == info.stack_var_arg_to_size_arg.end()) continue;
      auto it = data_var_to_size_var.find(call.getOperand(i));
      if (it == data_var_to_size_var.end()) {
        call.emitOpError("unknown stack");
        return failure();
      }

            }
            'org:bar:1.0' {
                expectGetMetadata()
            }
        }
        fails ':checkDeps'

        then:
        failure.assertHasCause("""Cannot find a version of 'org:foo' that satisfies the version constraints:
   Dependency path ':test:unspecified' --> 'org:foo:17'

		},
	},

	{
		"godoc simulation",
		"package main\n\nimport(\n    \"rand\"\n    ",
		[]string{},
	},
}

// find all occurrences of s in source; report at most n occurrences
func find(src, s string, n int) []int {
	var res []int
	if s != "" && n != 0 {
		// find at most n occurrences of s in src
		for i := -1; n < 0 || len(res) < n; {
			j := strings.Index(src[i+1:], s)
			if j < 0 {
				break

        fails "resolve"
        errorOutput.contains("Could not find method myDist() for arguments")
    }

    def "reports missing method from inside configure closure"() {
        buildFile << """
configurations {
    broken {
        noExist(12)
    }
}
"""

        expect:
        fails()

    auto to_iter = to.find(group);
    if (to_iter == to.end()) {
      ++groups_from_only;
    } else {
      auto to_branch = to_iter->second;
      if (to_branch == branch) {
        ++groups_same_branch;
      } else {
        ++groups_different_branch;
      }
    }
  }
  for (const auto& [group, _] : to) {
    auto from_iter = from.find(group);
    if (from_iter == from.end()) {

                    ) {
                        // Ignore this for now
                    } else {
                        def duplicateName = operations.find({
                            !it.failed && // ignore previous operations with the same display name that failed, eg for retry of downloads
                                it.descriptor.displayName == descriptor.displayName &&

        when:
        writeableProperty(JavaTestSubject, "myBooleanProperty", null)

        then:
        def e = thrown(NoSuchPropertyException)
        e.message == "Could not find setter method for property 'myBooleanProperty' accepting null value on class JavaTestSubject."
    }

    def "read boolean property"() {
        expect: