Java LinkedDirectedGraph.create方法代码示例

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/**
 * Tests another graph with cycles. The topology of this graph was inspired
 * by a control flow graph that was being incorrectly analyzed by an early
 * version of CheckPathsBetweenNodes.
 */
public void testCycles2() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");
  g.createDirectedGraphNode("c");
  g.createDirectedGraphNode("d");

  g.connect("a", "-", "b");
  g.connect("b", "-", "c");
  g.connect("c", "-", "b");
  g.connect("b", "-", "d");

  assertGood(createTest(g, "a", "d", Predicates.equalTo("a"), ALL_EDGE));
  assertBad(createTest(g, "a", "d", Predicates.equalTo("z"), ALL_EDGE));
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/**
 * Tests a graph where some paths between the nodes are valid and others
 * are invalid.
 */
public void testSomeValidPaths() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");
  g.createDirectedGraphNode("c");
  g.createDirectedGraphNode("d");
  g.createDirectedGraphNode("e");

  g.connect("a", "1", "b");
  g.connect("b", "2", "c");
  g.connect("b", "3", "e");
  g.connect("e", "4", "d");
  g.connect("c", "5", "d");

  assertBad(createTest(g, "a", "d", Predicates.equalTo("c"), ALL_EDGE));
  assertBad(createTest(g, "a", "d", Predicates.equalTo("z"), ALL_EDGE));
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/** Tests a graph with many valid paths. */
public void testManyValidPaths() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");
  g.createDirectedGraphNode("c1");
  g.createDirectedGraphNode("c2");
  g.createDirectedGraphNode("c3");
  DiGraphNode<String, String> d = g.createDirectedGraphNode("d");

  g.connect("a",  "-", "b");
  g.connect("b",  "-", "c1");
  g.connect("b",  "-", "c2");
  g.connect("c2", "-", "d");
  g.connect("c1", "-", "d");
  g.connect("a",  "-", "c3");
  g.connect("c3", "-", "d");

  assertGood(createTest(g, "a", "d", new PrefixPredicate("c"), ALL_EDGE));
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
@Override
public void setUp() {
  A = new Counter();
  B = new Counter();
  C = new Counter();
  D = new Counter();
  E = new Counter();

  graph = LinkedDirectedGraph.create();
  graph.createDirectedGraphNode(A);
  graph.createDirectedGraphNode(B);
  graph.createDirectedGraphNode(C);
  graph.createDirectedGraphNode(D);
  graph.createDirectedGraphNode(E);

  graph.connect(A, "->", B);
  graph.connect(A, "->", C);
  graph.connect(A, "->", D);
  graph.connect(B, "->", D);
  graph.connect(C, "->", E);
  graph.connect(D, "->", E);
  graph.connect(E, "->", D);
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/** Tests a graph with many valid paths. */
public void testManyValidPaths() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");
  g.createDirectedGraphNode("c1");
  g.createDirectedGraphNode("c2");
  g.createDirectedGraphNode("c3");
  g.createDirectedGraphNode("d");

  g.connect("a",  "-", "b");
  g.connect("b",  "-", "c1");
  g.connect("b",  "-", "c2");
  g.connect("c2", "-", "d");
  g.connect("c1", "-", "d");
  g.connect("a",  "-", "c3");
  g.connect("c3", "-", "d");

  assertGood(createTest(g, "a", "d", new PrefixPredicate("c"), ALL_EDGE));
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/**
 * Much of the tests are done by testing all paths. We quickly verified
 * that some paths are indeed correct for the some path case.
 */
public void testSomePath1() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");
  g.createDirectedGraphNode("c");
  g.createDirectedGraphNode("d");

  g.connect("a", "-", "b");
  g.connect("a", "-", "c");
  g.connect("b", "-", "d");
  g.connect("c", "-", "d");

  assertTrue(createTest(g, "a", "d", Predicates.equalTo("b"), ALL_EDGE)
      .somePathsSatisfyPredicate());
  assertTrue(createTest(g, "a", "d", Predicates.equalTo("c"), ALL_EDGE)
      .somePathsSatisfyPredicate());
  assertTrue(createTest(g, "a", "d", Predicates.equalTo("a"), ALL_EDGE)
      .somePathsSatisfyPredicate());
  assertTrue(createTest(g, "a", "d", Predicates.equalTo("d"), ALL_EDGE)
      .somePathsSatisfyPredicate());
  assertFalse(createTest(g, "a", "d", Predicates.equalTo("NONE"), ALL_EDGE)
      .somePathsSatisfyPredicate());
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
public void testGraph10() {
  // Test a graph with self-edges.
  maxChange = 5;

  A = new Counter();
  B = new Counter();

  graph = LinkedDirectedGraph.create();
  graph.createDirectedGraphNode(A);
  graph.createDirectedGraphNode(B);

  graph.connect(A, "->", A);
  graph.connect(A, "->", B);

  traversal.computeFixedPoint(graph);

  assertEquals(6, A.value);
  assertEquals(6, B.value);
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
public void testDirectedInAndOutEdges() {
  DiGraph<String, String> graph =
      LinkedDirectedGraph.create();
  graph.createNode("a");
  graph.createNode("b");
  graph.createNode("c");
  graph.createNode("d");
  graph.connect("a", "->", "b");
  graph.connect("a", "-->", "b");
  graph.connect("a", "--->", "b");
  graph.connect("a", "->", "c");
  graph.connect("c", "->", "d");
  assertSetEquals(graph.getDirectedSuccNodes("a"), "b", "c");
  assertSetEquals(graph.getDirectedPredNodes("b"), "a");
  assertSetEquals(graph.getDirectedPredNodes("c"), "a");
  assertListCount(graph.getDirectedSuccNodes("a"), "b", 3);

  // Removal.
  graph.disconnect("a", "b");
  assertFalse(graph.isConnected("a", "b"));
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/** Tests straight-line graphs. */
public void testSimple() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");
  g.createDirectedGraphNode("c");
  g.createDirectedGraphNode("d");

  g.connect("a", "-", "b");
  g.connect("b", "-", "c");
  g.connect("c", "-", "d");
  g.connect("a", "x", "d");

  // Simple case: the sole path from a to d has a matching node.
  assertGood(createTest(g, "a", "d", Predicates.equalTo("b"), edgeIs("-")));
  //Test two edge cases where satisfying node is the first and last node on
  // the path.
  assertGood(createTest(g, "a", "d", Predicates.equalTo("a"), edgeIs("-")));
  assertGood(createTest(g, "a", "d", Predicates.equalTo("d"), edgeIs("-")));

  // Traverse no edges, so no paths.
  assertGood(createTest(g, "a", "d", FALSE, NO_EDGE));

  // No path with matching edges contains b.
  assertBad(createTest(g, "a", "d", Predicates.equalTo("b"), edgeIs("x")));
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/**
 * Tests another graph with cycles. The topology of this graph was inspired
 * by a control flow graph that was being incorrectly analyzed by an early
 * version of CheckPathsBetweenNodes.
 */
public void testCycles3() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");
  g.createDirectedGraphNode("c");
  g.createDirectedGraphNode("d");

  g.connect("a", "-", "b");
  g.connect("b", "-", "c");
  g.connect("c", "-", "b");
  g.connect("b", "-", "d");
  g.connect("c", "-", "d");

  assertGood(createTest(g, "a", "d", Predicates.equalTo("a"), ALL_EDGE));
  assertBad(createTest(g, "a", "d", Predicates.equalTo("z"), ALL_EDGE));
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
/**
 * Gets a graph of the passes run. For debugging.
 */
GraphvizGraph getPassGraph() {
  LinkedDirectedGraph<String, String> graph = LinkedDirectedGraph.create();
  Iterable<PassFactory> allPasses =
      Iterables.concat(getChecks(), getOptimizations());
  String lastPass = null;
  String loopStart = null;
  for (PassFactory pass : allPasses) {
    String passName = pass.getName();
    int i = 1;
    while (graph.hasNode(passName)) {
      passName = pass.getName() + (i++);
    }
    graph.createNode(passName);

    if (loopStart == null && !pass.isOneTimePass()) {
      loopStart = passName;
    } else if (loopStart != null && pass.isOneTimePass()) {
      graph.connect(lastPass, "loop", loopStart);
      loopStart = null;
    }

    if (lastPass != null) {
      graph.connect(lastPass, "", passName);
    }
    lastPass = passName;
  }
  return graph;
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
LinkedDirectedGraph<JSModule, String> toGraphvizGraph() {
  LinkedDirectedGraph<JSModule, String> graphViz =
      LinkedDirectedGraph.create();
  for (JSModule module : getAllModules()) {
    graphViz.createNode(module);
    for (JSModule dep : module.getDependencies()) {
      graphViz.createNode(dep);
      graphViz.connect(module, "->", dep);
    }
  }
  return graphViz;
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
public void testSomePathRevisiting() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("1");
  g.createDirectedGraphNode("2a");
  g.createDirectedGraphNode("2b");
  g.createDirectedGraphNode("3");
  g.createDirectedGraphNode("4a");
  g.createDirectedGraphNode("4b");
  g.createDirectedGraphNode("5");
  g.connect("1", "-", "2a");
  g.connect("1", "-", "2b");
  g.connect("2a", "-", "3");
  g.connect("2b", "-", "3");
  g.connect("3", "-", "4a");
  g.connect("3", "-", "4b");
  g.connect("4a", "-", "5");
  g.connect("4b", "-", "5");

  CountingPredicate<String> p =
    new CountingPredicate<>(Predicates.equalTo("4a"));

  assertTrue(createTest(g, "1", "5", p, ALL_EDGE)
      .somePathsSatisfyPredicate());

  // Make sure we are not doing more traversals than we have to.
  assertEquals(4, p.count);
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
public void testSomePath2() {
  // No Paths between nodes, by definition, always false.
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("a");
  g.createDirectedGraphNode("b");

  assertFalse(createTest(g, "a", "b", Predicates.equalTo("b"), ALL_EDGE)
      .somePathsSatisfyPredicate());
  assertFalse(createTest(g, "a", "b", Predicates.equalTo("d"), ALL_EDGE)
      .somePathsSatisfyPredicate());
  assertTrue(createTest(g, "a", "b", Predicates.equalTo("a"), ALL_EDGE)
      .somePathsSatisfyPredicate());
}
 

import com.google.javascript.jscomp.graph.LinkedDirectedGraph; //导入方法依赖的package包/类
public void testSomePathRevisiting() {
  DiGraph<String, String> g = LinkedDirectedGraph.create();
  g.createDirectedGraphNode("1");
  g.createDirectedGraphNode("2a");
  g.createDirectedGraphNode("2b");
  g.createDirectedGraphNode("3");
  g.createDirectedGraphNode("4a");
  g.createDirectedGraphNode("4b");
  g.createDirectedGraphNode("5");
  g.connect("1", "-", "2a");
  g.connect("1", "-", "2b");
  g.connect("2a", "-", "3");
  g.connect("2b", "-", "3");
  g.connect("3", "-", "4a");
  g.connect("3", "-", "4b");
  g.connect("4a", "-", "5");
  g.connect("4b", "-", "5");

  CountingPredicate<String> p =
    new CountingPredicate<String>(Predicates.equalTo("4a"));

  assertTrue(createTest(g, "1", "5", p, ALL_EDGE)
      .somePathsSatisfyPredicate());

  // Make sure we are not doing more traversals than we have to.
  assertEquals(4, p.count);
}