public void testCharacterSimpleSplitWithNoDelimiter() { String simple = "a,b,c"; Iterable<String> letters = Splitter.on('.').split(simple); assertThat(letters).containsExactly("a,b,c").inOrder(); }
@Test public void testSelfLoop() { EndpointPair<String> unordered = EndpointPair.unordered("node", "node"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("node", "node"); assertThat(unordered.nodeU()).isEqualTo("node"); assertThat(unordered.nodeV()).isEqualTo("node"); assertThat(unordered.adjacentNode("node")).isEqualTo("node"); assertThat(unordered.toString()).isEqualTo("[node, node]"); }
@Test public void testOrderedEndpointPair() { EndpointPair<String> ordered = EndpointPair.ordered("source", "target"); assertThat(ordered.isOrdered()).isTrue(); assertThat(ordered).containsExactly("source", "target").inOrder(); assertThat(ordered.source()).isEqualTo("source"); assertThat(ordered.target()).isEqualTo("target"); assertThat(ordered.nodeU()).isEqualTo("source"); assertThat(ordered.nodeV()).isEqualTo("target"); assertThat(ordered.adjacentNode("source")).isEqualTo("target"); assertThat(ordered.adjacentNode("target")).isEqualTo("source"); assertThat(ordered.toString()).isEqualTo("<source -> target>"); }
@Override @Test public void addEdge_selfLoop() { assertThat(putEdge(N1, N1)).isTrue(); assertThat(graph.successors(N1)).containsExactly(N1); assertThat(graph.predecessors(N1)).containsExactly(N1); }
@Test public void copyOf_directedGraph() { Graph<Integer> directedGraph = buildDirectedGraph(); Graph<Integer> copy = copyOf(directedGraph); assertThat(copy).isEqualTo(directedGraph); }
@Test public void testPutNewValue() { assertThat(mapCache.put("key", "value")).isNull(); assertThat(mapCache.get("key")).isEqualTo("value"); // ensure key/value is cached assertThat(mapCache.put("key", "new value")).isEqualTo("value"); assertThat(mapCache.get("key")).isEqualTo("new value"); }
@Test public void edgeOrder_default() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.insertion()); assertThat(network.edges()).containsExactly("i", "e", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(ElementOrder.insertion()); // default }
@Test public void hasCycle_emptyGraph() { assertThat(hasCycle(directedGraph)).isFalse(); assertThat(hasCycle(undirectedGraph)).isFalse(); }
@Test public void addNode_newNode() { assertThat(addNode(N1)).isTrue(); assertThat(graph.nodes()).contains(N1); }
@Test public void incidentEdges_oneEdge() { addEdge(N1, N2, E12); assertThat(network.incidentEdges(N2)).containsExactly(E12); assertThat(network.incidentEdges(N1)).containsExactly(E12); }
public void testComputeIfAbsentEviction() { // b/80241237 Cache<String, String> c = CacheBuilder.newBuilder().maximumSize(1).build(); assertThat(c.asMap().computeIfAbsent("hash-1", k -> "")).isEqualTo(""); assertThat(c.asMap().computeIfAbsent("hash-1", k -> "")).isEqualTo(""); assertThat(c.asMap().computeIfAbsent("hash-1", k -> "")).isEqualTo(""); assertThat(c.size()).isEqualTo(1); assertThat(c.asMap().computeIfAbsent("hash-2", k -> "")).isEqualTo(""); }
public void testNewProxy_goodMethodWithEnoughTime() throws Exception { SampleImpl target = new SampleImpl(DELAY_MS); Sample proxy = service.newProxy(target, Sample.class, ENOUGH_MS, MILLISECONDS); Stopwatch stopwatch = Stopwatch.createStarted(); String result = proxy.sleepThenReturnInput("x"); assertThat(result).isEqualTo("x"); assertThat(stopwatch.elapsed(MILLISECONDS)).isIn(Range.closed(DELAY_MS, ENOUGH_MS)); assertThat(target.finished).isTrue(); }
@Override @Test public void addEdge_selfLoop() { assertThat(putEdge(N1, N1)).isTrue(); assertThat(graph.adjacentNodes(N1)).containsExactly(N1); }
@Test public void copyOf_undirectedGraph() { Graph<Integer> undirectedGraph = buildUndirectedGraph(); Graph<Integer> copy = copyOf(undirectedGraph); assertThat(copy).isEqualTo(undirectedGraph); }
@Test public void testRemoveEqualKeyWithDifferentReference() { String fooReference1 = new String("foo"); String fooReference2 = new String("foo"); assertThat(fooReference1).isNotSameAs(fooReference2); assertThat(mapCache.put(fooReference1, "bar")).isNull(); assertThat(mapCache.get(fooReference1)).isEqualTo("bar"); // ensure first reference is cached assertThat(mapCache.remove(fooReference2)).isEqualTo("bar"); assertThat(mapCache.get(fooReference1)).isNull(); }
@Test public void nodeOrder_default() { MutableGraph<Integer> graph = GraphBuilder.directed().build(); addNodes(graph); assertThat(graph.nodeOrder()).isEqualTo(insertion()); assertThat(graph.nodes()).containsExactly(3, 1, 4).inOrder(); }
@Test public void hasCycle_oneEdge() { for (MutableGraph<Integer> graph : graphsToTest) { graph.putEdge(1, 2); } assertThat(hasCycle(directedGraph)).isFalse(); assertThat(hasCycle(undirectedGraph)).isFalse(); }
@Test public void hasEdgeConnecting_correct() { putEdge(N1, N2); assertThat(graph.hasEdgeConnecting(EndpointPair.unordered(N1, N2))).isTrue(); assertThat(graph.hasEdgeConnecting(EndpointPair.unordered(N2, N1))).isTrue(); }
@Test public void testUnorderedEndpointPair() { EndpointPair<String> unordered = EndpointPair.unordered("chicken", "egg"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("chicken", "egg"); assertThat(ImmutableSet.of(unordered.nodeU(), unordered.nodeV())) .containsExactly("chicken", "egg"); assertThat(unordered.adjacentNode(unordered.nodeU())).isEqualTo(unordered.nodeV()); assertThat(unordered.adjacentNode(unordered.nodeV())).isEqualTo(unordered.nodeU()); assertThat(unordered.toString()).contains("chicken"); assertThat(unordered.toString()).contains("egg"); }
public void testStringSplitWithTrailingDelimiter() { String trailing = "a,b,c,"; Iterable<String> letters = Splitter.on(",").split(trailing); assertThat(letters).containsExactly("a", "b", "c", "").inOrder(); }