TEST(ErrorUtilTest, StatusScopedDiagnosticHandlerWithFilter) {
  // Filtering logic is based on tensorflow::IsInternalFrameForFilename()
  // Note we are surfacing the locations that are NOT internal frames
  // so locations that fail IsInternalFrameForFilename() evaluation pass the
  // filter.

  // These locations will fail the IsInternalFrameForFilename() check so will
  // pass the filter.
  MLIRContext context;
  auto id =

    public DefaultProblemsOperationContext(
        @Nullable Details details,
        List<Location> locations,
        List<Solution> solutions,
        AdditionalData additionalData,
        @Nullable FailureContainer failure
    ) {
        this.details = details;
        this.locations = locations;
        this.solutions = solutions;
        this.additionalData = additionalData;
        this.failure = failure;

        deserialized[0].definition.id.name == "type"
        deserialized[0].definition.id.displayName == "label"
        deserialized[0].locations[0].path == "location"
        deserialized[0].locations[0].line == 1
        deserialized[0].locations[0].column == 2
        deserialized[0].locations[0].length == 3
        deserialized[0].definition.documentationLink == null
    }

    /**
     * Invalidate the given locations as they are about to be updated.
     */
    void invalidate(Iterable<String> locations);

    /**
     * Runs an action which potentially writes to the given locations.
     */
    void write(Iterable<String> locations, IoRunnable action) throws IOException;

    /**
     * Updates the cached state at the location with the snapshot.

        builder.endChildren();
    }

    private static void addLocations(TreeFormatter builder, Collection<String> locations) {
        if (locations.isEmpty()) {
            return;
        }
        builder.node("Searched in the following locations");
        builder.startChildren();

        locations.forEach(builder::node);

        builder.endChildren();
    }

    /**

      1);

  // Check the location information.
  std::vector<std::string> locations;
  for (const auto& error : collected_errors) {
    EXPECT_TRUE(error.has_location());
    locations.push_back(error.location().DebugString());
  }

  EXPECT_THAT(locations, Each(testing::HasSubstr("CALLSITELOC")));
  EXPECT_THAT(locations, Each(testing::HasSubstr(input_file)));

class ArtifactNotFoundExceptionTest extends Specification {
    def "formats message and locations"() {
        def artifactId = Stub(ComponentArtifactIdentifier) {
            getDisplayName() >> "<artifact>"
        }
        def locations = ["http://somewhere", "sftp://elsewhere"]
        def exception = new ArtifactNotFoundException(artifactId, locations)

        expect:

        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Could not find %s.", artifact.getDisplayName()));
        if (!locations.isEmpty()) {
            builder.append(String.format("%nSearched in the following locations:"));
            for (String location : locations) {
                builder.append(String.format("%n    %s", location));

    }

    private long getVersion(String location) {
        return versionHierarchyRoot.getVersion(location)
    }

    List<String> locationWithAncestors(String location) {
        (location.split('/') as List)
            .findAll {!it.empty }
            .inits().collect { "/${it.join('/')}".toString() }
    }

    private void updateVersions(String... locations) {

        List<InternalLocation> locations,
        List<InternalSolution> solutions,
        InternalAdditionalData additionalData,
        @Nullable InternalFailure failure
    ) {
        this.definition = definition;
        this.details = details;
        this.contextualLabel = contextualLabel;
        this.locations = locations;
        this.solutions = solutions;