private static void containsExactlySanityCheck(Collection<?> collection, Object... varargs) { assertThat(collection).hasSize(varargs.length); for (Object obj : varargs) { assertThat(collection).contains(obj); } assertThat(collection).containsExactly(varargs); } }
public <T extends Loser<AssertionError>> void testMethod_exceptionTypes() throws NoSuchMethodException { Method failMethod = Loser.class.getMethod("lose"); Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.method(failMethod); assertThat(invokable.getExceptionTypes()).contains(TypeToken.of(AssertionError.class)); }
@Test public void addEdge_existingNodes() { // Adding nodes initially for safety (insulating from possible future // modifications to proxy methods) addNode(N1); addNode(N2); assertThat(addEdge(N1, N2, E12)).isTrue(); assertThat(network.edges()).contains(E12); assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12); assertThat(network.edgesConnecting(N2, N1)).containsExactly(E12); }
public void testGetTypes_noSuperclass() { TypeToken<Object>.TypeSet types = new TypeToken<Object>() {}.getTypes(); assertThat(types).contains(TypeToken.of(Object.class)); assertThat(types.rawTypes()).contains(Object.class); assertThat(types.interfaces()).isEmpty(); assertThat(types.interfaces().rawTypes()).isEmpty(); assertThat(types.classes()).contains(TypeToken.of(Object.class)); assertThat(types.classes().rawTypes()).contains(Object.class); }
public void testImmutableEnumSet_fromIterable() { ImmutableSet<SomeEnum> none = Sets.immutableEnumSet(MinimalIterable.<SomeEnum>of()); assertThat(none).isEmpty(); ImmutableSet<SomeEnum> one = Sets.immutableEnumSet(MinimalIterable.of(SomeEnum.B)); assertThat(one).contains(SomeEnum.B); ImmutableSet<SomeEnum> two = Sets.immutableEnumSet(MinimalIterable.of(SomeEnum.D, SomeEnum.B)); assertThat(two).containsExactly(SomeEnum.B, SomeEnum.D).inOrder(); }
public void testFindClassesToTest_ignoreClasses() { sanityTests.ignoreClasses(Predicates.<Object>equalTo(PublicFoo.class)); assertThat(findClassesToTest(ImmutableList.of(PublicFoo.class))).isEmpty(); assertThat(findClassesToTest(ImmutableList.of(Foo.class))).contains(Foo.class); }
public void testIgnoresEqual() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 6)); rangeSet.add(Range.closed(1, 6)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closed(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.greaterThan(6)) .inOrder(); }
public void testFindClassesToTest_publicApiOnly() { sanityTests.publicApiOnly(); assertThat(findClassesToTest(ImmutableList.of(Foo.class))).isEmpty(); assertThat(findClassesToTest(ImmutableList.of(PublicFoo.class))).contains(PublicFoo.class); }
public void testIgnoresSmallerSharingLowerBound() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 6)); rangeSet.add(Range.closed(1, 4)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closed(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.greaterThan(6)) .inOrder(); }
public void testResolveType_parameterizedType() { @SuppressWarnings("rawtypes") // trying to test raw type Parameterized<?, ?, ?> parameterized = new Parameterized<TypeTokenResolutionTest, Bar, String>() {}; TypeResolver typeResolver = TypeResolver.covariantly(parameterized.getClass()); ParameterizedType resolved = (ParameterizedType) typeResolver.resolveType(parameterized.parameterizedType()); assertEquals(TypeTokenResolutionTest.class, resolved.getOwnerType()); assertEquals(Bar.class, resolved.getRawType()); assertThat(resolved.getActualTypeArguments()).asList().contains(String.class); }
public void testIgnoresSmallerSharingUpperBound() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 6)); rangeSet.add(Range.closed(3, 6)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closed(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.greaterThan(6)) .inOrder(); }
@Test public void removeEdge_nodeNotPresent() { putEdge(N1, N2); assertThat(graph.removeEdge(N1, NODE_NOT_IN_GRAPH)).isFalse(); assertThat(graph.successors(N1)).contains(N2); }
public void testTrimToSize() { ArrayListMultimap<String, Integer> multimap = ArrayListMultimap.create(); multimap.put("foo", 1); multimap.put("foo", 2); multimap.put("bar", 3); multimap.trimToSize(); assertEquals(3, multimap.size()); assertThat(multimap.get("foo")).containsExactly(1, 2).inOrder(); assertThat(multimap.get("bar")).contains(3); } }
@Test public void removeEdge_edgeNotPresent() { putEdge(N1, N2); addNode(N3); assertThat(graph.removeEdge(N1, N3)).isFalse(); assertThat(graph.successors(N1)).contains(N2); } }
public void testIgnoresSmallerSharingNoBound() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 6)); rangeSet.add(Range.open(2, 4)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closed(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.greaterThan(6)) .inOrder(); }
@AndroidIncompatible // Android runs ExampleDerivedInterfaceTester directly if it exists public void testBuildTesterRequirements_classClassConflict() throws Exception { try { FeatureUtil.buildTesterRequirements( ConflictingRequirementsExampleDerivedInterfaceTester.class); fail("Expected ConflictingRequirementsException"); } catch (ConflictingRequirementsException e) { assertThat(e.getConflicts()).contains(ExampleBaseFeature.BASE_FEATURE_1); assertEquals(ConflictingRequirementsExampleDerivedInterfaceTester.class, e.getSource()); } }
public void testRemoveEmpty() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 6)); rangeSet.remove(Range.closedOpen(3, 3)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closed(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.greaterThan(6)) .inOrder(); }
public void testMergesConnectedWithOverlap() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(1, 4)); rangeSet.add(Range.open(2, 6)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.closedOpen(1, 6)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(1), Range.atLeast(6)) .inOrder(); }
public void testRemovePartSharingLowerBound() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 5)); rangeSet.remove(Range.closedOpen(3, 5)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.singleton(5)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(5), Range.greaterThan(5)) .inOrder(); }
public void testRemovePartSharingUpperBound() { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(Range.closed(3, 5)); rangeSet.remove(Range.openClosed(3, 5)); testInvariants(rangeSet); assertThat(rangeSet.asRanges()).contains(Range.singleton(3)); assertThat(rangeSet.complement().asRanges()) .containsExactly(Range.lessThan(3), Range.greaterThan(3)) .inOrder(); }