return {ToOperation(edge->src()), edge->src_output()};
}

void TF_OperationAllInputs(TF_Operation* oper, TF_Output* inputs,
                           int max_inputs) {
  for (auto* edge : oper->node.in_edges()) {
    if (edge->dst_input() >= 0 && edge->dst_input() < max_inputs) {
      inputs[edge->dst_input()] = {ToOperation(edge->src()),
                                   edge->src_output()};
    }
  }
}

            .contains(inEdge);
        if (network.isDirected()) {
          assertThat(network.incidentNodes(inEdge).target()).isEqualTo(node);
        }
      }

      for (E outEdge : sanityCheckSet(network.outEdges(node))) {
        assertThat(network.incidentEdges(node)).contains(outEdge);

    assume().that(graphIsMutable()).isTrue();

    addNode(N2);
    Set<String> inEdges = network.inEdges(N2);
    assertThrows(UnsupportedOperationException.class, () -> inEdges.add(E12));
    addEdge(N1, N2, E12);
    assertThat(network.inEdges(N2)).containsExactlyElementsIn(inEdges);
  }

  @Override
  @Test
  public void outEdges_checkReturnedSetMutability() {

    assume().that(graphIsMutable()).isTrue();

    addNode(N2);
    Set<String> inEdges = network.inEdges(N2);
    assertThrows(UnsupportedOperationException.class, () -> inEdges.add(E12));
    addEdge(N1, N2, E12);
    assertThat(network.inEdges(N2)).containsExactlyElementsIn(inEdges);
  }

  @Override
  @Test
  public void outEdges_checkReturnedSetMutability() {

      }
    }

    // Verify edges
    for (const EdgeSpec& e : e_edges) {
      ASSERT_TRUE(a_edges.find(e) != a_edges.end())
          << "Failed to find expected edge " << e.ToString()
          << " in fdef: " << fdef.DebugString();
    }
    for (const EdgeSpec& e : c_edges) {
      ASSERT_TRUE(a_edges.find(e) != a_edges.end())
          << "Failed to find expected control edge " << e.ToString()

  public Set<E> edgesConnecting(N nodeU, N nodeV) {
    Set<E> outEdgesU = outEdges(nodeU);
    Set<E> inEdgesV = inEdges(nodeV);
    return nodePairInvalidatableSet(
        outEdgesU.size() <= inEdgesV.size()
            ? unmodifiableSet(Sets.filter(outEdgesU, connectedPredicate(nodeU, nodeV)))
            : unmodifiableSet(Sets.filter(inEdgesV, connectedPredicate(nodeV, nodeU))),
        nodeU,
        nodeV);
  }

  @Override

  public Set<E> edgesConnecting(N nodeU, N nodeV) {
    Set<E> outEdgesU = outEdges(nodeU);
    Set<E> inEdgesV = inEdges(nodeV);
    return nodePairInvalidatableSet(
        outEdgesU.size() <= inEdgesV.size()
            ? unmodifiableSet(Sets.filter(outEdgesU, connectedPredicate(nodeU, nodeV)))
            : unmodifiableSet(Sets.filter(inEdgesV, connectedPredicate(nodeV, nodeU))),
        nodeU,
        nodeV);
  }

  @Override

  @Override
  @Test
  public void inEdges_checkReturnedSetMutability() {
    addNode(N2);
    Set<String> inEdges = network.inEdges(N2);
    assertThrows(UnsupportedOperationException.class, () -> inEdges.add(E12));
    addEdge(N1, N2, E12);
    assertThat(network.inEdges(N2)).containsExactlyElementsIn(inEdges);
  }

  @Override
  @Test
  public void outEdges_checkReturnedSetMutability() {
    addNode(N1);

        }

        checkEdges(count);
    }

    private void checkEdges(int nEdges) {
        if (incidentEdges == null) {
            incidentEdges = new HashMap<>(nEdges);
        }
        if (excidentEdges == null) {
            excidentEdges = new HashMap<>(nEdges);
        }
    }
    // ------------------------------------------------------------------------

  @Override
  @Test
  public void inEdges_checkReturnedSetMutability() {
    addNode(N2);
    Set<String> inEdges = network.inEdges(N2);
    assertThrows(UnsupportedOperationException.class, () -> inEdges.add(E12));
    addEdge(N1, N2, E12);
    assertThat(network.inEdges(N2)).containsExactlyElementsIn(inEdges);
  }

  @Override
  @Test
  public void outEdges_checkReturnedSetMutability() {
    addNode(N1);