private MetadataGraphEdge cleanEdges(
            MetadataGraphVertex v, List<MetadataGraphEdge> edges, ArtifactScopeEnum scope) {
        if (edges == null || edges.isEmpty()) {
            return null;
        }

        if (edges.size() == 1) {
            MetadataGraphEdge e = edges.get(0);
            if (scope.encloses(e.getScope())) {
                return e;
            }

                "wrong # of v2 incident edges in the resulting graph after resolver");
        assertEquals(
                "1.2",
                res.getIncidentEdges(v2).get(0).getVersion(),
                "wrong edge v1-v2 in the resulting graph after resolver");

        assertEquals(
                1, res.getIncidentEdges(v3).size(), "wrong # of edges v1-v3 in the resulting graph after resolver");

      // Number of edges remaining is unknown (node's incident edges have been removed).
      AbstractGraphTest.validateGraph(graph);

      for (int i = numNodesToRemove; i < NUM_NODES; ++i) {
        assertThat(graph.removeNode(nodeList.get(i))).isTrue();
      }

      assertThat(graph.nodes()).isEmpty();
      assertThat(graph.edges()).isEmpty(); // no edges can remain if there's no nodes

        SuggestItem merged = SuggestItem.merge(item1, item2);

        // Should have all 3 kinds
        assertEquals(3, merged.getKinds().length);
        assertTrue(Arrays.asList(merged.getKinds()).contains(SuggestItem.Kind.QUERY));
        assertTrue(Arrays.asList(merged.getKinds()).contains(SuggestItem.Kind.DOCUMENT));
        assertTrue(Arrays.asList(merged.getKinds()).contains(SuggestItem.Kind.USER));
    }

        checkArgument(edges().contains(edge));
        N nodeU = edge.nodeU();
        N nodeV = edge.nodeV();
        Set<EndpointPair<N>> endpointPairIncidentEdges =
            Sets.union(incidentEdges(nodeU), incidentEdges(nodeV));
        return nodePairInvalidatableSet(
            Sets.difference(endpointPairIncidentEdges, ImmutableSet.of(edge)), nodeU, nodeV);
      }

        + nodes()
        + ", edges: "
        + edgeValueMap(this);
  }

  private static <N, V> Map<EndpointPair<N>, V> edgeValueMap(ValueGraph<N, V> graph) {
    return Maps.asMap(
        graph.edges(),
        edge ->
            // requireNonNull is safe because the endpoint pair comes from the graph.
            requireNonNull(graph.edgeValueOrDefault(edge.nodeU(), edge.nodeV(), null)));
  }

def get_individual_sponsors(
    settings: Settings,
) -> defaultdict[float, dict[str, SponsorEntity]]:
    nodes: list[SponsorshipAsMaintainerNode] = []
    edges = get_graphql_sponsor_edges(settings=settings)

    while edges:
        for edge in edges:
            nodes.append(edge.node)
        last_edge = edges[-1]

            UpgradeResult merged = result1.merge(result2);

            assertTrue(merged.success(), "Merged empty results should be successful");
            assertEquals(0, merged.processedCount(), "Merged empty results should have no processed POMs");
            assertEquals(0, merged.modifiedCount(), "Merged empty results should have no modified POMs");

      }
    };
  }

  @Override
  public @Nullable N removeInEdge(E edge, boolean isSelfLoop) {
    if (!isSelfLoop) {
      return removeOutEdge(edge);
    }
    return null;
  }

  @Override
  public N removeOutEdge(E edge) {
    N node = super.removeOutEdge(edge);
    Multiset<N> adjacentNodes = getReference(adjacentNodesReference);
    if (adjacentNodes != null) {

    ImmutableMultimap.Builder<Character, Character> graphMapBuilder = ImmutableMultimap.builder();
    for (String edge : edges) {
      checkArgument(
          edge.length() == 2, "Expecting each edge to consist of 2 characters but got %s", edge);
      char node1 = edge.charAt(0);
      char node2 = edge.charAt(1);
      graphMapBuilder.put(node1, node2);