}

        matcher = LOCATION_PATTERN.matcher(failureText);
        while (matcher.find()) {
            fileNames.add(matcher.group(1).trim());
            lineNumbers.add(matcher.group(3));
        }

        matcher = DESCRIPTION_PATTERN.matcher(failureText);
        while (matcher.find()) {
            String problemStr = matcher.group(1);
            Problem problem = extract(problemStr);

        return find(ModelPath.path(path), type);
    }

    @Override
    public <T> T find(ModelPath path, ModelType<T> type) {
        return toType(type, get(path), "find(ModelPath, ModelType)");
    }

    private <T> T toType(ModelType<T> type, ModelNodeInternal node, String msg) {
        if (node == null) {
            return null;
        } else {

        executionIdentifications.size() == 2
        def projectTransformIdentification = executionIdentifications.find { it.artifactName == 'producer.jar' }
        def externalTransformIdentification = executionIdentifications.find { it.artifactName == 'test-4.2.jar' }

        [projectTransformIdentification, externalTransformIdentification].each {
            with(it) {

        failure.assertHasCause("""Could not find group:projectA:1.0.
Searched in the following locations:
  - ${repo1Module.pom.uri}
  - ${repo2Module.pom.uri}
Required by:
""")

        when:
        repo1Module.pom.expectGetMissing()
        repo2Module.pom.expectGetMissing()

        then:
        fails 'retrieve'

        failure.assertHasCause("""Could not find group:projectA:1.0.

    }
  }
  return absl::OkStatus();
}

Status SymbolicGradientBuilder::SumGradients(const Output& src, Output* grad) {
  auto iter = backprops_.find(src);
  if (iter == backprops_.end()) {
    return errors::Internal("Unable to find backprop list for node.id ",
                            src.node()->name());
  }
  const auto& grads = iter->second;

      host_compute_core, &fld, &shape_inference_graphs,
      &has_outside_compilation));

  // Get rewritten XLA computation function.
  std::unique_ptr<FunctionBody> xla_fbody;
  TF_CHECK_OK(FunctionDefToBodyHelper(*fld.Find("cluster_rewritten"),
                                      AttrSlice(), &fld, &xla_fbody));
  auto node_name_index = xla_fbody->graph->BuildNodeNameIndex();

  // Check XlaHostCompute nodes.

        def alternateSumFile = addFunction(sumSourceFile)
        replaceInSourceFile(toOtherSourceSet(alternateSumFile), 'include "common.h"', 'include "common2.h"').writeToDir(file("src/hello"))
    }

    def librarySourceModified(String lib="hello", String path="") {

		}
	}
	return packPallocSum(start, most, cur)
}

// find searches for npages contiguous free pages in pallocBits and returns
// the index where that run starts, as well as the index of the first free page
// it found in the search. searchIdx represents the first known free page and
// where to begin the next search from.
//
// If find fails to find any free space, it returns an index of ^uint(0) and

        expect:
        matches.size() == 6
        matches[0] == '\tat org.gradle.groovy.scripts.internal.DefaultScriptRunnerFactory$ScriptRunnerImpl.run(DefaultScriptRunnerFactory.java:93)'
    }

    def "does not find things that might look like stack traces"() {
        def output = """
* What went wrong:
A problem occurred evaluating root project '4j0h2'.
> Could not create an instance of type Thing.

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.
//