src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThan(final T value) { return new LessThanPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); } | @Test public void lessThan_works() { assertThat(lessThan(4)) .accepts(3) .hasDescription("less than '4'") .rejects(4) .rejects(5); assertThat(lessThan(Foo.SECOND)) .accepts(Foo.FIRST) .rejects(Foo.SECOND) .rejects(Foo.THIRD); } |
DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThan(final T value) { return new GreaterThanPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); } | @Test public void greaterThan_works() { assertThat(greaterThan(5)) .accepts(6) .hasDescription("greater than '5'") .rejects(5) .rejects(4); assertThat(greaterThan(Foo.SECOND)) .rejects(Foo.FIRST) .rejects(Foo.SECOND) .accepts(Foo.THIRD); } |
ArchUnitExtensions { public void dispatch(EvaluatedRule evaluatedRule) { for (ArchUnitExtension extension : extensionLoader.getAll()) { dispatch(evaluatedRule, extension); } } ArchUnitExtensions(); private ArchUnitExtensions(ArchUnitExtensionLoader extensionLoader); void dispatch(EvaluatedRule evaluatedRule); } | @Test public void extensions_are_configured() throws IOException { TestExtension extensionOne = new TestExtension("one"); TestExtension extensionTwo = new TestExtension("two"); when(extensionLoader.getAll()).thenReturn(ImmutableSet.<ArchUnitExtension>of(extensionOne, extensionTwo)); ArchConfiguration.get().setExtensionProperties(extensionOne.getUniqueIdentifier(), properties("enabled", "true", "one", "valueOne")); ArchConfiguration.get().setExtensionProperties(extensionTwo.getUniqueIdentifier(), properties("enabled", "true", "two", "valueTwo")); extensions.dispatch(evaluatedRule); assertThat(extensionOne.getConfiguredProperties()) .hasSize(2).containsEntry("one", "valueOne"); assertThat(extensionTwo.getConfiguredProperties()) .hasSize(2).containsEntry("two", "valueTwo"); }
@Test public void evaluated_rules_are_dispatched_after_extension_has_been_configured() { TestExtension extension = enabled(new TestExtension("test") { @Override public void handle(EvaluatedRule evaluatedRule) { assertPropertiesAreConfigured(); super.handle(evaluatedRule); } private void assertPropertiesAreConfigured() { checkNotNull(getConfiguredProperties()); } }); when(extensionLoader.getAll()).thenReturn(ImmutableSet.<ArchUnitExtension>of(extension)); extensions.dispatch(evaluatedRule); assertThat(extension.getEvaluatedRule()).isEqualTo(evaluatedRule); }
@Test public void evaluated_rules_are_dispatched_to_all_extensions() { TestExtension extensionOne = enabled(new TestExtension("one")); TestExtension extensionTwo = enabled(new TestExtension("two")); when(extensionLoader.getAll()).thenReturn(ImmutableSet.<ArchUnitExtension>of(extensionOne, extensionTwo)); extensions.dispatch(evaluatedRule); assertThat(extensionOne.getEvaluatedRule()).isEqualTo(evaluatedRule); assertThat(extensionTwo.getEvaluatedRule()).isEqualTo(evaluatedRule); }
@Test public void only_dispatches_to_enabled_extensions() { TestExtension extensionOne = newExtensionWithEnabled("one", false); TestExtension extensionTwo = newExtensionWithEnabled("two", true); when(extensionLoader.getAll()).thenReturn(ImmutableSet.<ArchUnitExtension>of(extensionOne, extensionTwo)); logTestRule.watch(ArchUnitExtensions.class, Level.DEBUG); extensions.dispatch(evaluatedRule); assertThat(extensionOne.wasNeverCalled()).as("Extension 'one' was never called").isTrue(); assertThat(extensionTwo.wasNeverCalled()).as("Extension 'two' was never called").isFalse(); logTestRule.assertLogMessage(Level.DEBUG, "Extension 'one' is disabled, skipping... (to enable this extension, configure extension.one.enabled=true)"); } |
DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> lessThanOrEqualTo(final T value) { return new LessThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); } | @Test public void lessThanOrEqualTo_works() { assertThat(lessThanOrEqualTo(5)) .accepts(4) .hasDescription("less than or equal to '5'") .accepts(5) .rejects(6); assertThat(lessThanOrEqualTo(Foo.SECOND)) .accepts(Foo.FIRST) .accepts(Foo.SECOND) .rejects(Foo.THIRD); } |
DescribedPredicate implements Predicate<T> { public static <T extends Comparable<T>> DescribedPredicate<T> greaterThanOrEqualTo(final T value) { return new GreaterThanOrEqualToPredicate<>(value); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); } | @Test public void greaterThanOrEqualTo_works() { assertThat(greaterThanOrEqualTo(5)) .accepts(6) .hasDescription("greater than or equal to '5'") .accepts(5) .rejects(4); assertThat(greaterThanOrEqualTo(Foo.SECOND)) .rejects(Foo.FIRST) .accepts(Foo.SECOND) .accepts(Foo.THIRD); } |
DescribedPredicate implements Predicate<T> { public static <T> DescribedPredicate<T> describe(String description, Predicate<? super T> predicate) { return new DescribePredicate<>(description, predicate).forSubType(); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); } | @Test public void describe_works() { Predicate<Integer> isEven = new Predicate<Integer>() { @Override public boolean apply(Integer input) { return input % 2 == 0; } }; assertThat(describe("is even", isEven)) .accepts(8) .hasDescription("is even") .accepts(4) .rejects(5); } |
DescribedPredicate implements Predicate<T> { public static DescribedPredicate<Iterable<?>> empty() { return new EmptyPredicate(); } DescribedPredicate(String description, Object... params); String getDescription(); DescribedPredicate<T> as(String description, Object... params); DescribedPredicate<T> and(final DescribedPredicate<? super T> other); DescribedPredicate<T> or(final DescribedPredicate<? super T> other); DescribedPredicate<F> onResultOf(final Function<? super F, ? extends T> function); @SuppressWarnings("unchecked") // DescribedPredicate is contravariant DescribedPredicate<U> forSubType(); @Override String toString(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysTrue(); @SuppressWarnings("unchecked") static DescribedPredicate<T> alwaysFalse(); static DescribedPredicate<T> equalTo(final T object); static DescribedPredicate<T> lessThan(final T value); static DescribedPredicate<T> greaterThan(final T value); static DescribedPredicate<T> lessThanOrEqualTo(final T value); static DescribedPredicate<T> greaterThanOrEqualTo(final T value); static DescribedPredicate<T> describe(String description, Predicate<? super T> predicate); static DescribedPredicate<T> doesNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> doNot(final DescribedPredicate<? super T> predicate); static DescribedPredicate<T> not(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<?>> empty(); static DescribedPredicate<Iterable<T>> anyElementThat(final DescribedPredicate<? super T> predicate); static DescribedPredicate<Iterable<T>> allElements(final DescribedPredicate<? super T> predicate); } | @Test public void empty_works() { assertThat(empty()) .hasDescription("empty") .accepts(Collections.emptyList()) .accepts(Collections.emptySet()) .rejects(ImmutableList.of(1)) .rejects(Collections.singleton("")); } |
PackageMatcher { @PublicAPI(usage = ACCESS) public Optional<Result> match(String aPackage) { Matcher matcher = packagePattern.matcher(aPackage); return matcher.matches() ? Optional.of(new Result(matcher)) : Optional.<Result>absent(); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean matches(String aPackage); @PublicAPI(usage = ACCESS) Optional<Result> match(String aPackage); @Override String toString(); @PublicAPI(usage = ACCESS)
static final Function<Result, List<String>> TO_GROUPS; } | @Test @DataProvider(value = { "some.arbitrary.pkg | some.arbitrary.pkg | true", "some.arbitrary.pkg | some.thing.different | false", "some..pkg | some.arbitrary.pkg | true", "some..middle..pkg | some.arbitrary.middle.more.pkg | true", "*..pkg | some.arbitrary.pkg | true", "some..* | some.arbitrary.pkg | true", "*..pkg | some.arbitrary.pkg.toomuch | false", "toomuch.some..* | some.arbitrary.pkg | false", "*..wrong | some.arbitrary.pkg | false", "some..* | wrong.arbitrary.pkg | false", "..some | some | true", "some.. | some | true", "*..some | some | false", "some..* | some | false", "..some | asome | false", "some.. | somea | false", "*.*.* | wrong.arbitrary.pkg | true", "*.*.* | wrong.arbitrary.pkg.toomuch | false", "some.arbi*.pk*.. | some.arbitrary.pkg.whatever | true", "some.arbi*.. | some.brbitrary.pkg | false", "some.*rary.*kg.. | some.arbitrary.pkg.whatever | true", "some.*rary.. | some.arbitrarz.pkg | false", "some.pkg | someepkg | false", "..pkg.. | some.random.pkg.maybe.anywhere | true", "..p.. | s.r.p.m.a | true", "*..pkg..* | some.random.pkg.maybe.anywhere | true", "*..p..* | s.r.p.m.a | true" }, splitBy = "\\|") public void match(String matcher, String target, boolean matches) { assertThat(PackageMatcher.of(matcher).matches(target)) .as("package matches") .isEqualTo(matches); } |
PackageMatcher { @PublicAPI(usage = ACCESS) public static PackageMatcher of(String packageIdentifier) { return new PackageMatcher(packageIdentifier); } private PackageMatcher(String packageIdentifier); @PublicAPI(usage = ACCESS) static PackageMatcher of(String packageIdentifier); @PublicAPI(usage = ACCESS) boolean matches(String aPackage); @PublicAPI(usage = ACCESS) Optional<Result> match(String aPackage); @Override String toString(); @PublicAPI(usage = ACCESS)
static final Function<Result, List<String>> TO_GROUPS; } | @Test public void should_reject_more_than_two_dots_in_a_row() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Package Identifier may not contain more than two '.' in a row"); PackageMatcher.of("some...pkg"); }
@Test public void should_reject_more_than_one_star_in_a_row() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Package Identifier may not contain more than one '*' in a row"); PackageMatcher.of("some**package"); }
@Test public void should_reject_capturing_with_two_dots() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Package Identifier does not support capturing via (..), use (**) instead"); PackageMatcher.of("some.(..).package"); }
@Test public void should_reject_illegal_characters() { String illegalPackageIdentifier = "some" + PackageMatcher.TWO_STAR_REGEX_MARKER + "package"; thrown.expect(IllegalArgumentException.class); thrown.expectMessage(String.format( "Package Identifier '%s' may only consist of valid java identifier parts or the symbols '.)(*'", illegalPackageIdentifier)); PackageMatcher.of(illegalPackageIdentifier); } |
PackageMatchers extends DescribedPredicate<String> { @PublicAPI(usage = ACCESS) public static PackageMatchers of(String... packageIdentifiers) { return of(ImmutableSet.copyOf(packageIdentifiers)); } private PackageMatchers(Set<String> packageIdentifiers); @PublicAPI(usage = ACCESS) static PackageMatchers of(String... packageIdentifiers); @PublicAPI(usage = ACCESS) static PackageMatchers of(Collection<String> packageIdentifiers); @Override @PublicAPI(usage = ACCESS) boolean apply(String aPackage); } | @Test public void matches_any_package() { assertThat(PackageMatchers.of("..match..", "..other..")) .accepts("foo.match.bar") .accepts("foo.other.bar") .accepts("foo.match.other.bar") .rejects("foo.bar") .rejects("matc.hother"); }
@Test public void description() { assertThat(PackageMatchers.of("..foo..", "..bar..")) .hasDescription("matches any of ['..foo..', '..bar..']"); } |
ChainableFunction implements Function<F, T> { public <E> ChainableFunction<E, T> after(final Function<? super E, ? extends F> function) { return new ChainableFunction<E, T>() { @Override public T apply(E input) { return ChainableFunction.this.apply(function.apply(input)); } }; } ChainableFunction<E, T> after(final Function<? super E, ? extends F> function); ChainableFunction<F, U> then(final Function<? super T, ? extends U> function); DescribedPredicate<F> is(DescribedPredicate<? super T> predicate); } | @Test public void after() { Integer result = plus(7).after(parseInteger()).apply("11"); assertThat(result).as("Adding 7 after parseInt('11')").isEqualTo(18); } |
ChainableFunction implements Function<F, T> { public <U> ChainableFunction<F, U> then(final Function<? super T, ? extends U> function) { return new ChainableFunction<F, U>() { @Override public U apply(F input) { return function.apply(ChainableFunction.this.apply(input)); } }; } ChainableFunction<E, T> after(final Function<? super E, ? extends F> function); ChainableFunction<F, U> then(final Function<? super T, ? extends U> function); DescribedPredicate<F> is(DescribedPredicate<? super T> predicate); } | @Test public void then() { Integer result = parseInteger().then(plus(7)).apply("11"); assertThat(result).as("parseInt('11') then adding 7").isEqualTo(18); } |
ChainableFunction implements Function<F, T> { public DescribedPredicate<F> is(DescribedPredicate<? super T> predicate) { return predicate.onResultOf(this); } ChainableFunction<E, T> after(final Function<? super E, ? extends F> function); ChainableFunction<F, U> then(final Function<? super T, ? extends U> function); DescribedPredicate<F> is(DescribedPredicate<? super T> predicate); } | @Test public void is() { assertThat(parseInteger().is(greaterThan(7))) .rejects("7") .accepts("8"); } |
Graph { Cycles<T, ATTACHMENT> findCycles() { Map<Integer, Map<Integer, Edge<T, ATTACHMENT>>> edgesByTargetIndexByOriginIndex = indexEdgesByTargetIndexByOriginIndex(nodes, outgoingEdges); JohnsonCycleFinder johnsonCycleFinder = new JohnsonCycleFinder(createPrimitiveGraph()); ImmutableList.Builder<Cycle<T, ATTACHMENT>> result = ImmutableList.builder(); JohnsonCycleFinder.Result cycles = johnsonCycleFinder.findCycles(); for (int[] rawCycle : cycles) { result.add(mapToCycle(edgesByTargetIndexByOriginIndex, rawCycle)); } return new Cycles<>(result.build(), cycles.maxNumberOfCyclesReached()); } @Override String toString(); } | @Test public void multiple_cycles_are_detected() { Graph<String, String> graph = new Graph<>(); Cycle<String, String> threeElements = randomCycle(3); Cycle<String, String> fourElements = randomCycle(4); Cycle<String, String> fiveElements = randomCycle(5); addCycles(graph, threeElements, fourElements, fiveElements); addCrossLink(graph, threeElements, fourElements); addCrossLink(graph, fourElements, fiveElements); Collection<Cycle<String, String>> cycles = graph.findCycles(); assertThat(cycles).containsOnly(threeElements, fourElements, fiveElements); }
@Test public void complete_graph() { Graph<Integer, Integer> completeGraph = createCompleteGraph(3); Iterable<Cycle<Integer, Integer>> cycles = completeGraph.findCycles(); assertThat(cycles).containsOnly(createCycle(ImmutableList.of(0, 1, 2, 0)), createCycle(ImmutableList.of(0, 2, 1, 0)), createCycle(ImmutableList.of(0, 1, 0)), createCycle(ImmutableList.of(1, 2, 1)), createCycle(ImmutableList.of(2, 0, 2))); }
@Test public void finds_cycles_in_real_life_graph() { Graph<Integer, Object> graph = RealLifeGraph.get(); int expectedNumberOfCycles = 10000; ArchConfiguration.get().setProperty(MAX_NUMBER_OF_CYCLES_TO_DETECT_PROPERTY_NAME, String.valueOf(expectedNumberOfCycles)); Cycles<Integer, Object> cycles = graph.findCycles(); assertThat(cycles).hasSize(expectedNumberOfCycles); assertThat(cycles.maxNumberOfCyclesReached()).as("maximum number of cycles reached").isTrue(); } |
Slices implements DescribedIterable<Slice>, CanOverrideDescription<Slices> { @PublicAPI(usage = ACCESS) public static Transformer matching(String packageIdentifier) { PackageMatchingSliceIdentifier sliceIdentifier = new PackageMatchingSliceIdentifier(packageIdentifier); String description = "slices matching " + sliceIdentifier.getDescription(); return new Transformer(sliceIdentifier, description); } private Slices(Iterable<Slice> slices); private Slices(Iterable<Slice> slices, String description); @Override Iterator<Slice> iterator(); @Override Slices as(String description); @Override String getDescription(); @PublicAPI(usage = ACCESS) Slices namingSlices(String pattern); @PublicAPI(usage = ACCESS) static Transformer matching(String packageIdentifier); @PublicAPI(usage = ACCESS) static Transformer assignedFrom(SliceAssignment sliceAssignment); } | @Test public void matches_slices() { JavaClasses classes = importClassesWithContext(Object.class, String.class, List.class, Set.class, Pattern.class); assertThat(Slices.matching("java.(*)..").transform(classes)).hasSize(2); assertThat(Slices.matching("(**)").transform(classes)).hasSize(3); assertThat(Slices.matching("java.(**)").transform(classes)).hasSize(3); assertThat(Slices.matching("java.(*).(*)").transform(classes)).hasSize(1); }
@Test public void default_naming_slices() { JavaClasses classes = importClassesWithContext(Object.class, String.class, Pattern.class); DescribedIterable<Slice> slices = Slices.matching("java.(*)..").transform(classes); assertThat(slices).extractingResultOf("getDescription").containsOnly("Slice lang", "Slice util"); }
@Test public void name_parts_are_resolved_correctly() { JavaClasses classes = importClassesWithContext(Object.class); DescribedIterable<Slice> slices = Slices.matching("(*).(*)..").transform(classes); assertThat(getOnlyElement(slices).getNamePart(1)).isEqualTo("java"); assertThat(getOnlyElement(slices).getNamePart(2)).isEqualTo("lang"); }
@Test public void slices_of_dependencies() { JavaMethod methodThatCallsJavaUtil = TestUtils.importClassWithContext(Object.class).getMethod("toString"); JavaMethod methodThatCallsJavaLang = TestUtils.importClassWithContext(Map.class).getMethod("put", Object.class, Object.class); simulateCall().from(methodThatCallsJavaUtil, 5).to(methodThatCallsJavaLang); simulateCall().from(methodThatCallsJavaLang, 1).to(methodThatCallsJavaUtil); Dependency first = dependencyFrom(getOnlyElement(methodThatCallsJavaUtil.getMethodCallsFromSelf())); Dependency second = dependencyFrom(getOnlyElement(methodThatCallsJavaLang.getMethodCallsFromSelf())); Slices slices = Slices.matching("java.(*)..").transform(ImmutableSet.of(first, second)); assertThat(slices).extractingResultOf("getDescription").containsOnly("Slice lang", "Slice util"); } |
Cycle { List<Edge<T, ATTACHMENT>> getEdges() { return path.getEdges(); } Cycle(List<Edge<T, ATTACHMENT>> edges); Cycle(Path<T, ATTACHMENT> path); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static Cycle<T, ATTACHMENT> from(Path<T, ATTACHMENT> path); } | @Test public void minimal_nontrivial_cycle() { String nodeA = "Node-A"; String nodeB = "Node-B"; Cycle<String, ?> cycle = new Cycle<>(asList(stringEdge(nodeA, nodeB), stringEdge(nodeB, nodeA))); assertThat(cycle.getEdges()).hasSize(2); } |
SliceIdentifier { @PublicAPI(usage = ACCESS) public static SliceIdentifier of(String... parts) { return of(ImmutableList.copyOf(parts)); } private SliceIdentifier(List<String> parts); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static SliceIdentifier of(String... parts); @PublicAPI(usage = ACCESS) static SliceIdentifier of(List<String> parts); @PublicAPI(usage = ACCESS) static SliceIdentifier ignore(); } | @Test public void rejects_null() { thrown.expect(NullPointerException.class); SliceIdentifier.of((String[]) null); }
@Test public void rejects_null_list() { thrown.expect(NullPointerException.class); SliceIdentifier.of((List<String>) null); }
@Test public void rejects_empty_parts() { expectEmptyPartsException(); SliceIdentifier.of(); }
@Test public void rejects_empty_parts_list() { expectEmptyPartsException(); SliceIdentifier.of(Collections.<String>emptyList()); } |
Slice extends ForwardingSet<JavaClass> implements HasDescription, CanOverrideDescription<Slice> { @PublicAPI(usage = ACCESS) public Set<Dependency> getDependenciesFromSelf() { ImmutableSet.Builder<Dependency> result = ImmutableSet.builder(); for (JavaClass javaClass : this) { for (Dependency dependency : javaClass.getDirectDependenciesFromSelf()) { if (isNotAssignedToOwnSlice(dependency.getTargetClass())) { result.add(dependency); } } } return result.build(); } private Slice(SliceAssignment sliceAssignment, List<String> matchingGroups, Set<JavaClass> classes); private Slice(SliceAssignment sliceAssignment, List<String> matchingGroups, Description description,
Set<JavaClass> classes); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) Slice as(String pattern); @PublicAPI(usage = ACCESS) Set<Dependency> getDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDependenciesToSelf(); @PublicAPI(usage = ACCESS) String getNamePart(int index); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); } | @Test public void dependencies_from_self() { Slice slice = getSlice(slicesOfTestClasses(), "first"); assertThatDependencies(slice.getDependenciesFromSelf()).containOnly( from(FirstAnyPkgClass.class).to(Object.class) .from(FirstAnyPkgClass.class).to(SomePkgSubClass.class) .from(FirstAnyPkgClass.class).to(SecondThreeAnyClass.class) .from(ClassOnlyDependentOnOwnPackageAndObject.class).to(Object.class) .from(FirstThreeAnyClass.class).to(Object.class) .from(FirstThreeAnyClass.class).to(SecondThreeAnyClass.class) ); } |
Slice extends ForwardingSet<JavaClass> implements HasDescription, CanOverrideDescription<Slice> { @PublicAPI(usage = ACCESS) public Set<Dependency> getDependenciesToSelf() { ImmutableSet.Builder<Dependency> result = ImmutableSet.builder(); for (JavaClass javaClass : this) { for (Dependency dependency : javaClass.getDirectDependenciesToSelf()) { if (isNotAssignedToOwnSlice(dependency.getOriginClass())) { result.add(dependency); } } } return result.build(); } private Slice(SliceAssignment sliceAssignment, List<String> matchingGroups, Set<JavaClass> classes); private Slice(SliceAssignment sliceAssignment, List<String> matchingGroups, Description description,
Set<JavaClass> classes); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) Slice as(String pattern); @PublicAPI(usage = ACCESS) Set<Dependency> getDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDependenciesToSelf(); @PublicAPI(usage = ACCESS) String getNamePart(int index); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); } | @Test public void dependencies_to_self() { Slice slice = getSlice(slicesOfTestClasses(), "first"); assertThatDependencies(slice.getDependenciesToSelf()).containOnly( from(SecondAnyClass.class).to(FirstAnyPkgClass.class) .from(SomePkgSubClass.class).to(FirstAnyPkgClass.class) ); } |
Edge { @Override public int hashCode() { return hashCode; } Edge(T from, T to, Collection<ATTACHMENT> attachments); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); } | @Test public void hashCode_of_two_equal_edges_is_equal() { Edge<Object, Object> equalEdge = new Edge<>(from, to, singletonList(new Object())); assertThat(new Edge<>(from, to, emptySet()).hashCode()).isEqualTo(equalEdge.hashCode()); } |
Architectures { @PublicAPI(usage = ACCESS) public static LayeredArchitecture layeredArchitecture() { return new LayeredArchitecture(); } private Architectures(); @PublicAPI(usage = ACCESS) static LayeredArchitecture layeredArchitecture(); @PublicAPI(usage = ACCESS) static OnionArchitecture onionArchitecture(); } | @Test public void layered_architecture_overridden_description() { LayeredArchitecture architecture = layeredArchitecture() .layer("One").definedBy("some.pkg..") .whereLayer("One").mayNotBeAccessedByAnyLayer() .as("overridden"); assertThat(architecture.getDescription()).isEqualTo("overridden"); }
@Test public void layered_architecture_because_clause() { ArchRule architecture = layeredArchitecture() .layer("One").definedBy("some.pkg..") .whereLayer("One").mayNotBeAccessedByAnyLayer() .as("overridden") .because("some reason"); assertThat(architecture.getDescription()).isEqualTo("overridden, because some reason"); }
@Test public void layered_architecture_defining_constraint_on_non_existing_target_layer_is_rejected() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("no layer"); thrown.expectMessage("NotThere"); layeredArchitecture() .layer("Some").definedBy("any") .whereLayer("NotThere").mayNotBeAccessedByAnyLayer(); }
@Test public void layered_architecture_defining_constraint_on_non_existing_origin_is_rejected() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("no layer"); thrown.expectMessage("NotThere"); layeredArchitecture() .layer("Some").definedBy("any") .whereLayer("Some").mayOnlyBeAccessedByLayers("NotThere"); }
@Test public void layered_architecture_allows_individual_empty_optionalLayer() { LayeredArchitecture architecture = layeredArchitecture() .optionalLayer("can be absent").definedBy(absolute("should.not.be.found..")); JavaClasses classes = new ClassFileImporter().importPackages(absolute("")); EvaluationResult result = architecture.evaluate(classes); assertThat(result.hasViolation()).as("result of evaluating empty optionalLayer has violation").isFalse(); assertThat(result.getFailureReport().isEmpty()).as("failure report").isTrue(); }
@Test public void layered_architecture_combines_multiple_ignores() { JavaClasses classes = new ClassFileImporter().importClasses( FirstAnyPkgClass.class, SomePkgSubClass.class, SecondThreeAnyClass.class, SomePkgClass.class); LayeredArchitecture layeredArchitecture = layeredArchitecture() .layer("One").definedBy(absolute("some.pkg..")) .whereLayer("One").mayNotBeAccessedByAnyLayer() .ignoreDependency(FirstAnyPkgClass.class, SomePkgSubClass.class); assertThat(layeredArchitecture.evaluate(classes).hasViolation()).as("result has violation").isTrue(); layeredArchitecture = layeredArchitecture .ignoreDependency(SecondThreeAnyClass.class, SomePkgClass.class); assertThat(layeredArchitecture.evaluate(classes).hasViolation()).as("result has violation").isFalse(); } |
Architectures { @PublicAPI(usage = ACCESS) public static OnionArchitecture onionArchitecture() { return new OnionArchitecture(); } private Architectures(); @PublicAPI(usage = ACCESS) static LayeredArchitecture layeredArchitecture(); @PublicAPI(usage = ACCESS) static OnionArchitecture onionArchitecture(); } | @Test public void onion_architecture_description() { OnionArchitecture architecture = onionArchitecture() .domainModels("onionarchitecture.domain.model..") .domainServices("onionarchitecture.domain.service..") .applicationServices("onionarchitecture.application..") .adapter("cli", "onionarchitecture.adapter.cli..") .adapter("persistence", "onionarchitecture.adapter.persistence..") .adapter("rest", "onionarchitecture.adapter.rest.command..", "onionarchitecture.adapter.rest.query.."); assertThat(architecture.getDescription()).isEqualTo( "Onion architecture consisting of" + lineSeparator() + "domain models ('onionarchitecture.domain.model..')" + lineSeparator() + "domain services ('onionarchitecture.domain.service..')" + lineSeparator() + "application services ('onionarchitecture.application..')" + lineSeparator() + "adapter 'cli' ('onionarchitecture.adapter.cli..')" + lineSeparator() + "adapter 'persistence' ('onionarchitecture.adapter.persistence..')" + lineSeparator() + "adapter 'rest' ('onionarchitecture.adapter.rest.command..', 'onionarchitecture.adapter.rest.query..')" ); }
@Test public void onion_architecture_description_with_missing_layers() { OnionArchitecture architecture = onionArchitecture(); assertThat(architecture.getDescription()).isEqualTo("Onion architecture consisting of"); }
@Test public void onion_architecture_overridden_description() { OnionArchitecture architecture = onionArchitecture() .domainModels("onionarchitecture.domain.model..") .domainServices("onionarchitecture.domain.service..") .applicationServices("onionarchitecture.application..") .adapter("cli", "onionarchitecture.adapter.cli..") .adapter("persistence", "onionarchitecture.adapter.persistence..") .adapter("rest", "onionarchitecture.adapter.rest.command..", "onionarchitecture.adapter.rest.query..") .as("overridden"); assertThat(architecture.getDescription()).isEqualTo("overridden"); }
@Test public void onion_architecture_because_clause() { ArchRule architecture = onionArchitecture() .domainModels("onionarchitecture.domain.model..") .domainServices("onionarchitecture.domain.service..") .applicationServices("onionarchitecture.application..") .adapter("cli", "onionarchitecture.adapter.cli..") .adapter("persistence", "onionarchitecture.adapter.persistence..") .adapter("rest", "onionarchitecture.adapter.rest.command..", "onionarchitecture.adapter.rest.query..") .as("overridden") .because("some reason"); assertThat(architecture.getDescription()).isEqualTo("overridden, because some reason"); } |
ArchUnitExtensionLoader { Iterable<ArchUnitExtension> getAll() { return extensions.get(); } } | @Test public void loads_a_single_extension() throws IOException { testServicesFile.addService(TestExtension.class); Iterable<ArchUnitExtension> extensions = extensionLoader.getAll(); assertThat(getOnlyElement(extensions)).isInstanceOf(TestExtension.class); }
@Test public void caches_loaded_extensions() { testServicesFile.addService(TestExtension.class); Iterable<ArchUnitExtension> first = extensionLoader.getAll(); Iterable<ArchUnitExtension> second = extensionLoader.getAll(); assertThat(first).usingElementComparator(sameInstance()).hasSameElementsAs(second); }
@Test public void loads_multiple_extensions() throws IOException { testServicesFile.addService(TestExtension.class); testServicesFile.addService(DummyTestExtension.class); testServicesFile.addService(YetAnotherDummyTestExtension.class); Iterable<ArchUnitExtension> extensions = extensionLoader.getAll(); assertThat(extensions) .hasSize(3) .hasAtLeastOneElementOfType(TestExtension.class) .hasAtLeastOneElementOfType(DummyTestExtension.class) .hasAtLeastOneElementOfType(YetAnotherDummyTestExtension.class); }
@Test public void rejects_null_extension_identifier() { testServicesFile.addService(TestExtensionWithNullIdentifier.class); thrown.expect(ExtensionLoadingException.class); thrown.expectMessage("identifier"); thrown.expectMessage("null"); thrown.expectMessage(containingWord(TestExtensionWithNullIdentifier.class.getName())); extensionLoader.getAll(); }
@Test public void rejects_illegal_characters_in_extension_identifier() { testServicesFile.addService(TestExtensionWithIllegalIdentifier.class); thrown.expect(ExtensionLoadingException.class); thrown.expectMessage("identifier"); thrown.expectMessage("'.'"); thrown.expectMessage(containingWord(TestExtensionWithIllegalIdentifier.class.getName())); extensionLoader.getAll(); }
@Test public void rejects_non_unique_extension_identifier() { testServicesFile.addService(TestExtension.class); testServicesFile.addService(TestExtensionWithSameIdentifier.class); thrown.expect(ExtensionLoadingException.class); thrown.expectMessage("must be unique"); thrown.expectMessage(TestExtension.UNIQUE_IDENTIFIER); thrown.expectMessage(containingWord(TestExtension.class.getName())); thrown.expectMessage(containingWord(TestExtensionWithSameIdentifier.class.getName())); extensionLoader.getAll(); }
@Test public void logs_discovered_extensions() { testServicesFile.addService(TestExtension.class); testServicesFile.addService(DummyTestExtension.class); logTestRule.watch(ArchUnitExtensionLoader.class, Level.INFO); extensionLoader.getAll(); logTestRule.assertLogMessage(Level.INFO, expectedExtensionLoadedMessage(TestExtension.UNIQUE_IDENTIFIER)); logTestRule.assertLogMessage(Level.INFO, expectedExtensionLoadedMessage(DummyTestExtension.UNIQUE_IDENTIFIER)); } |
ConditionEvents implements Iterable<ConditionEvent> { @PublicAPI(usage = ACCESS, state = EXPERIMENTAL) public void handleViolations(ViolationHandler<?> violationHandler) { ConditionEvent.Handler eventHandler = convertToEventHandler(violationHandler); for (final ConditionEvent event : eventsByViolation.get(Type.VIOLATION)) { event.handleWith(eventHandler); } } @PublicAPI(usage = ACCESS) ConditionEvents(); @PublicAPI(usage = ACCESS) void add(ConditionEvent event); @PublicAPI(usage = ACCESS) void setInformationAboutNumberOfViolations(String informationAboutNumberOfViolations); @PublicAPI(usage = ACCESS) Collection<ConditionEvent> getViolating(); @PublicAPI(usage = ACCESS) Collection<ConditionEvent> getAllowed(); @PublicAPI(usage = ACCESS) boolean containViolation(); @PublicAPI(usage = ACCESS) boolean isEmpty(); @Deprecated @PublicAPI(usage = ACCESS) List<String> getFailureDescriptionLines(); @PublicAPI(usage = ACCESS) FailureMessages getFailureMessages(); @PublicAPI(usage = ACCESS, state = EXPERIMENTAL) void handleViolations(ViolationHandler<?> violationHandler); @Override @PublicAPI(usage = ACCESS) Iterator<ConditionEvent> iterator(); @Override String toString(); } | @Test public void handleViolations_reports_only_violations_referring_to_the_correct_type() { ConditionEvents events = events( SimpleConditionEvent.satisfied(new CorrectType("do not handle"), "I'm not violated"), SimpleConditionEvent.violated(new WrongType(), "I'm violated, but wrong type"), SimpleConditionEvent.violated(new WrongSuperType(), "I'm violated, but wrong type"), SimpleConditionEvent.violated(new CorrectType("handle type"), "I'm violated and correct type"), SimpleConditionEvent.violated(new CorrectSubType("handle sub type"), "I'm violated and correct sub type")); final Set<String> handledFailures = new HashSet<>(); events.handleViolations(new ObjectToStringAndMessageJoiningTestHandler(handledFailures)); assertThat(handledFailures).containsOnly( "handle type: I'm violated and correct type", "handle sub type: I'm violated and correct sub type"); handledFailures.clear(); events.handleViolations(new ViolationHandler<CorrectType>() { @Override public void handle(Collection<CorrectType> violatingObject, String message) { new ObjectToStringAndMessageJoiningTestHandler(handledFailures).handle(violatingObject, message); } }); assertThat(handledFailures).containsOnly( "handle type: I'm violated and correct type", "handle sub type: I'm violated and correct sub type"); }
@Test public void handles_erased_generics_as_upper_bound() { ConditionEvents events = events( SimpleConditionEvent.violated(new CorrectType("ignore"), "correct"), SimpleConditionEvent.violated(new WrongType(), "wrong")); Set<String> handledFailureMessages = new HashSet<>(); events.handleViolations(genericBoundByCorrectType(handledFailureMessages)); assertThat(handledFailureMessages).containsOnly("correct"); handledFailureMessages = new HashSet<>(); events.handleViolations(unboundGeneric(handledFailureMessages)); assertThat(handledFailureMessages).containsOnly("correct", "wrong"); }
@Test public void can_handle_with_generic_superclasses() { ConditionEvents events = events( SimpleConditionEvent.violated(new Object(), "ignore"), SimpleConditionEvent.violated("correct", "ignore")); StringHandler handler = new StringHandler(); events.handleViolations(handler); assertThat(handler.getRecorded()).containsOnly("correct"); } |
JavaClassDiagramAssociation { Set<String> getPackageIdentifiersFromComponentOf(JavaClass javaClass) { return getPackageIdentifiersFromComponentOf(getComponentOf(javaClass)); } JavaClassDiagramAssociation(PlantUmlDiagram diagram); } | @Test public void get_package_identifier_associated_with_class() { String expectedPackageIdentifier = SomeOriginClass.class.getPackage().getName().replaceAll(".*\\.", ".."); JavaClassDiagramAssociation javaClassDiagramAssociation = createAssociation(TestDiagram.in(temporaryFolder) .component("A").withStereoTypes(expectedPackageIdentifier) .component("B").withStereoTypes("..noclasshere") .write()); JavaClass clazz = importClassWithContext(SomeOriginClass.class); assertThat(javaClassDiagramAssociation.getPackageIdentifiersFromComponentOf(clazz)) .as("package identifiers of " + clazz.getName()) .containsOnly(expectedPackageIdentifier); } |
JavaClassDiagramAssociation { Set<String> getTargetPackageIdentifiers(final JavaClass javaClass) { ImmutableSet.Builder<String> result = ImmutableSet.builder(); for (PlantUmlComponent target : getComponentOf(javaClass).getDependencies()) { result.addAll(getPackageIdentifiersFromComponentOf(target)); } return result.build(); } JavaClassDiagramAssociation(PlantUmlDiagram diagram); } | @Test public void get_target_package_identifiers_of_class() { String expectedTarget1 = "..target1"; String expectedTarget2 = "..target2"; JavaClassDiagramAssociation javaClassDiagramAssociation = createAssociation(TestDiagram.in(temporaryFolder) .component("A").withStereoTypes(SomeOriginClass.class.getPackage().getName().replaceAll(".*\\.", "..")) .component("B").withStereoTypes(expectedTarget1) .component("C").withStereoTypes(expectedTarget2) .dependencyFrom("[A]").to("[B]") .dependencyFrom("[A]").to("[C]") .write()); JavaClass clazz = importClassWithContext(SomeOriginClass.class); assertThat(javaClassDiagramAssociation.getTargetPackageIdentifiers(clazz)) .as("package identifiers of " + clazz.getName()) .containsOnly(expectedTarget1, expectedTarget2); }
@Test public void rejects_class_not_contained_in_any_component() { JavaClassDiagramAssociation javaClassDiagramAssociation = createAssociation(TestDiagram.in(temporaryFolder) .component("SomeComponent").withStereoTypes("..someStereotype.") .write()); JavaClass classNotContained = importClassWithContext(Object.class); thrown.expect(IllegalStateException.class); thrown.expectMessage(String.format("Class %s is not contained in any component", Object.class.getName())); javaClassDiagramAssociation.getTargetPackageIdentifiers(classNotContained); }
@Test public void class_resides_in_multiple_packages() { JavaClassDiagramAssociation javaClassDiagramAssociation = createAssociation(TestDiagram.in(temporaryFolder) .component("A").withStereoTypes("..foopackage..") .component("B").withStereoTypes("..barpackage") .write()); JavaClass classContainedInTwoComponents = importClassWithContext(ClassInFooAndBarPackage.class); thrown.expect(ComponentIntersectionException.class); thrown.expectMessage(String.format( "Class %s may not be contained in more than one component, but is contained in [A, B]", ClassInFooAndBarPackage.class.getName())); javaClassDiagramAssociation.getTargetPackageIdentifiers(classContainedInTwoComponents); } |
JavaClassDiagramAssociation { boolean contains(JavaClass javaClass) { return !getAssociatedComponents(javaClass).isEmpty(); } JavaClassDiagramAssociation(PlantUmlDiagram diagram); } | @Test public void reports_if_class_is_contained_in_any_component() { JavaClassDiagramAssociation javaClassDiagramAssociation = createAssociation(TestDiagram.in(temporaryFolder) .component("Object").withStereoTypes(Object.class.getPackage().getName()) .write()); assertThat(javaClassDiagramAssociation.contains(importClassWithContext(Object.class))) .as("association contains " + Object.class.getName()).isTrue(); assertThat(javaClassDiagramAssociation.contains(importClassWithContext(File.class))) .as("association contains " + File.class.getName()).isFalse(); } |
PlantUmlParser { private PlantUmlDiagram createDiagram(List<String> rawDiagramLines) { List<String> diagramLines = filterOutComments(rawDiagramLines); Set<PlantUmlComponent> components = parseComponents(diagramLines); PlantUmlComponents plantUmlComponents = new PlantUmlComponents(components); List<ParsedDependency> dependencies = parseDependencies(plantUmlComponents, diagramLines); return new PlantUmlDiagram.Builder(plantUmlComponents) .withDependencies(dependencies) .build(); } } | @Test public void parses_correct_number_of_components() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin..") .component("SomeTarget").withStereoTypes("..target..") .write()); assertThat(diagram.getAllComponents()).hasSize(2); }
@Test public void parses_a_simple_component() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin..") .write()); PlantUmlComponent origin = getComponentWithName("SomeOrigin", diagram); assertThat(getOnlyElement(origin.getStereotypes())).as("Stereotype") .isEqualTo(new Stereotype("..origin..")); assertThat(origin.getAlias().isPresent()).as("alias is present").isFalse(); }
@Test @UseDataProvider("simple_diagrams") public void parses_dependency_of_simple_component_diagram(Function<TestDiagram, TestDiagram> testCase) { TestDiagram initialDiagram = TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin..") .component("SomeTarget").withStereoTypes("..target.."); PlantUmlDiagram diagram = createDiagram(testCase.apply(initialDiagram).write()); PlantUmlComponent origin = getComponentWithName("SomeOrigin", diagram); PlantUmlComponent target = getOnlyElement(origin.getDependencies()); assertThat(target.getComponentName()).as("dependency component name").isEqualTo(new ComponentName("SomeTarget")); assertThat(target.getDependencies()).as("dependency component's dependencies").isEmpty(); assertThat(getOnlyElement(target.getStereotypes())).as("dependency component's stereotype") .isEqualTo(new Stereotype("..target..")); assertThat(target.getAlias()).as("dependency component's alias is present").isAbsent(); }
@Test @UseDataProvider("dependency_arrow_testcases") public void parses_various_types_of_dependency_arrows(String dependency) { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin..") .component("SomeTarget").withStereoTypes("..target..") .rawLine(dependency) .write()); PlantUmlComponent target = getOnlyElement(getComponentWithName("SomeOrigin", diagram).getDependencies()); assertThat(target.getComponentName()) .as("dependency component name") .isEqualTo(new ComponentName("SomeTarget")); }
@Test public void does_not_include_commented_out_lines() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("uncommentedComponent").withAlias("uncommentedAlias").withStereoTypes("..uncommentedPackage..") .rawLine(" ' [commentedComponent] <<..commentedPackage..>> as commentedAlias") .rawLine("") .rawLine(" ' [uncommentedComponent] --> [commentedComponent]") .write()); PlantUmlComponent uncommentedComponent = getComponentWithName("uncommentedComponent", diagram); assertThat(getOnlyElement(diagram.getAllComponents())).isEqualTo(uncommentedComponent); assertThat(uncommentedComponent.getDependencies().isEmpty()).isTrue(); }
@Test public void does_not_include_dependency_descriptions() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("component").withStereoTypes("..somePackage..") .component("otherComponent").withStereoTypes("..somePackage2..") .rawLine("[component] --> [otherComponent] : this part should be ignored, no matter the comment tick ' ") .write()); PlantUmlComponent component = getComponentWithName("component", diagram); PlantUmlComponent targetOfDescribedDependency = getOnlyElement(component.getDependencies()); assertThat(targetOfDescribedDependency.getComponentName()) .as("target of dependency with description") .isEqualTo(new ComponentName("otherComponent")); }
@Test public void throws_exception_with_components_that_are_not_yet_defined() { File file = TestDiagram.in(temporaryFolder) .dependencyFrom("[NotYetDefined]").to("[AlsoNotYetDefined]") .write(); thrown.expect(IllegalDiagramException.class); thrown.expectMessage("There is no Component with name or alias = 'NotYetDefined'"); thrown.expectMessage("Components must be specified separately from dependencies"); createDiagram(file); }
@Test public void throws_exception_with_components_without_stereotypes() { File file = TestDiagram.in(temporaryFolder) .rawLine("[componentWithoutStereotype]") .write(); thrown.expect(IllegalDiagramException.class); thrown.expectMessage("componentWithoutStereotype"); thrown.expectMessage("at least one stereotype specifying the package identifier(<<..>>)"); createDiagram(file); }
@Test public void parses_two_identical_components_no_dependency() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("someName").withAlias("someAlias").withStereoTypes("someStereotype") .component("someName").withAlias("someAlias").withStereoTypes("someStereotype") .write()); assertThat(diagram.getAllComponents()).containsOnly(getComponentWithName("someName", diagram)); }
@Test public void rejects_a_component_with_an_illegal_alias() { File file = TestDiagram.in(temporaryFolder) .component("irrelevant").withAlias("ill[]egal").withStereoTypes("..irrelevant..") .write(); thrown.expect(IllegalDiagramException.class); thrown.expectMessage("Alias 'ill[]egal' should not contain character(s): '[' or ']' or '\"'"); createDiagram(file); }
@Test public void parses_a_tricky_alias() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("tricky").withAlias("because it's quoted").withStereoTypes("..tricky..") .component("tricky as hell cause of as keyword").withAlias("other").withStereoTypes("..other..") .write()); PlantUmlComponent trickyAsHell = getComponentWithName("tricky as hell cause of as keyword", diagram); PlantUmlComponent tricky = getComponentWithName("tricky", diagram); assertThat(trickyAsHell.getAlias().get()).isEqualTo(new Alias("other")); assertThat(tricky.getAlias().get()).isEqualTo(new Alias("because it's quoted")); }
@Test public void parses_component_diagram_with_multiple_stereotypes() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("someComponent") .withStereoTypes("..firstPackage..", "..secondPackage..", "..thirdPackage..") .write()); PlantUmlComponent component = getOnlyElement(diagram.getAllComponents()); assertThat(component.getStereotypes()).containsOnly( new Stereotype("..firstPackage.."), new Stereotype("..secondPackage.."), new Stereotype("..thirdPackage..")); }
@Test public void parses_component_diagram_with_multiple_stereotypes_and_alias() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("someComponent").withAlias("someAlias") .withStereoTypes("..firstPackage..", "..secondPackage..", "..thirdPackage..") .write()); PlantUmlComponent component = getOnlyElement(diagram.getAllComponents()); assertThat(component.getAlias()).contains(new Alias("someAlias")); }
@Test public void parses_diagram_with_dependencies_that_use_alias() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("A").withAlias("aliasForA").withStereoTypes("..controller..") .component("B").withAlias("aliasForB").withStereoTypes("..service..") .dependencyFrom("aliasForA").to("aliasForB") .write()); PlantUmlComponent aliasForA = getComponentWithAlias(new Alias("aliasForA"), diagram); PlantUmlComponent aliasForB = getComponentWithAlias(new Alias("aliasForB"), diagram); assertThat(getComponentWithName("A", diagram)).isEqualTo(aliasForA); assertThat(getComponentWithName("B", diagram)).isEqualTo(aliasForB); assertThat(aliasForA.getDependencies()).containsOnly(aliasForB); }
@Test public void parses_dependencies_between_components_without_brackets() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("A").withStereoTypes("..origin..") .component("B").withStereoTypes("..target..") .dependencyFrom("A").to("B") .write()); PlantUmlComponent a = getComponentWithName("A", diagram); PlantUmlComponent b = getComponentWithName("B", diagram); assertThat(a.getDependencies()).containsOnly(b); }
@Test public void parses_multiple_components_and_dependencies() { File file = TestDiagram.in(temporaryFolder) .component("Component1").withStereoTypes("..origin1..") .component("Component2").withStereoTypes("..target1..") .component("Component3").withStereoTypes("..origin2..") .component("Component4").withStereoTypes("..target2..") .dependencyFrom("Component1").to("Component2") .dependencyFrom("Component3").to("Component4") .write(); PlantUmlDiagram diagram = createDiagram(file); PlantUmlComponent component1 = getComponentWithName("Component1", diagram); PlantUmlComponent component2 = getComponentWithName("Component2", diagram); PlantUmlComponent component3 = getComponentWithName("Component3", diagram); PlantUmlComponent component4 = getComponentWithName("Component4", diagram); assertThat(diagram.getAllComponents()).containsOnly(component1, component2, component3, component4); assertThat(component1.getDependencies()).containsOnly(component2); assertThat(component2.getDependencies().isEmpty()).isTrue(); assertThat(component3.getDependencies()).containsOnly(component4); assertThat(component4.getDependencies().isEmpty()).isTrue(); }
@Test public void parses_a_diagram_with_non_unique_origins() { File file = TestDiagram.in(temporaryFolder) .component("Component1").withStereoTypes("..origin..") .component("Component2").withStereoTypes("..target1..") .component("Component3").withStereoTypes("..target2..") .dependencyFrom("[Component1]").to("[Component2]") .dependencyFrom("[Component1]").to("[Component3]") .write(); PlantUmlDiagram diagram = createDiagram(file); PlantUmlComponent component1 = getComponentWithName("Component1", diagram); PlantUmlComponent component2 = getComponentWithName("Component2", diagram); PlantUmlComponent component3 = getComponentWithName("Component3", diagram); assertThat(component1.getDependencies()).containsOnly(component2, component3); }
@Test public void parse_a_diagram_with_non_unique_targets() { File file = TestDiagram.in(temporaryFolder) .component("Component1").withStereoTypes("..origin1..") .component("Component2").withStereoTypes("..origin2..") .component("Component3").withStereoTypes("..target..") .dependencyFrom("[Component1]").to("[Component3]") .dependencyFrom("[Component2]").to("[Component3]") .write(); PlantUmlDiagram diagram = createDiagram(file); PlantUmlComponent component1 = getComponentWithName("Component1", diagram); PlantUmlComponent component2 = getComponentWithName("Component2", diagram); PlantUmlComponent component3 = getComponentWithName("Component3", diagram); assertThat(component1.getDependencies()).containsOnly(component3); assertThat(component2.getDependencies()).containsOnly(component3); }
@Test public void parse_a_component_diagram_with_both_alias_and_names_used() { PlantUmlDiagram diagram = createDiagram(TestDiagram.in(temporaryFolder) .component("A").withAlias("foo").withStereoTypes("..service..") .component("B").withStereoTypes("..controller..") .dependencyFrom("[B]").to("foo") .dependencyFrom("foo").to("[B]") .write()); PlantUmlComponent componentB = getComponentWithName("B", diagram); PlantUmlComponent componentFoo = getComponentWithAlias(new Alias("foo"), diagram); assertThat(componentB.getDependencies()).containsOnly(componentFoo); assertThat(componentFoo.getDependencies()).containsOnly(componentB); }
@Test public void parses_a_component_diagram_that_uses_alias_with_and_without_brackets() { File file = TestDiagram.in(temporaryFolder) .component("A").withAlias("foo").withStereoTypes("..origin..") .component("B").withAlias("bar").withStereoTypes("..target..") .dependencyFrom("foo").to("bar") .dependencyFrom("[foo]").to("[bar]") .write(); PlantUmlDiagram diagram = createDiagram(file); PlantUmlComponent foo = getComponentWithAlias(new Alias("foo"), diagram); PlantUmlComponent bar = getComponentWithAlias(new Alias("bar"), diagram); assertThat(foo.getDependencies()).containsOnly(bar); assertThat(bar.getDependencies()).isEmpty(); } |
PlantUmlArchCondition extends ArchCondition<JavaClass> { @PublicAPI(usage = ACCESS) public static PlantUmlArchCondition adhereToPlantUmlDiagram(URL url, Configuration configuration) { return create(url, configuration); } private PlantUmlArchCondition(
String description,
DescribedPredicate<Dependency> ignorePredicate,
JavaClassDiagramAssociation javaClassDiagramAssociation); @PublicAPI(usage = ACCESS) PlantUmlArchCondition ignoreDependenciesWithOrigin(DescribedPredicate<? super JavaClass> ignorePredicate); @PublicAPI(usage = ACCESS) PlantUmlArchCondition ignoreDependenciesWithTarget(DescribedPredicate<? super JavaClass> ignorePredicate); @PublicAPI(usage = ACCESS) PlantUmlArchCondition ignoreDependencies(final Class<?> origin, final Class<?> target); @PublicAPI(usage = ACCESS) PlantUmlArchCondition ignoreDependencies(final String origin, final String target); @PublicAPI(usage = ACCESS) PlantUmlArchCondition ignoreDependencies(DescribedPredicate<? super Dependency> ignorePredicate); @Override void check(JavaClass item, ConditionEvents events); @PublicAPI(usage = ACCESS) static PlantUmlArchCondition adhereToPlantUmlDiagram(URL url, Configuration configuration); @PublicAPI(usage = ACCESS) static PlantUmlArchCondition adhereToPlantUmlDiagram(String fileName, Configuration configuration); @PublicAPI(usage = ACCESS) static PlantUmlArchCondition adhereToPlantUmlDiagram(Path path, Configuration configuration); @PublicAPI(usage = ACCESS) static PlantUmlArchCondition adhereToPlantUmlDiagram(File file, Configuration configuration); } | @Test public void diagram_with_multiple_dependencies_that_considers_only_certain_packages() { File file = TestDiagram.in(temporaryFolder) .component("SomeOrigin").withStereoTypes("..origin") .component("SomeIntermediary").withStereoTypes("..intermediary") .component("SomeTarget").withStereoTypes("..target") .dependencyFrom("SomeOrigin").to("SomeIntermediary") .dependencyFrom("SomeIntermediary").to("SomeTarget") .write(); JavaClasses classes = getClassesFrom("multipledependencies"); PlantUmlArchCondition condition = adhereToPlantUmlDiagram(file, consideringOnlyDependenciesInAnyPackage("..origin", "..intermediary", "..target")); assertConditionHasNumberOfFailures(classes, condition, 3); condition = adhereToPlantUmlDiagram(file, consideringOnlyDependenciesInAnyPackage("..origin", "..intermediary")); assertConditionHasNumberOfFailures(classes, condition, 2); condition = adhereToPlantUmlDiagram(file, consideringOnlyDependenciesInAnyPackage("..origin")); assertConditionHasNumberOfFailures(classes, condition, 1); } |
FreezingArchRule implements ArchRule { @PublicAPI(usage = ACCESS) public static FreezingArchRule freeze(ArchRule rule) { return new FreezingArchRule(rule, ViolationStoreFactory.create(), ViolationLineMatcherFactory.create()); } private FreezingArchRule(ArchRule delegate, ViolationStore store, ViolationLineMatcher matcher); @Override @PublicAPI(usage = ACCESS) void check(JavaClasses classes); @Override @PublicAPI(usage = ACCESS) FreezingArchRule because(String reason); @Override @PublicAPI(usage = ACCESS) FreezingArchRule as(String newDescription); @Override @PublicAPI(usage = ACCESS) EvaluationResult evaluate(JavaClasses classes); @Override @PublicAPI(usage = ACCESS) String getDescription(); @PublicAPI(usage = ACCESS) FreezingArchRule persistIn(ViolationStore store); @PublicAPI(usage = ACCESS) FreezingArchRule associateViolationLinesVia(ViolationLineMatcher matcher); @Override String toString(); @PublicAPI(usage = ACCESS) static FreezingArchRule freeze(ArchRule rule); } | @Test public void default_violation_store_works() throws IOException { useTemporaryDefaultStorePath(); ArchConfiguration.get().setProperty(ALLOW_STORE_CREATION_PROPERTY_NAME, "true"); String[] frozenViolations = {"first violation", "second violation"}; FreezingArchRule frozen = freeze(rule("some description") .withViolations(frozenViolations)); assertThat(frozen) .checking(importClasses(getClass())) .hasNoViolation(); frozen = freeze(rule("some description") .withViolations(frozenViolations[0], "third violation")); assertThat(frozen) .checking(importClasses(getClass())) .hasOnlyViolations("third violation"); frozen = freeze(rule("some description") .withViolations(frozenViolations[0], frozenViolations[1], "third violation")); assertThat(frozen) .checking(importClasses(getClass())) .hasOnlyViolations(frozenViolations[1], "third violation"); } |
ViolationLineMatcherFactory { static ViolationLineMatcher create() { return ArchConfiguration.get().containsProperty(FREEZE_LINE_MATCHER_PROPERTY) ? createInstance(ArchConfiguration.get().getProperty(FREEZE_LINE_MATCHER_PROPERTY)) : DEFAULT_MATCHER; } } | @Test @DataProvider(splitBy = "\\|", value = { "" + "|" + "|" + true, "" + "abc|" + "abc|" + true, "" + "abc|" + "abcd|" + false, "" + "(A.java:1)|" + "(A.java:2)|" + true, "" + "A.java:1|" + "A.java:2|" + false, "" + "(A.java:1)|" + "(A.java:2|" + false, "" + "A$1 B$2 C$4 (X.java:111)|" + "A$2 B$3 C$5 (X.java:222)|" + true, "" + "A$a|" + "A$b|" + false, "" + "A:1|" + "A$2|" + false, "" + "Method <MyClass.lambda$myFunction$2()> has a violation in (MyClass.java:123)|" + "Method <MyClass.lambda$myFunction$123()> has a violation in (MyClass.java:0)|" + true, "" + "Method <C.lambda$myFunction$2()> is bad in (C.java:123)|" + "Method <C.lambda$myFunction$2()> is bad in (C.java:123), too|" + false, "" + "A:1) B$2 C|" + "A: B$ C|" + true, }) public void default_matcher(String str1, String str2, boolean expected) { ViolationLineMatcher defaultMatcher = ViolationLineMatcherFactory.create(); assertThat(defaultMatcher.matches(str1, str2)) .as(String.format("'%s' matches '%s'", str1, str2)) .isEqualTo(expected); } |
ReflectionUtils { static Collection<Field> getAllFields(Class<?> owner, Predicate<? super Field> predicate) { return filter(getAll(owner, new Collector<Field>() { @Override protected Collection<? extends Field> extractFrom(Class<?> type) { return ImmutableList.copyOf(type.getDeclaredFields()); } }), toGuava(predicate)); } private ReflectionUtils(); } | @Test public void getAllFields() { Collection<Field> fields = ReflectionUtils.getAllFields(Child.class, named("field")); assertThat(fields).containsOnly( field(Child.class, "field"), field(UpperMiddle.class, "field"), field(LowerMiddle.class, "field"), field(Parent.class, "field") ); }
@Test public void getAllFields_of_interface() { assertThat(ReflectionUtils.getAllFields(SubInterface.class, always(true))) .containsOnly( field(SomeInterface.class, "SOME_CONSTANT"), field(OtherInterface.class, "OTHER_CONSTANT")); } |
ReflectionUtils { static Collection<Method> getAllMethods(Class<?> owner, Predicate<? super Method> predicate) { return filter(getAll(owner, new Collector<Method>() { @Override protected Collection<? extends Method> extractFrom(Class<?> type) { return ImmutableList.copyOf(type.getDeclaredMethods()); } }), toGuava(predicate)); } private ReflectionUtils(); } | @Test public void getAllMethods() { Collection<Method> methods = ReflectionUtils.getAllMethods(Child.class, named("overrideMe")); assertThat(methods).containsOnly( method(Child.class, "overrideMe"), method(UpperMiddle.class, "overrideMe"), method(LowerMiddle.class, "overrideMe"), method(Parent.class, "overrideMe") ); }
@Test public void getAllMethods_of_interface() { assertThat(ReflectionUtils.getAllMethods(SubInterface.class, always(true))) .containsOnly( method(SomeInterface.class, "foo"), method(OtherInterface.class, "bar")); } |
ReflectionUtils { static Set<Class<?>> getAllSuperTypes(Class<?> type) { if (type == null) { return Collections.emptySet(); } ImmutableSet.Builder<Class<?>> result = ImmutableSet.<Class<?>>builder() .add(type) .addAll(getAllSuperTypes(type.getSuperclass())); for (Class<?> c : type.getInterfaces()) { result.addAll(getAllSuperTypes(c)); } return result.build(); } private ReflectionUtils(); } | @Test public void getAllSupertypes() { assertThat(ReflectionUtils.getAllSuperTypes(Child.class)).containsOnly( Child.class, ChildInterface.class, UpperMiddle.class, LowerMiddle.class, Parent.class, SomeInterface.class, OtherInterface.class, Object.class ); } |
ClassCache { JavaClasses getClassesToAnalyzeFor(Class<?> testClass, ClassAnalysisRequest classAnalysisRequest) { checkNotNull(testClass); checkNotNull(classAnalysisRequest); if (cachedByTest.containsKey(testClass)) { return cachedByTest.get(testClass); } LocationsKey locations = RequestedLocations.by(classAnalysisRequest, testClass).asKey(); JavaClasses classes = classAnalysisRequest.getCacheMode() == FOREVER ? cachedByLocations.getUnchecked(locations).get() : new LazyJavaClasses(locations.locations, locations.importOptionTypes).get(); cachedByTest.put(testClass, classes); return classes; } } | @Test public void loads_classes() { JavaClasses classes = cache.getClassesToAnalyzeFor(TestClass.class, analyzePackages("com.tngtech.archunit.junit")); assertThat(classes).as("Classes were found").isNotEmpty(); }
@Test public void reuses_loaded_classes_by_test() { cache.getClassesToAnalyzeFor(TestClass.class, analyzePackages("com.tngtech.archunit.junit")); cache.getClassesToAnalyzeFor(TestClass.class, analyzePackages("com.tngtech.archunit.junit")); verifyNumberOfImports(1); }
@Test public void reuses_loaded_classes_by_locations_if_cacheMode_is_FOREVER() { cache.getClassesToAnalyzeFor(TestClass.class, analyzePackages("com.tngtech.archunit.junit")); cache.getClassesToAnalyzeFor(EquivalentTestClass.class, analyzePackages("com.tngtech.archunit.junit")); verifyNumberOfImports(1); }
@Test public void doesnt_reuse_loaded_classes_by_locations_if_cacheMode_is_PER_CLASS() { cache.getClassesToAnalyzeFor(TestClass.class, analyzePackages("com.tngtech.archunit.junit").withCacheMode(PER_CLASS)); assertThat(cache.cachedByLocations.asMap()).as("Classes cached by location").isEmpty(); cache.getClassesToAnalyzeFor(EquivalentTestClass.class, analyzePackages("com.tngtech.archunit.junit").withCacheMode(PER_CLASS)); verifyNumberOfImports(2); }
@Test public void filters_jars_relative_to_class() { JavaClasses classes = cache.getClassesToAnalyzeFor(TestClass.class, analyzePackagesOf(Rule.class)); assertThat(classes).isNotEmpty(); for (JavaClass clazz : classes) { assertThat(clazz.getPackageName()).doesNotContain("tngtech"); } }
@Test public void gets_all_classes_relative_to_class() { JavaClasses classes = cache.getClassesToAnalyzeFor(TestClass.class, analyzePackagesOf(getClass())); assertThat(classes).isNotEmpty(); assertThat(classes.contain(getClass())).as("root class is contained itself").isTrue(); }
@Test public void get_all_classes_by_LocationProvider() { JavaClasses classes = cache.getClassesToAnalyzeFor(TestClass.class, new TestAnalysisRequest() .withPackagesRoots(ClassCacheTest.class) .withLocationProviders(TestLocationProviderOfClass_String.class, TestLocationProviderOfClass_Rule.class)); assertThatTypes(classes).contain(String.class, Rule.class, getClass()); classes = cache.getClassesToAnalyzeFor(TestClassWithLocationProviderUsingTestClass.class, analyzeLocation(LocationOfClass.Provider.class)); assertThatTypes(classes).contain(String.class); assertThatTypes(classes).doNotContain(getClass()); }
@Test public void rejects_LocationProviders_without_default_constructor() { thrown.expect(ArchTestExecutionException.class); thrown.expectMessage("public default constructor"); thrown.expectMessage(LocationProvider.class.getSimpleName()); cache.getClassesToAnalyzeFor(WrongLocationProviderWithConstructorParam.class, analyzeLocation(WrongLocationProviderWithConstructorParam.class)); }
@Test public void filters_urls() { JavaClasses classes = cache.getClassesToAnalyzeFor(TestClass.class, new TestAnalysisRequest().withImportOptions(TestFilterForJUnitJars.class)); assertThat(classes).isNotEmpty(); for (JavaClass clazz : classes) { assertThat(clazz.getPackageName()).doesNotContain("tngtech"); assertThat(clazz.getPackageName()).contains("junit"); } }
@Test public void non_existing_packages_are_ignored() { JavaClasses first = cache.getClassesToAnalyzeFor(TestClass.class, new TestAnalysisRequest() .withPackages("something.that.doesnt.exist") .withPackagesRoots(Rule.class)); JavaClasses second = cache.getClassesToAnalyzeFor(TestClass.class, analyzePackagesOf(Rule.class)); assertThat(first).isEqualTo(second); verifyNumberOfImports(1); }
@Test @UseDataProvider("test_classes_without_any_imported_classes") public void when_there_are_only_nonexisting_sources_nothing_is_imported(TestAnalysisRequest analysisRequest) { JavaClasses classes = cache.getClassesToAnalyzeFor(TestClass.class, analysisRequest); assertThat(classes).isEmpty(); verify(cacheClassFileImporter).importClasses(any(ImportOptions.class), locationCaptor.capture()); assertThat(locationCaptor.getValue()).isEmpty(); }
@Test public void distinguishes_import_option_when_caching() { JavaClasses importingWholeClasspathWithFilter = cache.getClassesToAnalyzeFor(TestClass.class, new TestAnalysisRequest().withImportOptions(TestFilterForJUnitJars.class)); JavaClasses importingWholeClasspathWithEquivalentButDifferentFilter = cache.getClassesToAnalyzeFor(EquivalentTestClass.class, new TestAnalysisRequest().withImportOptions(AnotherTestFilterForJUnitJars.class)); assertThat(importingWholeClasspathWithFilter) .as("number of classes imported") .hasSameSizeAs(importingWholeClasspathWithEquivalentButDifferentFilter); verifyNumberOfImports(2); } |
ArchCondition { public void init(Iterable<T> allObjectsToTest) { } ArchCondition(String description, Object... args); void init(Iterable<T> allObjectsToTest); abstract void check(T item, ConditionEvents events); void finish(ConditionEvents events); ArchCondition<T> and(ArchCondition<? super T> condition); ArchCondition<T> or(ArchCondition<? super T> condition); String getDescription(); ArchCondition<T> as(String description, Object... args); @Override String toString(); @SuppressWarnings("unchecked") // Cast is safe since input parameter is contravariant ArchCondition<U> forSubType(); } | @Test @UseDataProvider("conditionCombinations") public void join_inits_all_conditions(ConditionCombination combination) { ConditionWithInitAndFinish one = someCondition("one"); ConditionWithInitAndFinish two = someCondition("two"); combination.combine(one, two).init(singleton("init")); assertThat(one.allObjectsToTest).containsExactly("init"); assertThat(two.allObjectsToTest).containsExactly("init"); } |
ArchCondition { public void finish(ConditionEvents events) { } ArchCondition(String description, Object... args); void init(Iterable<T> allObjectsToTest); abstract void check(T item, ConditionEvents events); void finish(ConditionEvents events); ArchCondition<T> and(ArchCondition<? super T> condition); ArchCondition<T> or(ArchCondition<? super T> condition); String getDescription(); ArchCondition<T> as(String description, Object... args); @Override String toString(); @SuppressWarnings("unchecked") // Cast is safe since input parameter is contravariant ArchCondition<U> forSubType(); } | @Test @UseDataProvider("conditionCombinations") public void join_finishes_all_conditions(ConditionCombination combination) { ConditionWithInitAndFinish one = someCondition("one"); ConditionWithInitAndFinish two = someCondition("two"); ConditionEvents events = new ConditionEvents(); combination.combine(one, two).finish(events); assertThat(one.eventsFromFinish).isEqualTo(events); assertThat(two.eventsFromFinish).isEqualTo(events); } |
EvaluationResult { @PublicAPI(usage = ACCESS) public FailureReport getFailureReport() { return new FailureReport(rule, priority, events.getFailureMessages()); } @PublicAPI(usage = ACCESS) EvaluationResult(HasDescription rule, Priority priority); @PublicAPI(usage = ACCESS) EvaluationResult(HasDescription rule, ConditionEvents events, Priority priority); @PublicAPI(usage = ACCESS) FailureReport getFailureReport(); @PublicAPI(usage = ACCESS) void add(EvaluationResult part); @PublicAPI(usage = ACCESS, state = EXPERIMENTAL) void handleViolations(ViolationHandler<?> violationHandler); @PublicAPI(usage = ACCESS) boolean hasViolation(); @PublicAPI(usage = ACCESS) Priority getPriority(); @PublicAPI(usage = ACCESS) EvaluationResult filterDescriptionsMatching(Predicate<String> linePredicate); } | @Test public void properties_are_passed_to_FailureReport() { EvaluationResult result = new EvaluationResult( hasDescription("special description"), events("first bummer", "second bummer"), Priority.HIGH); assertThat(result.getFailureReport().getDetails()).containsExactly("first bummer", "second bummer"); assertThat(result.getFailureReport().toString()) .containsPattern("Priority.*HIGH") .contains("special description") .contains("first bummer") .contains("second bummer"); } |
InitialConfiguration { public synchronized void set(T object) { checkState(this.value == null, String.format( "Configuration may only be set once - current: %s / new: %s", this.value, object)); this.value = object; } synchronized void set(T object); synchronized T get(); } | @Test public void throws_exception_if_object_is_set_more_than_once() { InitialConfiguration<Object> configuration = new InitialConfiguration<>(); configuration.set("old"); thrown.expect(IllegalStateException.class); thrown.expectMessage("set once"); thrown.expectMessage("old"); thrown.expectMessage("changed"); configuration.set("changed"); } |
InitialConfiguration { public synchronized T get() { checkState(value != null, "No value was ever set"); return value; } synchronized void set(T object); synchronized T get(); } | @Test public void throws_exception_if_no_value_is_present_on_access() { thrown.expect(IllegalStateException.class); thrown.expectMessage("No value was ever set"); new InitialConfiguration<>().get(); } |
Locations { @PublicAPI(usage = ACCESS) public static Set<Location> of(Iterable<URL> urls) { ImmutableSet.Builder<Location> result = ImmutableSet.builder(); for (URL url : urls) { result.add(Location.of(url)); } return result.build(); } private Locations(); @PublicAPI(usage = ACCESS) static Set<Location> of(Iterable<URL> urls); @PublicAPI(usage = ACCESS) static Set<Location> ofPackage(String pkg); @PublicAPI(usage = ACCESS) static Set<Location> ofClass(Class<?> clazz); @PublicAPI(usage = ACCESS) static Set<Location> inClassPath(); } | @Test public void locations_of_URLs() throws Exception { Collection<Location> locations = Locations.of(ImmutableList.of( urlOfClass(getClass()), urlOfClass(Locations.class))); assertThat(urisOf(locations)).containsOnly( urlOfClass(getClass()).toURI(), urlOfClass(Locations.class).toURI() ); } |
Locations { @PublicAPI(usage = ACCESS) public static Set<Location> ofPackage(String pkg) { ImmutableSet.Builder<Location> result = ImmutableSet.builder(); for (Location location : getLocationsOf(asResourceName(pkg))) { result.add(location); } return result.build(); } private Locations(); @PublicAPI(usage = ACCESS) static Set<Location> of(Iterable<URL> urls); @PublicAPI(usage = ACCESS) static Set<Location> ofPackage(String pkg); @PublicAPI(usage = ACCESS) static Set<Location> ofClass(Class<?> clazz); @PublicAPI(usage = ACCESS) static Set<Location> inClassPath(); } | @Test public void locations_of_packages_within_file_URIs() throws Exception { Set<Location> locations = Locations.ofPackage("com.tngtech.archunit.core.importer"); assertThat(urisOf(locations)).contains( uriOfFolderOf(getClass()), uriOfFolderOf(Locations.class) ); }
@Test public void locations_of_packages_within_JAR_URIs() throws Exception { Set<Location> locations = Locations.ofPackage("org.junit"); assertThat(urisOf(locations)).contains( uriOfFolderOf(Test.class) ); }
@Test public void locations_of_packages_within_JAR_URIs_that_do_not_contain_package_folder() throws Exception { independentClasspathRule.configureClasspath(); Set<Location> locations = Locations.ofPackage(independentClasspathRule.getIndependentTopLevelPackage()); ClassFileSource source = getOnlyElement(locations).asClassFileSource(new ImportOptions()); for (ClassFileLocation classFileLocation : source) { try (InputStream ignored = classFileLocation.openStream()) { } } assertThat(source) .as("URIs in " + independentClasspathRule.getIndependentTopLevelPackage()) .hasSize(independentClasspathRule.getNamesOfClasses().size()); }
@Test public void locations_of_packages_from_mixed_URIs() { Set<Location> locations = Locations.ofPackage("com.tngtech"); assertThat(urisOf(locations)).contains( resolvedUri(getClass(), "/com/tngtech"), resolvedUri(DataProvider.class, "/com/tngtech") ); } |
Locations { @PublicAPI(usage = ACCESS) public static Set<Location> ofClass(Class<?> clazz) { return getLocationsOf(asResourceName(clazz.getName()) + ".class"); } private Locations(); @PublicAPI(usage = ACCESS) static Set<Location> of(Iterable<URL> urls); @PublicAPI(usage = ACCESS) static Set<Location> ofPackage(String pkg); @PublicAPI(usage = ACCESS) static Set<Location> ofClass(Class<?> clazz); @PublicAPI(usage = ACCESS) static Set<Location> inClassPath(); } | @Test public void locations_of_class_from_file_URI() throws Exception { assertThat(urisOf(Locations.ofClass(getClass()))).containsExactly( urlOfClass(getClass()).toURI() ); }
@Test public void locations_of_class_from_JAR_URI() throws Exception { assertThat(urisOf(Locations.ofClass(Test.class))).containsExactly( urlOfClass(Test.class).toURI() ); } |
Locations { @PublicAPI(usage = ACCESS) public static Set<Location> inClassPath() { ImmutableSet.Builder<Location> result = ImmutableSet.builder(); for (URL url : locationResolver.get().resolveClassPath()) { result.add(Location.of(url)); } return result.build(); } private Locations(); @PublicAPI(usage = ACCESS) static Set<Location> of(Iterable<URL> urls); @PublicAPI(usage = ACCESS) static Set<Location> ofPackage(String pkg); @PublicAPI(usage = ACCESS) static Set<Location> ofClass(Class<?> clazz); @PublicAPI(usage = ACCESS) static Set<Location> inClassPath(); } | @Test public void locations_in_classpath() throws Exception { assertThat(urisOf(Locations.inClassPath())).contains( getClass().getResource("/").toURI(), resolvedUri(DataProvider.class, "/"), resolvedUri(Test.class, "/") ); } |
Location { @PublicAPI(usage = ACCESS) public boolean contains(String part) { return uri.toString().contains(part); } Location(NormalizedUri uri); @PublicAPI(usage = ACCESS) URI asURI(); @PublicAPI(usage = ACCESS) boolean contains(String part); @PublicAPI(usage = ACCESS) boolean matches(Pattern pattern); @PublicAPI(usage = ACCESS) abstract boolean isJar(); @PublicAPI(usage = ACCESS) abstract boolean isArchive(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static Location of(URL url); @PublicAPI(usage = ACCESS) static Location of(URI uri); @PublicAPI(usage = ACCESS) static Location of(JarFile jar); @PublicAPI(usage = ACCESS) static Location of(Path path); } | @Test @UseDataProvider("locations_of_own_class") public void contains(Location location) { assertThat(location.contains("archunit")).as("location contains 'archunit'").isTrue(); assertThat(location.contains("/archunit/")).as("location contains '/archunit/'").isTrue(); assertThat(location.contains(getClass().getSimpleName())).as("location contains own simple class name").isTrue(); assertThat(location.contains("wrong")).as("location contains 'wrong'").isFalse(); } |
Location { @PublicAPI(usage = ACCESS) public boolean matches(Pattern pattern) { return pattern.matcher(uri.toString()).matches(); } Location(NormalizedUri uri); @PublicAPI(usage = ACCESS) URI asURI(); @PublicAPI(usage = ACCESS) boolean contains(String part); @PublicAPI(usage = ACCESS) boolean matches(Pattern pattern); @PublicAPI(usage = ACCESS) abstract boolean isJar(); @PublicAPI(usage = ACCESS) abstract boolean isArchive(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static Location of(URL url); @PublicAPI(usage = ACCESS) static Location of(URI uri); @PublicAPI(usage = ACCESS) static Location of(JarFile jar); @PublicAPI(usage = ACCESS) static Location of(Path path); } | @Test @UseDataProvider("locations_of_own_class") public void matches(Location location) { assertThat(location.matches(Pattern.compile("archunit.*"))).as("location matches 'archunit.*'").isFalse(); assertThat(location.matches(Pattern.compile(".*archunit.*"))).as("location matches '.*archunit.*'").isTrue(); assertThat(location.matches(Pattern.compile(".*/archunit/.*"))).as("location contains '/archunit/'").isTrue(); assertThat(location.matches(Pattern.compile(".*" + getClass().getSimpleName() + ".*"))) .as("location matches own simple class name").isTrue(); assertThat(location.matches(Pattern.compile(".*wrong.*"))).as("location matches '.*wrong.*'").isFalse(); } |
Location { @PublicAPI(usage = ACCESS) public URI asURI() { return uri.toURI(); } Location(NormalizedUri uri); @PublicAPI(usage = ACCESS) URI asURI(); @PublicAPI(usage = ACCESS) boolean contains(String part); @PublicAPI(usage = ACCESS) boolean matches(Pattern pattern); @PublicAPI(usage = ACCESS) abstract boolean isJar(); @PublicAPI(usage = ACCESS) abstract boolean isArchive(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static Location of(URL url); @PublicAPI(usage = ACCESS) static Location of(URI uri); @PublicAPI(usage = ACCESS) static Location of(JarFile jar); @PublicAPI(usage = ACCESS) static Location of(Path path); } | @Test public void asUri() throws URISyntaxException { URL url = getClass().getResource("."); assertThat(Location.of(url).asURI()).isEqualTo(url.toURI()); } |
Location { Location append(String relativeURI) { relativeURI = encodeIllegalCharacters(relativeURI); if (uri.toString().endsWith("/") && relativeURI.startsWith("/")) { relativeURI = relativeURI.substring(1); } if (!uri.toString().endsWith("/") && !relativeURI.startsWith("/")) { relativeURI = "/" + relativeURI; } return Location.of(URI.create(uri + relativeURI)); } Location(NormalizedUri uri); @PublicAPI(usage = ACCESS) URI asURI(); @PublicAPI(usage = ACCESS) boolean contains(String part); @PublicAPI(usage = ACCESS) boolean matches(Pattern pattern); @PublicAPI(usage = ACCESS) abstract boolean isJar(); @PublicAPI(usage = ACCESS) abstract boolean isArchive(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static Location of(URL url); @PublicAPI(usage = ACCESS) static Location of(URI uri); @PublicAPI(usage = ACCESS) static Location of(JarFile jar); @PublicAPI(usage = ACCESS) static Location of(Path path); } | @Test @UseDataProvider("base_locations") public void append(Location location) { Location appendAbsolute = location.append("/bar/baz"); Location appendRelative = location.append("bar/baz"); Location expected = Location.of(Paths.get("/some/path/bar/baz")); assertThat(appendAbsolute).isEqualTo(expected); assertThat(appendRelative).isEqualTo(expected); } |
ClassFileImporter { @PublicAPI(usage = ACCESS) public JavaClasses importClasses(Class<?>... classes) { return importClasses(Arrays.asList(classes)); } @PublicAPI(usage = ACCESS) ClassFileImporter(); @PublicAPI(usage = ACCESS) ClassFileImporter(ImportOptions importOptions); @PublicAPI(usage = ACCESS) ClassFileImporter withImportOption(ImportOption option); @PublicAPI(usage = ACCESS) JavaClasses importPath(String path); @PublicAPI(usage = ACCESS) JavaClasses importPath(Path path); @PublicAPI(usage = ACCESS) JavaClasses importPaths(String... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Path... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Collection<Path> paths); @PublicAPI(usage = ACCESS) JavaClasses importJar(JarFile jar); @PublicAPI(usage = ACCESS) JavaClasses importJars(JarFile... jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importJars(Iterable<JarFile> jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importPackages(Collection<String> packages); @PublicAPI(usage = ACCESS) JavaClasses importPackages(String... packages); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(ImportOptions options); @PublicAPI(usage = ACCESS) JavaClass importClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importUrl(URL url); @PublicAPI(usage = ACCESS) JavaClasses importUrls(Collection<URL> urls); @PublicAPI(usage = ACCESS) JavaClasses importLocations(Collection<Location> locations); } | @Test public void imports_jdk_classes() { JavaClasses classes = new ClassFileImporter().importClasses(File.class); assertThatTypes(classes).matchExactly(File.class); }
@Test public void classes_know_which_fields_have_their_type() { JavaClasses classes = new ClassFileImporter().importClasses(SomeClass.class, OtherClass.class, SomeEnum.class); assertThat(classes.get(SomeEnum.class).getFieldsWithTypeOfSelf()) .extracting("name").contains("other", "someEnum"); }
@Test public void classes_know_which_methods_have_their_type_as_parameter() { JavaClasses classes = new ClassFileImporter().importClasses(SomeClass.class, OtherClass.class, SomeEnum.class); assertThat(classes.get(SomeEnum.class).getMethodsWithParameterTypeOfSelf()) .extracting("name").contains("methodWithSomeEnumParameter", "otherMethodWithSomeEnumParameter"); }
@Test public void classes_know_which_methods_have_their_type_as_return_type() { JavaClasses classes = new ClassFileImporter().importClasses(SomeClass.class, OtherClass.class, SomeEnum.class); assertThat(classes.get(SomeEnum.class).getMethodsWithReturnTypeOfSelf()) .extracting("name").contains("methodWithSomeEnumReturnType", "otherMethodWithSomeEnumReturnType"); }
@Test public void classes_know_which_method_throws_clauses_contain_their_type() { JavaClasses classes = new ClassFileImporter().importClasses(ClassWithThrowingMethod.class, FirstCheckedException.class); Set<ThrowsDeclaration<JavaMethod>> throwsDeclarations = classes.get(FirstCheckedException.class).getMethodThrowsDeclarationsWithTypeOfSelf(); assertThatType(getOnlyElement(throwsDeclarations).getDeclaringClass()).matches(ClassWithThrowingMethod.class); assertThat(classes.get(FirstCheckedException.class).getConstructorsWithParameterTypeOfSelf()).isEmpty(); }
@Test public void classes_know_which_constructors_have_their_type_as_parameter() { JavaClasses classes = new ClassFileImporter().importClasses(SomeClass.class, OtherClass.class, SomeEnum.class); assertThat(classes.get(SomeEnum.class).getConstructorsWithParameterTypeOfSelf()) .extracting("owner").extracting("name") .contains(SomeClass.class.getName(), OtherClass.class.getName()); }
@Test public void classes_know_which_constructor_throws_clauses_contain_their_type() { JavaClasses classes = new ClassFileImporter().importClasses(ClassWithThrowingConstructor.class, FirstCheckedException.class); Set<ThrowsDeclaration<JavaConstructor>> throwsDeclarations = classes.get(FirstCheckedException.class).getConstructorsWithThrowsDeclarationTypeOfSelf(); assertThatType(getOnlyElement(throwsDeclarations).getDeclaringClass()).matches(ClassWithThrowingConstructor.class); assertThat(classes.get(FirstCheckedException.class).getMethodThrowsDeclarationsWithTypeOfSelf()).isEmpty(); }
@Test public void classes_know_which_annotations_have_their_type() { JavaClasses classes = new ClassFileImporter().importClasses(ClassWithOneAnnotation.class, SimpleAnnotation.class); Set<JavaAnnotation<?>> annotations = classes.get(SimpleAnnotation.class).getAnnotationsWithTypeOfSelf(); assertThat(getOnlyElement(annotations).getOwner()).isEqualTo(classes.get(ClassWithOneAnnotation.class)); }
@Test public void imports_class_objects() { JavaClasses classes = new ClassFileImporter().importClasses(ClassToImportOne.class, ClassToImportTwo.class); assertThatTypes(classes).matchInAnyOrder(ClassToImportOne.class, ClassToImportTwo.class); } |
ClassFileImporter { @PublicAPI(usage = ACCESS) public JavaClasses importPackagesOf(Class<?>... classes) { return importPackagesOf(ImmutableSet.copyOf(classes)); } @PublicAPI(usage = ACCESS) ClassFileImporter(); @PublicAPI(usage = ACCESS) ClassFileImporter(ImportOptions importOptions); @PublicAPI(usage = ACCESS) ClassFileImporter withImportOption(ImportOption option); @PublicAPI(usage = ACCESS) JavaClasses importPath(String path); @PublicAPI(usage = ACCESS) JavaClasses importPath(Path path); @PublicAPI(usage = ACCESS) JavaClasses importPaths(String... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Path... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Collection<Path> paths); @PublicAPI(usage = ACCESS) JavaClasses importJar(JarFile jar); @PublicAPI(usage = ACCESS) JavaClasses importJars(JarFile... jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importJars(Iterable<JarFile> jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importPackages(Collection<String> packages); @PublicAPI(usage = ACCESS) JavaClasses importPackages(String... packages); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(ImportOptions options); @PublicAPI(usage = ACCESS) JavaClass importClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importUrl(URL url); @PublicAPI(usage = ACCESS) JavaClasses importUrls(Collection<URL> urls); @PublicAPI(usage = ACCESS) JavaClasses importLocations(Collection<Location> locations); } | @Test public void imports_jdk_packages() { JavaClasses classes = new ClassFileImporter().importPackagesOf(File.class); assertThatTypes(classes).contain(File.class); }
@Test public void creates_JavaPackages_for_each_JavaClass() { JavaClasses classes = new ClassFileImporter().importPackagesOf(getClass()); JavaPackage javaPackage = classes.get(SomeClass.class).getPackage(); assertThat(javaPackage.containsClass(SomeEnum.class)).as("Package contains " + SomeEnum.class).isTrue(); assertThatTypes(javaPackage.getParent().get().getClasses()).contain(getClass()); }
@Test @UseDataProvider("array_types") public void adds_package_of_component_type_to_arrays(Class<?> classAccessingArray) { JavaClass javaClass = new ClassFileImporter().importPackagesOf(classAccessingArray) .get(classAccessingArray); JavaClass arrayType = getOnlyElement(javaClass.getFieldAccessesFromSelf()).getTarget().getRawType(); assertThat(arrayType.getPackageName()).isEqualTo(ClassUsedInArray.class.getPackage().getName()); assertThat(arrayType.getPackage().getName()).isEqualTo(ClassUsedInArray.class.getPackage().getName()); } |
ClassFileImporter { @PublicAPI(usage = ACCESS) public JavaClass importClass(Class<?> clazz) { return getOnlyElement(importClasses(clazz)); } @PublicAPI(usage = ACCESS) ClassFileImporter(); @PublicAPI(usage = ACCESS) ClassFileImporter(ImportOptions importOptions); @PublicAPI(usage = ACCESS) ClassFileImporter withImportOption(ImportOption option); @PublicAPI(usage = ACCESS) JavaClasses importPath(String path); @PublicAPI(usage = ACCESS) JavaClasses importPath(Path path); @PublicAPI(usage = ACCESS) JavaClasses importPaths(String... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Path... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Collection<Path> paths); @PublicAPI(usage = ACCESS) JavaClasses importJar(JarFile jar); @PublicAPI(usage = ACCESS) JavaClasses importJars(JarFile... jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importJars(Iterable<JarFile> jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importPackages(Collection<String> packages); @PublicAPI(usage = ACCESS) JavaClasses importPackages(String... packages); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(ImportOptions options); @PublicAPI(usage = ACCESS) JavaClass importClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importUrl(URL url); @PublicAPI(usage = ACCESS) JavaClasses importUrls(Collection<URL> urls); @PublicAPI(usage = ACCESS) JavaClasses importLocations(Collection<Location> locations); } | @Test public void creates_superclass_and_interface_relations_missing_from_context() { JavaClass javaClass = new ClassFileImporter().importClass(SubSubSubSubClass.class); assertThat(javaClass.getAllSuperClasses()).extracting("name") .containsExactly( SubSubSubClass.class.getName(), SubSubClass.class.getName(), SubClass.class.getName(), BaseClass.class.getName(), Object.class.getName()); assertThat(javaClass.getAllInterfaces()).extracting("name") .containsOnly( SubInterface.class.getName(), YetAnotherInterface.class.getName(), ParentInterface.class.getName(), GrandParentInterface.class.getName(), OtherInterface.class.getName()); }
@Test public void class_has_source_of_import() throws Exception { ArchConfiguration.get().setMd5InClassSourcesEnabled(true); JavaClass clazzFromFile = new ClassFileImporter().importClass(ClassToImportOne.class); Source source = clazzFromFile.getSource().get(); assertThat(source.getUri()).isEqualTo(urlOf(ClassToImportOne.class).toURI()); assertThat(source.getFileName()).contains(ClassToImportOne.class.getSimpleName() + ".java"); assertThat(source.getMd5sum()).isEqualTo(md5sumOf(bytesAt(urlOf(ClassToImportOne.class)))); clazzFromFile = new ClassFileImporter().importClass(ClassWithInnerClass.Inner.class); source = clazzFromFile.getSource().get(); assertThat(source.getUri()).isEqualTo(urlOf(ClassWithInnerClass.Inner.class).toURI()); assertThat(source.getFileName()).contains(ClassWithInnerClass.class.getSimpleName() + ".java"); assertThat(source.getMd5sum()).isEqualTo(md5sumOf(bytesAt(urlOf(ClassWithInnerClass.Inner.class)))); JavaClass clazzFromJar = new ClassFileImporter().importClass(Rule.class); source = clazzFromJar.getSource().get(); assertThat(source.getUri()).isEqualTo(urlOf(Rule.class).toURI()); assertThat(source.getFileName()).contains(Rule.class.getSimpleName() + ".java"); assertThat(source.getMd5sum()).isEqualTo(md5sumOf(bytesAt(urlOf(Rule.class)))); ArchConfiguration.get().setMd5InClassSourcesEnabled(false); source = new ClassFileImporter().importClass(ClassToImportOne.class).getSource().get(); assertThat(source.getMd5sum()).isEqualTo(MD5_SUM_DISABLED); } |
ContainsOnlyCondition extends ArchCondition<Collection<? extends T>> { @Override public void check(Collection<? extends T> collection, ConditionEvents events) { ConditionEvents subEvents = new ConditionEvents(); for (T item : collection) { condition.check(item, subEvents); } if (!subEvents.isEmpty()) { events.add(new OnlyConditionEvent(collection, subEvents)); } } ContainsOnlyCondition(ArchCondition<T> condition); @Override void check(Collection<? extends T> collection, ConditionEvents events); @Override String toString(); } | @Test public void satisfied_works_and_description_contains_mismatches() { ConditionEvents events = new ConditionEvents(); containOnlyElementsThat(IS_SERIALIZABLE).check(ONE_SERIALIZABLE_AND_ONE_NON_SERIALIZABLE_OBJECT, events); assertThat(events).containViolations(isSerializableMessageFor(Object.class)); events = new ConditionEvents(); containOnlyElementsThat(IS_SERIALIZABLE).check(TWO_SERIALIZABLE_OBJECTS, events); assertThat(events).containNoViolation(); }
@Test public void inverting_works() throws Exception { ConditionEvents events = new ConditionEvents(); containOnlyElementsThat(IS_SERIALIZABLE).check(TWO_SERIALIZABLE_OBJECTS, events); assertThat(events).containNoViolation(); assertThat(events.getAllowed()).as("Exactly one allowed event occurred").hasSize(1); assertThat(getInverted(events)).containViolations(messageForTwoTimes(isSerializableMessageFor(SerializableObject.class))); }
@Test public void if_there_are_no_input_events_no_ContainsOnlyEvent_is_added() { ConditionEvents events = new ConditionEvents(); containOnlyElementsThat(IS_SERIALIZABLE).check(emptyList(), events); assertThat(events.isEmpty()).as("events are empty").isTrue(); } |
ClassFileImporter { @PublicAPI(usage = ACCESS) public JavaClasses importUrls(Collection<URL> urls) { return importLocations(Locations.of(urls)); } @PublicAPI(usage = ACCESS) ClassFileImporter(); @PublicAPI(usage = ACCESS) ClassFileImporter(ImportOptions importOptions); @PublicAPI(usage = ACCESS) ClassFileImporter withImportOption(ImportOption option); @PublicAPI(usage = ACCESS) JavaClasses importPath(String path); @PublicAPI(usage = ACCESS) JavaClasses importPath(Path path); @PublicAPI(usage = ACCESS) JavaClasses importPaths(String... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Path... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Collection<Path> paths); @PublicAPI(usage = ACCESS) JavaClasses importJar(JarFile jar); @PublicAPI(usage = ACCESS) JavaClasses importJars(JarFile... jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importJars(Iterable<JarFile> jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importPackages(Collection<String> packages); @PublicAPI(usage = ACCESS) JavaClasses importPackages(String... packages); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(ImportOptions options); @PublicAPI(usage = ACCESS) JavaClass importClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importUrl(URL url); @PublicAPI(usage = ACCESS) JavaClasses importUrls(Collection<URL> urls); @PublicAPI(usage = ACCESS) JavaClasses importLocations(Collection<Location> locations); } | @Test public void imports_urls_of_files() { Set<URL> urls = newHashSet(urlOf(ClassToImportOne.class), urlOf(ClassWithNestedClass.class)); Set<JavaClass> classesFoundAtUrls = new HashSet<>(); for (JavaClass javaClass : new ClassFileImporter().importUrls(urls)) { if (!Object.class.getName().equals(javaClass.getName())) { classesFoundAtUrls.add(javaClass); } } assertThat(classesFoundAtUrls).as("Number of classes at the given URLs").hasSize(2); }
@Test public void imports_urls_of_jars() { Set<URL> urls = newHashSet(urlOf(Test.class), urlOf(RunWith.class)); assumeTrue("We can't completely ensure that this will always be taken from a JAR file, though it's very likely", "jar".equals(urls.iterator().next().getProtocol())); JavaClasses classes = new ClassFileImporter().importUrls(urls) .that(DescribedPredicate.not(type(Annotation.class))); assertThat(classes).as("Number of classes at the given URLs").hasSize(2); } |
ClassFileImporter { @PublicAPI(usage = ACCESS) public JavaClasses importUrl(URL url) { return importUrls(singletonList(url)); } @PublicAPI(usage = ACCESS) ClassFileImporter(); @PublicAPI(usage = ACCESS) ClassFileImporter(ImportOptions importOptions); @PublicAPI(usage = ACCESS) ClassFileImporter withImportOption(ImportOption option); @PublicAPI(usage = ACCESS) JavaClasses importPath(String path); @PublicAPI(usage = ACCESS) JavaClasses importPath(Path path); @PublicAPI(usage = ACCESS) JavaClasses importPaths(String... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Path... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Collection<Path> paths); @PublicAPI(usage = ACCESS) JavaClasses importJar(JarFile jar); @PublicAPI(usage = ACCESS) JavaClasses importJars(JarFile... jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importJars(Iterable<JarFile> jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importPackages(Collection<String> packages); @PublicAPI(usage = ACCESS) JavaClasses importPackages(String... packages); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(ImportOptions options); @PublicAPI(usage = ACCESS) JavaClass importClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importUrl(URL url); @PublicAPI(usage = ACCESS) JavaClasses importUrls(Collection<URL> urls); @PublicAPI(usage = ACCESS) JavaClasses importLocations(Collection<Location> locations); } | @Test public void imports_urls_of_folders() throws Exception { File testexamplesFolder = new File(new File(urlOf(getClass()).toURI()).getParentFile(), "testexamples"); JavaClasses javaClasses = new ClassFileImporter().importUrl(testexamplesFolder.toURI().toURL()); assertThatTypes(javaClasses).contain(SomeClass.class, OtherClass.class); }
@Test public void is_resilient_against_broken_ClassFileSources() throws MalformedURLException { JavaClasses classes = new ClassFileImporter().importUrl(new File("/broken.class").toURI().toURL()); assertThat(classes).isEmpty(); classes = new ClassFileImporter().importUrl(new File("/broken.jar").toURI().toURL()); assertThat(classes).isEmpty(); } |
ClassFileImporter { @PublicAPI(usage = ACCESS) public JavaClasses importPath(String path) { return importPaths(path); } @PublicAPI(usage = ACCESS) ClassFileImporter(); @PublicAPI(usage = ACCESS) ClassFileImporter(ImportOptions importOptions); @PublicAPI(usage = ACCESS) ClassFileImporter withImportOption(ImportOption option); @PublicAPI(usage = ACCESS) JavaClasses importPath(String path); @PublicAPI(usage = ACCESS) JavaClasses importPath(Path path); @PublicAPI(usage = ACCESS) JavaClasses importPaths(String... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Path... paths); @PublicAPI(usage = ACCESS) JavaClasses importPaths(Collection<Path> paths); @PublicAPI(usage = ACCESS) JavaClasses importJar(JarFile jar); @PublicAPI(usage = ACCESS) JavaClasses importJars(JarFile... jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importJars(Iterable<JarFile> jarFiles); @PublicAPI(usage = ACCESS) JavaClasses importPackages(Collection<String> packages); @PublicAPI(usage = ACCESS) JavaClasses importPackages(String... packages); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importPackagesOf(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(); @PublicAPI(usage = ACCESS) JavaClasses importClasspath(ImportOptions options); @PublicAPI(usage = ACCESS) JavaClass importClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Class<?>... classes); @PublicAPI(usage = ACCESS) JavaClasses importClasses(Collection<Class<?>> classes); @PublicAPI(usage = ACCESS) JavaClasses importUrl(URL url); @PublicAPI(usage = ACCESS) JavaClasses importUrls(Collection<URL> urls); @PublicAPI(usage = ACCESS) JavaClasses importLocations(Collection<Location> locations); } | @Test public void imports_classes_outside_of_the_classpath() throws IOException { Path targetDir = outsideOfClassPath .onlyKeep(not(containsPattern("^Missing.*"))) .setUp(getClass().getResource("testexamples/outsideofclasspath")); JavaClasses classes = new ClassFileImporter().importPath(targetDir); assertThat(classes).hasSize(5); assertThat(classes).extracting("name").containsOnly( "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.ChildClass", "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.MiddleClass", "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.ExistingDependency", "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.ChildClass$MySeed", "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.ExistingDependency$GimmeADescription" ); JavaClass middleClass = findAnyByName(classes, "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.MiddleClass"); assertThat(middleClass.getSimpleName()).as("simple name").isEqualTo("MiddleClass"); assertThat(middleClass.isInterface()).as("is interface").isFalse(); assertThatCall(findAnyByName(middleClass.getMethodCallsFromSelf(), "println")) .isFrom(middleClass.getMethod("overrideMe")) .isTo(targetWithFullName(String.format("%s.println(%s)", PrintStream.class.getName(), String.class.getName()))) .inLineNumber(12); assertThatCall(findAnyByName(middleClass.getMethodCallsFromSelf(), "getSomeString")) .isFrom(middleClass.getMethod("overrideMe")) .isTo(targetWithFullName( "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.MissingDependency.getSomeString()")) .inLineNumber(12); JavaClass gimmeADescription = findAnyByName(classes, "com.tngtech.archunit.core.importer.testexamples.outsideofclasspath.ExistingDependency$GimmeADescription"); assertThat(gimmeADescription.getSimpleName()).as("simple name").isEqualTo("GimmeADescription"); assertThat(gimmeADescription.isInterface()).as("is interface").isTrue(); }
@Test public void import_is_resilient_against_broken_class_files() throws Exception { Class<?> expectedClass = getClass(); File folder = temporaryFolder.newFolder(); copyClassFile(expectedClass, folder); Files.write(new File(folder, "Evil.class").toPath(), "broken".getBytes(UTF_8)); logTest.watch(ClassFileProcessor.class, Level.WARN); JavaClasses classes = new ClassFileImporter().importPath(folder.toPath()); assertThatTypes(classes).matchExactly(expectedClass); logTest.assertLogMessage(Level.WARN, "Evil.class"); } |
JavaClassDescriptorImporter { static JavaClassDescriptor createFromAsmObjectTypeName(String objectTypeName) { return importAsmType(Type.getObjectType(objectTypeName)); } } | @Test public void asm_object_type() { JavaClassDescriptor objectType = JavaClassDescriptorImporter.createFromAsmObjectTypeName("java/lang/Object"); assertThat(objectType).isEquivalentTo(Object.class); } |
JavaClassDescriptorImporter { static JavaClassDescriptor importAsmType(Type type) { return JavaClassDescriptor.From.name(type.getClassName()); } } | @Test public void asm_Type() throws NoSuchMethodException { Type toStringType = Type.getReturnType(Object.class.getDeclaredMethod("toString")); JavaClassDescriptor toStringDescriptor = JavaClassDescriptorImporter.importAsmType(toStringType); assertThat(toStringDescriptor.getFullyQualifiedClassName()).isEqualTo(String.class.getName()); assertThat(toStringDescriptor.resolveClass()).isEqualTo(String.class); } |
JavaAccess implements HasName, HasDescription, HasOwner<JavaCodeUnit>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getDescription() { String description = origin.getDescription() + " " + descriptionVerb() + " " + getTarget().getDescription(); return description + " in " + getSourceCodeLocation(); } JavaAccess(DomainBuilders.JavaAccessBuilder<TARGET, ?> builder); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) JavaCodeUnit getOrigin(); @PublicAPI(usage = ACCESS) JavaClass getOriginOwner(); @PublicAPI(usage = ACCESS) JavaClass getTargetOwner(); @PublicAPI(usage = ACCESS) TARGET getTarget(); @PublicAPI(usage = ACCESS) int getLineNumber(); @Override @PublicAPI(usage = ACCESS) JavaCodeUnit getOwner(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override @PublicAPI(usage = ACCESS) String getDescription(); } | @Test public void when_the_origin_is_an_inner_class_the_toplevel_class_is_displayed_as_location() { TestJavaAccess access = javaAccessFrom(importClassWithContext(SomeClass.Inner.class), "foo") .to(SomeEnum.class, "bar") .inLineNumber(7); assertThat(access.getDescription()).contains("(SomeClass.java:7)"); }
@Test public void location_of_origin_of_deeper_inner_class_hierarchies() { JavaClass innerClass = importClassesWithContext(SomeClass.Inner.InnerInner.class, SomeClass.Inner.class, SomeClass.class) .get(SomeClass.Inner.InnerInner.class); TestJavaAccess access = javaAccessFrom(innerClass, "bar") .to(SomeEnum.class, "bar") .inLineNumber(7); assertThat(access.getDescription()).contains("(SomeClass.java:7)"); } |
Formatters { @PublicAPI(usage = ACCESS) public static String ensureSimpleName(String name) { int lastIndexOfDot = name.lastIndexOf('.'); String partAfterDot = lastIndexOfDot >= 0 ? name.substring(lastIndexOfDot + 1) : name; int lastIndexOf$ = partAfterDot.lastIndexOf('$'); String simpleNameCandidate = lastIndexOf$ >= 0 ? partAfterDot.substring(lastIndexOf$ + 1) : partAfterDot; for (int i = 0; i < simpleNameCandidate.length(); i++) { if (Character.isJavaIdentifierStart(simpleNameCandidate.charAt(i))) { return simpleNameCandidate.substring(i); } } return ""; } private Formatters(); @PublicAPI(usage = ACCESS) static String formatMethod(String ownerName, String methodName, JavaClassList parameters); @PublicAPI(usage = ACCESS) static String formatMethodSimple(String ownerName, String methodName, List<String> parameters); @PublicAPI(usage = ACCESS) static String formatMethod(String ownerName, String methodName, List<String> parameters); @PublicAPI(usage = ACCESS) static String formatMethodParameterTypeNames(List<String> typeNames); @PublicAPI(usage = ACCESS) static String formatThrowsDeclarationTypeNames(List<String> typeNames); @PublicAPI(usage = ACCESS) static String ensureSimpleName(String name); } | @Test public void ensureSimpleName_withNullString() { thrown.expect(NullPointerException.class); Formatters.ensureSimpleName(null); }
@Test @UseDataProvider("simple_name_test_cases") public void ensureSimpleName(String input, String expected) { assertThat(Formatters.ensureSimpleName(input)).isEqualTo(expected); } |
JavaPackage implements HasName, HasAnnotations<JavaPackage> { @PublicAPI(usage = ACCESS) public JavaPackage getPackage(String packageName) { return getValue(tryGetPackage(packageName), "This package does not contain any sub package '%s'", packageName); } private JavaPackage(String name, Set<JavaClass> classes, Map<String, JavaPackage> subPackages); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) String getRelativeName(); @PublicAPI(usage = ACCESS) HasAnnotations<?> getPackageInfo(); @PublicAPI(usage = ACCESS) Optional<? extends HasAnnotations<?>> tryGetPackageInfo(); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<JavaPackage>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaPackage> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaPackage>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) Optional<JavaPackage> getParent(); @PublicAPI(usage = ACCESS) Set<JavaClass> getClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClasses(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getSubPackages(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getAllSubPackages(); @PublicAPI(usage = ACCESS) boolean containsClass(JavaClass clazz); @PublicAPI(usage = ACCESS) boolean containsClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClass getClass(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean containsClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) boolean containsClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) boolean containsPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesToSelf(); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaPackage> predicate, PackageVisitor visitor); @Override String getDescription(); @Override String toString(); } | @Test public void rejects_retrieving_non_existing_subpackages() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("does not contain"); thrown.expectMessage("some.pkg"); importDefaultPackage().getPackage("some.pkg"); }
@Test public void function_GET_RELATIVE_NAME() { JavaPackage defaultPackage = importDefaultPackage(Object.class); String name = GET_RELATIVE_NAME.apply(defaultPackage.getPackage("java.lang")); assertThat(name).isEqualTo("lang"); }
@Test public void function_GET_CLASSES() { JavaPackage defaultPackage = importDefaultPackage(Object.class, String.class, Collection.class); Iterable<JavaClass> classes = GET_CLASSES.apply(defaultPackage.getPackage("java.lang")); assertThatTypes(classes).contain(Object.class, String.class); for (JavaClass javaClass : classes) { assertThat(javaClass.getPackageName()).startsWith("java.lang"); } }
@Test public void function_GET_SUB_PACKAGES() { JavaPackage defaultPackage = importDefaultPackage(Object.class, Annotation.class, Field.class, Collection.class); Iterable<JavaPackage> packages = GET_SUB_PACKAGES.apply(defaultPackage.getPackage("java.lang")); assertThatPackages(packages).containPackagesOf(Annotation.class, Field.class); } |
JavaPackage implements HasName, HasAnnotations<JavaPackage> { @PublicAPI(usage = ACCESS) public JavaClass getClassWithSimpleName(String className) { return getValue(tryGetClassWithSimpleName(className), "This package does not contain any class with simple name '%s'", className); } private JavaPackage(String name, Set<JavaClass> classes, Map<String, JavaPackage> subPackages); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) String getRelativeName(); @PublicAPI(usage = ACCESS) HasAnnotations<?> getPackageInfo(); @PublicAPI(usage = ACCESS) Optional<? extends HasAnnotations<?>> tryGetPackageInfo(); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<JavaPackage>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaPackage> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaPackage>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) Optional<JavaPackage> getParent(); @PublicAPI(usage = ACCESS) Set<JavaClass> getClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClasses(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getSubPackages(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getAllSubPackages(); @PublicAPI(usage = ACCESS) boolean containsClass(JavaClass clazz); @PublicAPI(usage = ACCESS) boolean containsClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClass getClass(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean containsClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) boolean containsClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) boolean containsPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesToSelf(); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaPackage> predicate, PackageVisitor visitor); @Override String getDescription(); @Override String toString(); } | @Test public void rejects_retrieving_non_existing_classes_by_simple_name() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("does not contain"); thrown.expectMessage(Object.class.getSimpleName()); importDefaultPackage().getClassWithSimpleName(Object.class.getSimpleName()); } |
JavaPackage implements HasName, HasAnnotations<JavaPackage> { @PublicAPI(usage = ACCESS) public void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor) { for (JavaClass javaClass : getClassesWith(predicate)) { visitor.visit(javaClass); } for (JavaPackage subPackage : getSubPackages()) { subPackage.accept(predicate, visitor); } } private JavaPackage(String name, Set<JavaClass> classes, Map<String, JavaPackage> subPackages); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) String getRelativeName(); @PublicAPI(usage = ACCESS) HasAnnotations<?> getPackageInfo(); @PublicAPI(usage = ACCESS) Optional<? extends HasAnnotations<?>> tryGetPackageInfo(); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<JavaPackage>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaPackage> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaPackage>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) Optional<JavaPackage> getParent(); @PublicAPI(usage = ACCESS) Set<JavaClass> getClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClasses(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getSubPackages(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getAllSubPackages(); @PublicAPI(usage = ACCESS) boolean containsClass(JavaClass clazz); @PublicAPI(usage = ACCESS) boolean containsClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClass getClass(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean containsClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) boolean containsClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) boolean containsPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesToSelf(); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaPackage> predicate, PackageVisitor visitor); @Override String getDescription(); @Override String toString(); } | @Test public void visits_classes() { JavaPackage defaultPackage = importDefaultPackage(Object.class, String.class, File.class, Serializable.class, Security.class); final List<JavaClass> visitedClasses = new ArrayList<>(); defaultPackage.accept(startsWith("S"), new ClassVisitor() { @Override public void visit(JavaClass javaClass) { visitedClasses.add(javaClass); } }); assertThatTypes(visitedClasses).contain(String.class, Serializable.class, Security.class); for (JavaClass visitedClass : visitedClasses) { assertThat(visitedClass.getSimpleName()).startsWith("S"); } } |
JavaPackage implements HasName, HasAnnotations<JavaPackage> { @PublicAPI(usage = ACCESS) public Optional<? extends HasAnnotations<?>> tryGetPackageInfo() { return packageInfo; } private JavaPackage(String name, Set<JavaClass> classes, Map<String, JavaPackage> subPackages); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) String getRelativeName(); @PublicAPI(usage = ACCESS) HasAnnotations<?> getPackageInfo(); @PublicAPI(usage = ACCESS) Optional<? extends HasAnnotations<?>> tryGetPackageInfo(); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<JavaPackage>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaPackage> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaPackage>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) Optional<JavaPackage> getParent(); @PublicAPI(usage = ACCESS) Set<JavaClass> getClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClasses(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getSubPackages(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getAllSubPackages(); @PublicAPI(usage = ACCESS) boolean containsClass(JavaClass clazz); @PublicAPI(usage = ACCESS) boolean containsClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClass getClass(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean containsClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) boolean containsClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) boolean containsPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesToSelf(); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaPackage> predicate, PackageVisitor visitor); @Override String getDescription(); @Override String toString(); } | @Test public void test_tryGetPackageInfo() { JavaPackage annotatedPackage = importPackage("packageexamples.annotated"); JavaPackage nonAnnotatedPackage = importPackage("packageexamples"); assertThat(annotatedPackage.tryGetPackageInfo()).isPresent(); assertThat(nonAnnotatedPackage.tryGetPackageInfo()).isAbsent(); } |
JavaPackage implements HasName, HasAnnotations<JavaPackage> { @Override @PublicAPI(usage = ACCESS) public Set<? extends JavaAnnotation<JavaPackage>> getAnnotations() { if (packageInfo.isPresent()) { return FluentIterable.from(packageInfo.get().getAnnotations()).transform(toGuava(withSelfAsOwner)).toSet(); } return emptySet(); } private JavaPackage(String name, Set<JavaClass> classes, Map<String, JavaPackage> subPackages); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) String getRelativeName(); @PublicAPI(usage = ACCESS) HasAnnotations<?> getPackageInfo(); @PublicAPI(usage = ACCESS) Optional<? extends HasAnnotations<?>> tryGetPackageInfo(); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<JavaPackage>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaPackage> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaPackage>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) Optional<JavaPackage> getParent(); @PublicAPI(usage = ACCESS) Set<JavaClass> getClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClasses(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getSubPackages(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getAllSubPackages(); @PublicAPI(usage = ACCESS) boolean containsClass(JavaClass clazz); @PublicAPI(usage = ACCESS) boolean containsClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClass getClass(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean containsClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) boolean containsClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) boolean containsPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesToSelf(); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaPackage> predicate, PackageVisitor visitor); @Override String getDescription(); @Override String toString(); } | @Test public void test_getAnnotations() { JavaPackage annotatedPackage = importPackage("packageexamples.annotated"); JavaPackage nonAnnotatedPackage = importPackage("packageexamples"); JavaAnnotation<JavaPackage> annotation = getOnlyElement(annotatedPackage.getAnnotations()); assertThatType(annotation.getRawType()).matches(PackageLevelAnnotation.class); assertThat(annotation.getOwner()).isEqualTo(annotatedPackage); assertThat(nonAnnotatedPackage.getAnnotations()).isEmpty(); } |
JavaPackage implements HasName, HasAnnotations<JavaPackage> { @Override @PublicAPI(usage = ACCESS) public <A extends Annotation> Optional<A> tryGetAnnotationOfType(Class<A> type) { if (packageInfo.isPresent()) { return packageInfo.get().tryGetAnnotationOfType(type); } return Optional.absent(); } private JavaPackage(String name, Set<JavaClass> classes, Map<String, JavaPackage> subPackages); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) String getRelativeName(); @PublicAPI(usage = ACCESS) HasAnnotations<?> getPackageInfo(); @PublicAPI(usage = ACCESS) Optional<? extends HasAnnotations<?>> tryGetPackageInfo(); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<JavaPackage>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaPackage> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaPackage>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) Optional<JavaPackage> getParent(); @PublicAPI(usage = ACCESS) Set<JavaClass> getClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClasses(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getSubPackages(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getAllSubPackages(); @PublicAPI(usage = ACCESS) boolean containsClass(JavaClass clazz); @PublicAPI(usage = ACCESS) boolean containsClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClass getClass(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean containsClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) boolean containsClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) boolean containsPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesToSelf(); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaPackage> predicate, PackageVisitor visitor); @Override String getDescription(); @Override String toString(); } | @Test public void test_tryGetAnnotationOfType_type() { JavaPackage annotatedPackage = importPackage("packageexamples.annotated"); JavaPackage nonAnnotatedPackage = importPackage("packageexamples"); assertThat(annotatedPackage.tryGetAnnotationOfType(PackageLevelAnnotation.class)).isPresent(); assertThat(annotatedPackage.tryGetAnnotationOfType(Deprecated.class)).isAbsent(); assertThat(nonAnnotatedPackage.tryGetAnnotationOfType(Deprecated.class)).isAbsent(); } |
JavaPackage implements HasName, HasAnnotations<JavaPackage> { @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> annotationType) { if (packageInfo.isPresent()) { return packageInfo.get().isAnnotatedWith(annotationType); } return false; } private JavaPackage(String name, Set<JavaClass> classes, Map<String, JavaPackage> subPackages); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) String getRelativeName(); @PublicAPI(usage = ACCESS) HasAnnotations<?> getPackageInfo(); @PublicAPI(usage = ACCESS) Optional<? extends HasAnnotations<?>> tryGetPackageInfo(); @Override @PublicAPI(usage = ACCESS) Set<? extends JavaAnnotation<JavaPackage>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaPackage> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaPackage>> tryGetAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @PublicAPI(usage = ACCESS) Optional<JavaPackage> getParent(); @PublicAPI(usage = ACCESS) Set<JavaClass> getClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClasses(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getSubPackages(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getAllSubPackages(); @PublicAPI(usage = ACCESS) boolean containsClass(JavaClass clazz); @PublicAPI(usage = ACCESS) boolean containsClass(Class<?> clazz); @PublicAPI(usage = ACCESS) JavaClass getClass(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean containsClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithFullyQualifiedName(String className); @PublicAPI(usage = ACCESS) boolean containsClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) JavaClass getClassWithSimpleName(String className); @PublicAPI(usage = ACCESS) boolean containsPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getClassDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaPackage> getPackageDependenciesToSelf(); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaClass> predicate, ClassVisitor visitor); @PublicAPI(usage = ACCESS) void accept(Predicate<? super JavaPackage> predicate, PackageVisitor visitor); @Override String getDescription(); @Override String toString(); } | @Test public void test_isAnnotatedWith_type() { JavaPackage annotatedPackage = importPackage("packageexamples.annotated"); JavaPackage nonAnnotatedPackage = importPackage("packageexamples"); assertThat(annotatedPackage.isAnnotatedWith(PackageLevelAnnotation.class)).isTrue(); assertThat(annotatedPackage.isAnnotatedWith(Deprecated.class)).isFalse(); assertThat(nonAnnotatedPackage.isAnnotatedWith(Deprecated.class)).isFalse(); }
@Test public void test_isAnnotatedWith_predicate() { JavaPackage annotatedPackage = importPackage("packageexamples.annotated"); JavaPackage nonAnnotatedPackage = importPackage("packageexamples"); assertThat(annotatedPackage.isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())).isTrue(); assertThat(annotatedPackage.isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())).isFalse(); assertThat(nonAnnotatedPackage.isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())).isFalse(); assertThat(nonAnnotatedPackage.isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())).isFalse(); } |
NeverCondition extends ArchCondition<T> { @Override public void init(Iterable<T> allObjectsToTest) { condition.init(allObjectsToTest); } NeverCondition(ArchCondition<T> condition); @Override void init(Iterable<T> allObjectsToTest); @Override void finish(ConditionEvents events); @Override void check(T item, ConditionEvents events); @Override String toString(); } | @Test public void inits_inverted_condition() { ConditionWithInitAndFinish original = someCondition("anything"); ArchCondition<String> never = never(original); never.init(Collections.singleton("something")); assertThat(original.allObjectsToTest).containsExactly("something"); } |
JavaFieldAccess extends JavaAccess<FieldAccessTarget> { @Override public int hashCode() { return 31 * super.hashCode() + accessType.hashCode(); } JavaFieldAccess(JavaFieldAccessBuilder builder); @PublicAPI(usage = ACCESS) AccessType getAccessType(); @Override int hashCode(); @Override boolean equals(Object obj); } | @Test public void equals_should_work() throws Exception { JavaClass clazz = importClassWithContext(SomeClass.class); JavaFieldAccess access = stringFieldAccessRecordBuilder(clazz) .withOrigin(accessFieldMethod(clazz)) .build(); JavaFieldAccess equalAccess = stringFieldAccessRecordBuilder(clazz) .withOrigin(accessFieldMethod(clazz)) .build(); assertThat(access).isEqualTo(access); assertThat(access.hashCode()).isEqualTo(access.hashCode()); assertThat(access).isEqualTo(equalAccess); assertThat(access.hashCode()).isEqualTo(equalAccess.hashCode()); JavaFieldAccess otherAccessType = stringFieldAccessRecordBuilder(clazz) .withAccessType(SET) .withOrigin(accessFieldMethod(clazz)) .build(); JavaFieldAccess otherLineNumber = stringFieldAccessRecordBuilder(clazz) .withOrigin(accessFieldMethod(clazz)) .withLineNumber(999) .build(); JavaFieldAccess otherTarget = stringFieldAccessRecordBuilder(clazz) .withOrigin(accessFieldMethod(clazz)) .withTarget(targetFrom(clazz.getField("intField"))) .build(); JavaFieldAccess otherCaller = stringFieldAccessRecordBuilder(clazz) .withOrigin(clazz.getMethod("accessInt")) .build(); assertThat(access).isNotEqualTo(otherAccessType); assertThat(access).isNotEqualTo(otherLineNumber); assertThat(access).isNotEqualTo(otherTarget); assertThat(access).isNotEqualTo(otherCaller); } |
AnnotationProxy { public static <A extends Annotation> A of(Class<A> annotationType, JavaAnnotation<?> toProxy) { checkArgument(annotationType.getName().equals(toProxy.getRawType().getName()), "Requested annotation type %s is incompatible with %s of type %s", annotationType.getSimpleName(), JavaAnnotation.class.getSimpleName(), toProxy.getRawType().getSimpleName()); return newProxy(annotationType, toProxy); } static A of(Class<A> annotationType, JavaAnnotation<?> toProxy); } | @Test public void wrong_annotation_type_is_rejected() { JavaAnnotation<?> mismatch = javaAnnotationFrom(TestAnnotation.class.getAnnotation(Retention.class), getClass()); thrown.expect(IllegalArgumentException.class); thrown.expectMessage(Retention.class.getSimpleName()); thrown.expectMessage(TestAnnotation.class.getSimpleName()); thrown.expectMessage("incompatible"); AnnotationProxy.of(TestAnnotation.class, mismatch); } |
JavaWildcardType implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public String getName() { return WILDCARD_TYPE_NAME; } JavaWildcardType(JavaWildcardTypeBuilder builder); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @PublicAPI(usage = ACCESS) List<JavaType> getLowerBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); } | @Test public void wildcard_name() { @SuppressWarnings("unused") class ClassWithUnboundTypeParameter<T extends List<?>> { } JavaWildcardType type = importWildcardTypeOf(ClassWithUnboundTypeParameter.class); assertThat(type.getName()).isEqualTo("?"); } |
JavaWildcardType implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public List<JavaType> getUpperBounds() { return upperBounds; } JavaWildcardType(JavaWildcardTypeBuilder builder); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @PublicAPI(usage = ACCESS) List<JavaType> getLowerBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); } | @Test public void wildcard_upper_bounds() { @SuppressWarnings("unused") class ClassWithUnboundTypeParameter<T extends List<? extends Serializable>> { } JavaWildcardType type = importWildcardTypeOf(ClassWithUnboundTypeParameter.class); assertThatTypes(type.getUpperBounds()).matchExactly(Serializable.class); } |
JavaWildcardType implements JavaType, HasUpperBounds { @PublicAPI(usage = ACCESS) public List<JavaType> getLowerBounds() { return lowerBounds; } JavaWildcardType(JavaWildcardTypeBuilder builder); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @PublicAPI(usage = ACCESS) List<JavaType> getLowerBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); } | @Test public void wildcard_lower_bounds() { @SuppressWarnings("unused") class ClassWithUnboundTypeParameter<T extends List<? super Serializable>> { } JavaWildcardType type = importWildcardTypeOf(ClassWithUnboundTypeParameter.class); assertThatTypes(type.getLowerBounds()).matchExactly(Serializable.class); } |
JavaWildcardType implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return erasure; } JavaWildcardType(JavaWildcardTypeBuilder builder); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @PublicAPI(usage = ACCESS) List<JavaType> getLowerBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); } | @Test public void erased_unbound_wildcard_is_java_lang_Object() { @SuppressWarnings("unused") class ClassWithUnboundWildcard<T extends List<?>> { } JavaWildcardType type = importWildcardTypeOf(ClassWithUnboundWildcard.class); assertThatType(type.toErasure()).matches(Object.class); }
@Test public void erased_wildcard_bound_by_single_class_is_this_class() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithSingleClassBound<T extends List<? extends Serializable>> { } JavaWildcardType type = importWildcardTypeOf(ClassWithBoundTypeParameterWithSingleClassBound.class); assertThatType(type.toErasure()).matches(Serializable.class); }
@Test public void erased_wildcard_bound_by_single_generic_class_is_the_erasure_of_this_class() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithSingleGenericClassBound<T extends List<? extends List<String>>> { } JavaWildcardType type = importWildcardTypeOf(ClassWithBoundTypeParameterWithSingleGenericClassBound.class); assertThatType(type.toErasure()).matches(List.class); }
@Test public void erased_wildcard_bound_by_concrete_array_type_is_array_type() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithSingleGenericArrayBound<T extends List<? extends Object[]>, U extends List<? extends String[][]>, V extends List<? extends List<?>[][][]>> { } JavaWildcardType wildcard = importWildcardTypeOf(ClassWithBoundTypeParameterWithSingleGenericArrayBound.class, 0); assertThatType(wildcard.toErasure()).matches(Object[].class); wildcard = importWildcardTypeOf(ClassWithBoundTypeParameterWithSingleGenericArrayBound.class, 1); assertThatType(wildcard.toErasure()).matches(String[][].class); wildcard = importWildcardTypeOf(ClassWithBoundTypeParameterWithSingleGenericArrayBound.class, 2); assertThatType(wildcard.toErasure()).matches(List[][][].class); }
@Test public void erased_wildcard_bound_by_generic_array_type_is_array_with_erasure_component_type() { @SuppressWarnings("unused") class ClassWithBoundTypeParameterWithGenericArrayBounds<A, B extends String, C extends List<?>, T extends List<? extends A[]>, U extends List<? extends B[][]>, V extends List<? extends C[][][]>> { } JavaWildcardType wildcard = importWildcardTypeOf(ClassWithBoundTypeParameterWithGenericArrayBounds.class, 3); assertThatType(wildcard.toErasure()).matches(Object[].class); wildcard = importWildcardTypeOf(ClassWithBoundTypeParameterWithGenericArrayBounds.class, 4); assertThatType(wildcard.toErasure()).matches(String[][].class); wildcard = importWildcardTypeOf(ClassWithBoundTypeParameterWithGenericArrayBounds.class, 5); assertThatType(wildcard.toErasure()).matches(List[][][].class); } |
JavaWildcardType implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = boundsToString(); return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } JavaWildcardType(JavaWildcardTypeBuilder builder); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @PublicAPI(usage = ACCESS) List<JavaType> getLowerBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); } | @Test public void toString_unbounded() { @SuppressWarnings("unused") class Unbounded<T extends List<?>> { } JavaWildcardType wildcardType = importWildcardTypeOf(Unbounded.class); assertThat(wildcardType.toString()) .contains(JavaWildcardType.class.getSimpleName()) .contains("?") .doesNotContain("extends") .doesNotContain("super"); }
@Test public void toString_upper_bounded() { @SuppressWarnings("unused") class UpperBounded<T extends List<? extends String>> { } JavaWildcardType wildcardType = importWildcardTypeOf(UpperBounded.class); assertThat(wildcardType.toString()) .contains(JavaWildcardType.class.getSimpleName()) .contains("? extends java.lang.String") .doesNotContain("super"); }
@Test public void toString_lower_bounded() { @SuppressWarnings("unused") class LowerBounded<T extends List<? super String>> { } JavaWildcardType wildcardType = importWildcardTypeOf(LowerBounded.class); assertThat(wildcardType.toString()) .contains(JavaWildcardType.class.getSimpleName()) .contains("? super java.lang.String") .doesNotContain("extends"); } |
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public JavaClass toErasure() { return this; } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); } | @Test public void erased_type_of_class_is_the_class_itself() { class SimpleClass { } JavaType type = new ClassFileImporter().importClass(SimpleClass.class); assertThat(type.toErasure()).isEqualTo(type); } |
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public Set<JavaConstructor> getConstructors() { return constructors; } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); } | @Test public void finds_constructors() { JavaClass javaClass = importClassWithContext(ClassWithSeveralConstructorsFieldsAndMethods.class); assertThat(javaClass.getConstructors()).hasSize(3); assertThat(javaClass.getConstructors()).is(containing(codeUnitWithSignature(CONSTRUCTOR_NAME))); assertThat(javaClass.getConstructors()).is(containing(codeUnitWithSignature(CONSTRUCTOR_NAME, String.class))); assertThat(javaClass.getConstructors()).is(containing(codeUnitWithSignature(CONSTRUCTOR_NAME, int.class, Object[].class))); } |
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public boolean isAnnotatedWith(Class<? extends Annotation> annotationType) { return isAnnotatedWith(annotationType.getName()); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); } | @Test public void isAnnotatedWith_predicate() { assertThat(importClassWithContext(Parent.class) .isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())) .as("predicate matches").isTrue(); assertThat(importClassWithContext(Parent.class) .isAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())) .as("predicate matches").isFalse(); } |
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public boolean isMetaAnnotatedWith(Class<? extends Annotation> type) { return isMetaAnnotatedWith(type.getName()); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); } | @Test public void isMetaAnnotatedWith_predicate() { JavaClass clazz = importClassesWithContext(Parent.class, SomeAnnotation.class).get(Parent.class); assertThat(clazz .isMetaAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue())) .as("predicate matches").isTrue(); assertThat(clazz .isMetaAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysFalse())) .as("predicate matches").isFalse(); } |
JavaClass implements JavaType, HasName.AndFullName, HasAnnotations<JavaClass>, HasModifiers, HasSourceCodeLocation { @PublicAPI(usage = ACCESS) public boolean isEquivalentTo(Class<?> clazz) { return getName().equals(clazz.getName()); } JavaClass(JavaClassBuilder builder); @PublicAPI(usage = ACCESS) Optional<Source> getSource(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @PublicAPI(usage = ACCESS) String getSimpleName(); @PublicAPI(usage = ACCESS) JavaPackage getPackage(); @PublicAPI(usage = ACCESS) String getPackageName(); @PublicAPI(usage = ACCESS) boolean isPrimitive(); @PublicAPI(usage = ACCESS) boolean isInterface(); @PublicAPI(usage = ACCESS) boolean isEnum(); @PublicAPI(usage = ACCESS) Optional<JavaEnumConstant> tryGetEnumConstant(String name); @PublicAPI(usage = ACCESS) JavaEnumConstant getEnumConstant(String name); @PublicAPI(usage = ACCESS) Set<JavaEnumConstant> getEnumConstants(); @PublicAPI(usage = ACCESS) boolean isArray(); @PublicAPI(usage = ACCESS) JavaClass getComponentType(); @PublicAPI(usage = ACCESS) boolean isTopLevelClass(); @PublicAPI(usage = ACCESS) boolean isNestedClass(); @PublicAPI(usage = ACCESS) boolean isMemberClass(); @PublicAPI(usage = ACCESS) boolean isInnerClass(); @PublicAPI(usage = ACCESS) boolean isLocalClass(); @PublicAPI(usage = ACCESS) boolean isAnonymousClass(); @Override @PublicAPI(usage = ACCESS) Set<JavaModifier> getModifiers(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> type); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(String typeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) A getAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) JavaAnnotation<JavaClass> getAnnotationOfType(String typeName); @Override @PublicAPI(usage = ACCESS) Set<JavaAnnotation<JavaClass>> getAnnotations(); @Override @PublicAPI(usage = ACCESS) Optional<A> tryGetAnnotationOfType(Class<A> type); @Override @PublicAPI(usage = ACCESS) Optional<JavaAnnotation<JavaClass>> tryGetAnnotationOfType(String typeName); @PublicAPI(usage = ACCESS) List<JavaTypeVariable> getTypeParameters(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getSuperClass(); @PublicAPI(usage = ACCESS) List<JavaClass> getClassHierarchy(); @PublicAPI(usage = ACCESS) List<JavaClass> getAllSuperClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaClass> getInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllInterfaces(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllClassesSelfIsAssignableTo(); @PublicAPI(usage = ACCESS) Optional<JavaClass> getEnclosingClass(); @PublicAPI(usage = ACCESS) Set<JavaClass> getAllSubClasses(); @PublicAPI(usage = ACCESS) Set<JavaMember> getMembers(); @PublicAPI(usage = ACCESS) Set<JavaMember> getAllMembers(); @PublicAPI(usage = ACCESS) Set<JavaField> getFields(); @PublicAPI(usage = ACCESS) Set<JavaField> getAllFields(); @PublicAPI(usage = ACCESS) JavaField getField(String name); @PublicAPI(usage = ACCESS) Optional<JavaField> tryGetField(String name); @PublicAPI(usage = ACCESS) Set<JavaCodeUnit> getCodeUnits(); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, String... parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypes(String name, List<Class<?>> parameters); @PublicAPI(usage = ACCESS) JavaCodeUnit getCodeUnitWithParameterTypeNames(String name, List<String> parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaMethod getMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaMethod> tryGetMethod(String name, String... parameters); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethods(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getAllMethods(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) JavaConstructor getConstructor(String... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(Class<?>... parameters); @PublicAPI(usage = ACCESS) Optional<JavaConstructor> tryGetConstructor(String... parameters); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructors(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getAllConstructors(); @PublicAPI(usage = ACCESS) Optional<JavaStaticInitializer> getStaticInitializer(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAllAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaCall<?>> getCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesFromSelf(); @PublicAPI(usage = ACCESS) Set<Dependency> getDirectDependenciesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaFieldAccess> getFieldAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethodCall> getMethodCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructorCall> getConstructorCallsToSelf(); @PublicAPI(usage = ACCESS) Set<JavaAccess<?>> getAccessesToSelf(); @PublicAPI(usage = ACCESS) Set<JavaField> getFieldsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaMethod> getMethodsWithReturnTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaMethod>> getMethodThrowsDeclarationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaConstructor> getConstructorsWithParameterTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<ThrowsDeclaration<JavaConstructor>> getConstructorsWithThrowsDeclarationTypeOfSelf(); @PublicAPI(usage = ACCESS) Set<JavaAnnotation<?>> getAnnotationsWithTypeOfSelf(); @PublicAPI(usage = ACCESS) boolean isEquivalentTo(Class<?> clazz); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableFrom(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) boolean isAssignableTo(Class<?> type); @PublicAPI(usage = ACCESS) boolean isAssignableTo(final String typeName); @PublicAPI(usage = ACCESS) boolean isAssignableTo(DescribedPredicate<? super JavaClass> predicate); @ResolvesTypesViaReflection @PublicAPI(usage = ACCESS) Class<?> reflect(); @Override String toString(); @PublicAPI(usage = ACCESS) static List<String> namesOf(Class<?>... paramTypes); @PublicAPI(usage = ACCESS) static List<String> namesOf(Iterable<Class<?>> paramTypes); @Deprecated @PublicAPI(usage = ACCESS) boolean isAnonymous(); } | @Test public void JavaClass_is_equivalent_to_reflect_type() { JavaClass list = importClassWithContext(List.class); assertThat(list.isEquivalentTo(List.class)).as("JavaClass is List.class").isTrue(); assertThat(list.isEquivalentTo(Collection.class)).as("JavaClass is Collection.class").isFalse(); } |
QuickSort extends AbstractSort<E> { public void sort(SortableCollection<E> sortable) { int n = sortable.size(); FJQuickSort<E> qsort = new FJQuickSort<>(comparator,swapper); qsort.qsort(sortable, 0, n-1); } void sort(SortableCollection<E> sortable); } | @Test public void canSortStrings() { final String[] actualNames = new String[]{ "Johnson", "Wilson", "Wilkinson", "Abraham", "Dagobert" }; final String[] expected = new String[]{"Abraham", "Dagobert", "Johnson", "Wilkinson", "Wilson"}; Sort<String> sort = new QuickSort<>(); sort.setComparator(String::compareTo); sort.setSwapper(new ArraySwapper<String>(actualNames)); sort.sort(new ArrayWrapper<>(actualNames)); Assert.assertArrayEquals(expected, actualNames); }
@Test public void canSortOne() { final String[] actualNames = new String[]{"Abraham"}; final String[] expected = new String[]{"Abraham"}; Sort<String> sort = new QuickSort<>(); sort.setComparator(String::compareTo); sort.setSwapper(new ArraySwapper<String>(actualNames)); sort.sort(new ArrayWrapper<>(actualNames)); Assert.assertArrayEquals(expected, actualNames); }
@Test public void canSortAlreadySorted() { final String[] actualNames = new String[]{"Abraham", "Dagobert"}; final String[] expected = new String[]{"Abraham", "Dagobert"}; Sort<String> sort = new QuickSort<>(); sort.setComparator(String::compareTo); sort.setSwapper(new ArraySwapper<String>(actualNames)); sort.sort(new ArrayWrapper<>(actualNames)); Assert.assertArrayEquals(expected, actualNames); } |
ResourceBasedProductLookup implements ProductLookup { @Override public List<String> byQuery(String query) { log.info("query is {}", query); loadProducts(); List<String> pis = new LinkedList<>(); StringTokenizer st = new StringTokenizer(query, "&="); while (st.hasMoreTokens()) { final String key = st.nextToken(); if (st.hasMoreTokens()) { final String value = st.nextToken(); log.debug("processing {}={} query", key, value); if (!"title".equals(key)) { log.error("Search by title is allowed only"); return noProducts; } for (String id : products.keySet()) { log.error("key: {} value:{} id:{}", key, value, id); ProductInformation pi = products.get(id); if (pi.getTitle().startsWith(value)) { pis.add(id); } } } } return pis; } @Override ProductInformation byId(String id); @Override List<String> byQuery(String query); } | @Test public void queryFindsMultipleTitles(){ ProductLookup pl = new ResourceBasedProductLookup(); List<String> pis = pl.byQuery("title=D&title=B"); Assert.assertEquals(pis.size(),3); } |
UniqueGuesser extends Guesser { @Override protected Guess nextGuess() { Guess guess = super.nextGuess(); while (guess.isNotUnique()) { guess = super.nextGuess(); } return guess; } @Inject UniqueGuesser(Table table); } | @Test public void generateAllGuesses() { int numberOfGuesses = 0; Table table = new Table(NR_COLUMNS, manager); Guesser guesser = new UniqueGuesser(table); while (guesser.nextGuess() != Guess.none) { numberOfGuesses++; } Assert.assertEquals(6 * 5 * 4 * 3, numberOfGuesses); } |
Row { public boolean matches(Guess guess) { return this.guess.nrOfPartialMatches(guess) == partial && this.guess.nrOfFullMatches(guess) == full; } Row(Guess guess, int full, int partial); protected Row(Row cloneFrom); void setFull(int full); void setPartial(int partial); boolean matches(Guess guess); int nrOfColumns(); String toString(); int getFull(); int getPartial(); Color getColor(int column); static final Row none; } | @Test public void allColorsAndPositionsMatch() { Color[] colors = firstColors(); Guess guess = new Guess(colors); Row row = new Row(guess, NR_COLUMNS, 0); Assert.assertTrue(row.matches(guess)); }
@Test public void allButOneColorsAndPositionsMatch() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Color[] colors = firstColors(); Row row = new Row(new Guess(colors), NR_COLUMNS - 1, 0); stepTheLastColor(colors); Assert.assertTrue(row.matches(new Guess(colors))); }
@Test public void twoColorsWrongPositionOtherGoodPosition() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Color[] colors = firstColors(); Row row = new Row(new Guess(colors), NR_COLUMNS - 2, 2); Color swap = colors[0]; colors[0] = colors[1]; colors[1] = swap; Assert.assertTrue(row.matches(new Guess(colors))); } |
Game { public Row addNewGuess(Guess guess) { final int full = secret.nrOfFullMatches(guess); final int partial = secret.nrOfPartialMatches(guess); return addGuess(guess, full, partial); } Game(Table table, Guess secret); void setFinished(); Row addGuess(Guess guess, int full, int partial); Row addNewGuess(Guess guess); boolean isFinished(); Table getTable(); } | @Test public void canAddNewGuess() { createTestGame(); game.addNewGuess(secret); }
@Test(expected = IllegalArgumentException.class) public void throwsExceptionForFinishedGame() { createTestGame(); game.addNewGuess(secret); game.addNewGuess(secret); } |
ColorManager { public Color firstColor() { return first; } @Inject ColorManager(@Named("nrColors") int nrColors, ColorFactory factory); Color firstColor(); boolean thereIsNextColor(Color color); Color nextColor(Color color); int getNrColors(); } | @Test public void thereIsAFirstColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNotNull(manager.firstColor()); } |
ColorManager { public Color nextColor(Color color) { return successor.get(color); } @Inject ColorManager(@Named("nrColors") int nrColors, ColorFactory factory); Color firstColor(); boolean thereIsNextColor(Color color); Color nextColor(Color color); int getNrColors(); } | @Test public void noColorHasNoNextColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNull(manager.nextColor(Color.none)); } |
UniqueGuesser extends Guesser { @Override protected Guess nextGuess() { Guess guess = super.nextGuess(); while (!guess.isUnique()) { guess = super.nextGuess(); } return guess; } UniqueGuesser(Table table); } | @Test public void generateAllGuesses() { int numberOfGuesses = 0; Table table = new Table(NR_COLUMNS, manager); Guesser guesser = new UniqueGuesser(table); while (guesser.nextGuess() != Guess.none) { numberOfGuesses++; } Assert.assertEquals(6 * 5 * 4 * 3, numberOfGuesses); } |
Row { public boolean matches(Guess guess) { return this.guess.nrOfPartialMatches(guess) == partial && this.guess.nrOfFullMatches(guess) == full; } Row(Guess guess, int full, int partial); protected Row(Row cloneFrom); boolean matches(Guess guess); int nrOfColumns(); String toString(); static final Row none; } | @Test public void allColorsAndPositionsMatch() { Color[] colors = firstColors(); Guess guess = new Guess(colors); Row row = new Row(guess, NR_COLUMNS, 0); Assert.assertTrue(row.matches(guess)); }
@Test public void allButOneColorsAndPositionsMatch() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Color[] colors = firstColors(); Row row = new Row(new Guess(colors), NR_COLUMNS - 1, 0); stepTheLastColor(colors); Assert.assertTrue(row.matches(new Guess(colors))); }
@Test public void twoColorsWrongPositionOtherGoodPosition() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Color[] colors = firstColors(); Row row = new Row(new Guess(colors), NR_COLUMNS - 2, 2); Color swap = colors[0]; colors[0] = colors[1]; colors[1] = swap; Assert.assertTrue(row.matches(new Guess(colors))); } |
Game { public Row addNewGuess(Guess guess) { assertNotFinished(); final int full = secret.nrOfFullMatches(guess); final int partial = secret.nrOfPartialMatches(guess); final Row row = new Row(guess,full,partial); table.addRow(row); if (itWasAWinningGuess(full)) { finished = true; } return row; } Game(Table table, Guess secret); Row addNewGuess(Guess guess); boolean isFinished(); } | @Test public void canAddNewGuess() { createTestGame(); game.addNewGuess(secret); }
@Test(expected = IllegalArgumentException.class) public void throwsExceptionForFinishedGame() { createTestGame(); game.addNewGuess(secret); game.addNewGuess(secret); } |
ColorManager { public Color firstColor() { return first; } ColorManager(int nrColors, ColorFactory factory); Color firstColor(); boolean thereIsNextColor(Color color); Color nextColor(Color color); int getNrColors(); } | @Test public void thereIsAFirstColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNotNull(manager.firstColor()); } |
ColorManager { public Color nextColor(Color color) { return successor.get(color); } ColorManager(int nrColors, ColorFactory factory); Color firstColor(); boolean thereIsNextColor(Color color); Color nextColor(Color color); int getNrColors(); } | @Test public void noColorHasNoNextColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNull(manager.nextColor(Color.none)); } |
Partitioner { public int partition(SortableCollection<E> sortable, int start, int end, E pivot) { int small = start; int large = end; while (large > small) { while (comparator.compare(sortable.get(small), pivot) < 0 && small < large ) { small++; } while (comparator.compare(sortable.get(large), pivot) >= 0 && small < large) { large--; } if (small < large) { swapper.swap(small, large); } } return large; } Partitioner(Comparator<E> comparator, Swapper swapper); int partition(SortableCollection<E> sortable, int start, int end, E pivot); } | @Test public void partitionsIntArray() { Integer[] partitionThis = new Integer[]{0, 7, 6, 2}; Swapper swapper = new ArraySwapper<>(partitionThis); Partitioner<Integer> partitioner = new Partitioner<>((a, b) -> a < b ? -1 : a > b ? +1 : 0, swapper); final Integer pivot = 6; final int cutIndex = partitioner.partition(new ArrayWrapper<>(partitionThis), 0, partitionThis.length-1, pivot); Assert.assertEquals(2, cutIndex); final Integer[] expected = new Integer[]{0, 2, 6, 7}; Assert.assertArrayEquals(expected,partitionThis); } |
UniqueGuesser extends Guesser { @Override protected Color[] nextGuess() { Color[] guess = super.nextGuess(); while (isNotUnique(guess)) { guess = super.nextGuess(); } return guess; } UniqueGuesser(Table table); } | @Test public void generateAllGuesses() { int numberOfGuesses = 0; ColorManager manager = new ColorManager(NR_COLORS); Table table = new Table(NR_COLUMNS, manager); Guesser guesser = new UniqueGuesser(table); while (guesser.nextGuess() != Guesser.none) { numberOfGuesses++; } Assert.assertEquals(6 * 5 * 4 * 3, numberOfGuesses); } |
Row { public void setMatch(int matchedPositions, int matchedColors) { if (matchedColors + matchedPositions > positions.length) { throw new IllegalArgumentException( "Number of matches can not be more that the position."); } this.matchedColors = matchedColors; this.matchedPositions = matchedPositions; } Row(Color[] positions); protected Row(Row cloneFrom); void setMatch(int matchedPositions, int matchedColors); boolean guessMatches(Color[] guess); int nrMatchingColors(Color[] guess); int nrMatchingPositions(Color[] guess); int nrOfColumns(); static final Row none; } | @Test(expected = IllegalArgumentException.class) public void throwsIAEForInvalidMatchParameters(){ Row row = new Row(new Color[NR_COLUMNS]); row.setMatch(NR_COLUMNS,1); } |
Game { public void addNewGuess(Row row) { if (isFinished()) { throw new IllegalArgumentException("You can not guess on a finished game."); } final int positionMatch = secretRow.nrMatchingPositions(row.positions); final int colorMatch = secretRow.nrMatchingColors(row.positions); row.setMatch(positionMatch, colorMatch); table.addRow(row); if (itWasAWinningGuess(positionMatch)) { finished = true; } } Game(Table table, Color[] secret); void addNewGuess(Row row); boolean isFinished(); } | @Test public void canAddNewGuess() { createTestGame(); game.addNewGuess(new Row(secret)); }
@Test(expected = IllegalArgumentException.class) public void throwsExceptionForFinishedGame() { createTestGame(); game.addNewGuess(new Row(secret)); game.addNewGuess(new Row(secret)); } |
ColorManager { public Color firstColor() { return first; } ColorManager(int nrColors); Color firstColor(); Color nextColor(Color color); } | @Test public void thereIsAFirstColor() { ColorManager manager = new ColorManager(NR_COLORS); System.out.println(manager.firstColor()); Assert.assertNotNull(manager.firstColor()); } |
ColorManager { public Color nextColor(Color color) { return successor.get(color); } ColorManager(int nrColors); Color firstColor(); Color nextColor(Color color); } | @Test public void noColorHasNoNextColor() { ColorManager manager = new ColorManager(NR_COLORS); Assert.assertNull(manager.nextColor(Color.none)); } |
AwsS3Utils { static String checkBucketIsAccessible(AmazonS3 amazonS3, String bucketName) { HeadBucketRequest headBucketRequest = new HeadBucketRequest(bucketName); try { amazonS3.headBucket(headBucketRequest); } catch (AmazonServiceException e) { throw new AwsS3Exception("Bucket is not accessible", args -> args.add("bucketName", bucketName), e); } return bucketName; } private AwsS3Utils(); static AmazonS3 buildS3Client(@Nullable String accessKey, @Nullable String secretKey, //
@Nullable String endpoint, @Nullable Integer port, @Nullable String region); } | @Test(expectedExceptions = RuntimeException.class, expectedExceptionsMessageRegExp = "Bucket is not accessible.*") public void shouldFindNoS3Bucket() { new Expectations() {{ m_amazonS3.headBucket((HeadBucketRequest) any); AmazonServiceException amazonServiceException = new AmazonServiceException(""); amazonServiceException.setStatusCode(404); result = amazonServiceException; }}; AwsS3Utils.checkBucketIsAccessible(m_amazonS3, "myBucketName"); }
@Test public void shouldFindAS3Bucket() { new Expectations() {{ m_amazonS3.headBucket((HeadBucketRequest) any); result = new HeadBucketResult(); }}; AwsS3Utils.checkBucketIsAccessible(m_amazonS3, "myBucketName"); }
@Test(expectedExceptions = RuntimeException.class, expectedExceptionsMessageRegExp = "Bucket is not accessible.*") public void shouldThrowAnExceptionWhenNoS3BucketFound() { new Expectations() {{ m_amazonS3.headBucket((HeadBucketRequest) any); AmazonServiceException amazonServiceException = new AmazonServiceException(""); amazonServiceException.setStatusCode(401); result = amazonServiceException; }}; AwsS3Utils.checkBucketIsAccessible(m_amazonS3, "myBucketName"); } |
JacksonSerializer implements TransactionSerializer, SnapshotSerializer { @Override public SerializableSnapshot deserializeSnapshot(String storeName, InputStream in) throws IOException { return m_objectMapper.reader().forType(SerializableSnapshot.class).readValue(in); } JacksonSerializer(); @Override void serializeTransaction(OutputStream out, SerializableTransaction transaction); @Override SerializableTransaction deserializeTransaction(InputStream in); @Override void serializeSnapshot(OutputStream out, SerializableSnapshot serializableSnapshot); @Override SerializableSnapshot deserializeSnapshot(String storeName, InputStream in); } | @Test public void shouldProvideTheStoreNameInTheDeSerializedSnapshotWithoutApplicationModelVersion() throws IOException { JacksonSerializer jacksonSerializer = new JacksonSerializer(); InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("io/axway/iron/spi/jackson/simple.snapshot.json"); SerializableSnapshot serializableSnapshot = jacksonSerializer.deserializeSnapshot("myStoreName", inputStream); assertThat(serializableSnapshot.getSnapshotModelVersion()).isEqualTo(123L); assertThat(serializableSnapshot.getApplicationModelVersion()).isEqualTo(0L); assertThat(serializableSnapshot.getTransactionId()).isEqualTo(new BigInteger("123456789")); assertThat(serializableSnapshot.getEntities()).hasSize(1); SerializableEntity serializableEntity = serializableSnapshot.getEntities().stream().findFirst().get(); assertThat(serializableEntity.getNextId()).isEqualTo(1L); assertThat(serializableEntity.getEntityName()).isEqualTo("io.axway.iron.spi.jackson.SimpleEntity"); assertThat(serializableEntity.getRelations()).isEmpty(); assertThat(serializableEntity.getAttributes()).containsOnlyKeys("simpleAttribute"); SerializableAttributeDefinition simpleAttribute = serializableEntity.getAttributes().get("simpleAttribute"); assertThat(simpleAttribute.getDataType()).isEqualTo("java.lang.String"); assertThat(serializableEntity.getUniques()).containsExactly(List.of("simpleAttribute")); assertThat(serializableEntity.getNextId()).isEqualTo(1L); assertThat(serializableEntity.getInstances()).hasSize(1); SerializableInstance serializableInstance = serializableEntity.getInstances().stream().findFirst().get(); assertThat(serializableInstance.getId()).isEqualTo(0L); assertThat(serializableInstance.getValues()).containsOnlyKeys("simpleAttribute"); assertThat(serializableInstance.getValues().get("simpleAttribute")).isEqualTo("simpleAttributeValue"); }
@Test public void shouldProvideTheStoreNameInTheDeSerializedSnapshotWithApplicationModelVersion() throws IOException { JacksonSerializer jacksonSerializer = new JacksonSerializer(); InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("io/axway/iron/spi/jackson/simple.snapshotWithAppModelVersion.json"); SerializableSnapshot serializableSnapshot = jacksonSerializer.deserializeSnapshot("myStoreName", inputStream); assertThat(serializableSnapshot.getApplicationModelVersion()).isEqualTo(666L); } |
StoreManagerBuilderConfigurator { static String getProperty(Properties properties, String key) { String property = properties.getProperty(key); if (property != null) { StringBuffer result = new StringBuffer(); Matcher matcher = VARIABLE_REGEX_PATTERN.matcher(property); while (matcher.find()) { String name = matcher.group("name"); String source = matcher.group("source"); String value = null; if (source == null) { value = getProperty(properties, name); } else if (source.equalsIgnoreCase("env")) { value = System.getenv(name); } else if (source.equalsIgnoreCase("sys")) { value = System.getProperty(name); } if (value == null) { throw new ConfigurationException("Unknown property", args -> args.add("key", key).add("properties", properties)); } matcher.appendReplacement(result, Matcher.quoteReplacement(value)); } matcher.appendTail(result); property = result.toString(); } return property; } void fill(StoreManagerBuilder storeManagerBuilder, String builderName, Properties properties); } | @Test(dataProvider = "getPropertyDataProvider") public void test(String message, String mapProperties, String key, String expectedValue) throws IOException { Properties properties = new Properties(); properties.load(new StringReader(mapProperties)); assertThat(StoreManagerBuilderConfigurator.getProperty(properties, key)).as(message).isEqualTo(expectedValue); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.