@Test public void removeEdge_existingEdge() { putEdge(N1, N2); assertThat(graph.successors(N1)).containsExactly(N2); assertThat(graph.predecessors(N2)).containsExactly(N1); assertThat(graph.removeEdge(N1, N2)).isTrue(); assertThat(graph.removeEdge(N1, N2)).isFalse(); assertThat(graph.successors(N1)).isEmpty(); assertThat(graph.predecessors(N2)).isEmpty(); }
private static void assertTestRunnableStates(boolean[] states, TestRunnable[] testRunnables) { for (int i = 0; i < testRunnables.length; i++) { assertThat(testRunnables[i].hasRun).isEqualTo(states[i]); } }
public void testWildcardCaptured_typeVariableDeclaresTypeBound_wildcardHasNoExplicitUpperBound() throws Exception { TypeToken<Counter<?>> type = new TypeToken<Counter<?>>() {}; TypeToken<?> fieldType = type.resolveType(Counter.class.getDeclaredField("counts").getGenericType()); Type[] typeArgs = ((ParameterizedType) fieldType.getType()).getActualTypeArguments(); assertThat(typeArgs).asList().hasSize(1); TypeVariable<?> captured = (TypeVariable<?>) typeArgs[0]; assertThat(captured.getBounds()).asList().containsExactly(Number.class); assertThat(new TypeToken<List<? extends Number>>() {}.isSupertypeOf(fieldType)).isTrue(); assertThat(new TypeToken<List<? extends Iterable<?>>>() {}.isSupertypeOf(fieldType)).isFalse(); }
@Test public void addEdge_existingEdgeBetweenSameNodes() { assertThat(addEdge(N1, N2, E12)).isTrue(); ImmutableSet<String> edges = ImmutableSet.copyOf(network.edges()); assertThat(addEdge(N1, N2, E12)).isFalse(); assertThat(network.edges()).containsExactlyElementsIn(edges); assertThat(addEdge(N2, N1, E12)).isFalse(); assertThat(network.edges()).containsExactlyElementsIn(edges); }
@Test public void simpleResizeWithCenterCrop() { Request input = new Request.Builder(IMAGE_URI).resize(50, 50).centerCrop().build(); Request output = transformer.transformRequest(input); assertThat(output).isNotSameAs(input); assertThat(output.hasSize()).isFalse(); assertThat(output.centerCrop).isFalse(); String expected = Thumbor.create(HOST).buildImage(IMAGE).resize(50, 50).toUrl(); assertThat(output.uri.toString()).isEqualTo(expected); }
@Test public void testHandleNulls() { mapCache.put("foo", "bar"); mapCache.put("non-null key", null); mapCache.put(null, "non-null value"); assertThat(mapCache.get("foo")).isEqualTo("bar"); assertThat(mapCache.get("non-null key")).isNull(); assertThat(mapCache.get(null)).isEqualTo("non-null value"); assertThat(mapCache.containsKey("foo")).isTrue(); assertThat(mapCache.containsKey("bar")).isFalse(); assertThat(mapCache.containsKey("non-null key")).isTrue(); assertThat(mapCache.containsKey(null)).isTrue(); // Test again - in reverse order. assertThat(mapCache.get(null)).isEqualTo("non-null value"); assertThat(mapCache.get("non-null key")).isNull(); assertThat(mapCache.get("foo")).isEqualTo("bar"); } }
@Test public void createDirected_expectedEdgeCount() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().expectedEdgeCount(EDGE_COUNT).build(); assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty(); }
@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 addEdge_existingEdgeBetweenSameNodes() { addEdge(N1, N2, E12); ImmutableSet<String> edges = ImmutableSet.copyOf(network.edges()); assertThat(addEdge(N1, N2, E12)).isFalse(); assertThat(network.edges()).containsExactlyElementsIn(edges); }
@Test public void startSpanNullParentWithRecordEvents() { RecordEventsSpanImpl span = (RecordEventsSpanImpl) SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions) .setSampler(Samplers.neverSample()) .setRecordEvents(true) .startSpan(); assertThat(span.getContext().isValid()).isTrue(); assertThat(span.getOptions().contains(Options.RECORD_EVENTS)).isTrue(); assertThat(span.getContext().getTraceOptions().isSampled()).isFalse(); SpanData spanData = span.toSpanData(); assertThat(spanData.getParentSpanId()).isNull(); assertThat(spanData.getHasRemoteParent()).isNull(); }
@Test public void inPurgeableIfInPurgeable() { final Request request = new Request.Builder(URI_1).purgeable().build(); final BitmapFactory.Options options = createBitmapOptions(request); assertThat(options).isNotNull(); assertThat(options.inPurgeable).isTrue(); assertThat(options.inInputShareable).isTrue(); assertThat(options.inJustDecodeBounds).isFalse(); }
@Test public void removeEdge_existingSelfLoopEdge() { addEdge(N1, N1, E11); assertThat(network.removeEdge(E11)).isTrue(); assertThat(network.edges()).doesNotContain(E11); assertThat(network.edgesConnecting(N1, N1)).isEmpty(); } }
@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>"); }
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(); }
@Test public void createUndirected_multigraph() { MutableNetwork<Integer, String> undirectedMultigraph = NetworkBuilder.undirected().allowsParallelEdges(true).build(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(undirectedMultigraph.addEdge(N2, N1, E21)).isTrue(); assertThat(undirectedMultigraph.edgesConnecting(N1, N2)) .isEqualTo(ImmutableSet.of(E12, E12_A, E21)); }
static void assertStronglyEquivalent(ValueGraph<?, ?> graphA, ValueGraph<?, ?> graphB) { // Properties not covered by equals() assertThat(graphA.allowsSelfLoops()).isEqualTo(graphB.allowsSelfLoops()); assertThat(graphA.nodeOrder()).isEqualTo(graphB.nodeOrder()); assertThat(graphA).isEqualTo(graphB); }
@Test public void testGenerateKey() throws Exception { assertThat(generateKey(EMPTY)).isNotNull(); Uri testUri = Uri.parse("test"); String key = CacheUtil.generateKey(testUri); assertThat(key).isNotNull(); // Should generate the same key for the same input assertThat(generateKey(testUri)).isEqualTo(key); // Should generate different key for different input assertThat(key.equals(generateKey(parse("test2")))).isFalse(); }
/** Call this in a {@link TestSubtype} public method asserting subtype relationship. */ final <T> T isSubtype(T sub) { Type returnType = method.getGenericReturnType(); Type paramType = getOnlyParameterType(); TestSubtype spec = method.getAnnotation(TestSubtype.class); assertThat(TypeToken.of(paramType).isSubtypeOf(returnType)) .named("%s is subtype of %s", paramType, returnType) .isTrue(); assertThat(TypeToken.of(returnType).isSupertypeOf(paramType)) .named("%s is supertype of %s", returnType, paramType) .isTrue(); if (!spec.suppressGetSubtype()) { assertThat(getSubtype(returnType, TypeToken.of(paramType).getRawType())).isEqualTo(paramType); } if (!spec.suppressGetSupertype()) { assertThat(getSupertype(paramType, TypeToken.of(returnType).getRawType())) .isEqualTo(returnType); } return sub; }
@Test public void shouldHandleParamTypes() throws Exception { InvocationProfile profile = new InvocationProfile("android/view/View/invalidate(I[ZLjava/lang/String;)Lwhatever/Foo;", false, getClass().getClassLoader()); assertThat(profile.clazz).isEqualTo(View.class); assertThat(profile.methodName).isEqualTo("invalidate"); assertThat(profile.isStatic).isEqualTo(false); assertThat(profile.paramTypes).asList().containsExactly("int", "boolean[]", "java.lang.String"); } }
@Override @Test public void addEdge_selfLoop() { assertThat(addEdge(N1, N1, E11)).isTrue(); assertThat(network.edges()).contains(E11); assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11); }