Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: StringArray { public static String[] valueOf(String str) { return str.split("\\s,\\s"); } private StringArray(); static String[] valueOf(String str); }### Answer: @Test public void testValueOf() { String[] ary = StringArray.valueOf("a,b"); assertThat(ary, arrayContaining("a", "b")); }
### Question: CharsetConverter implements IStringConverter<Charset> { public Charset convert(String value) { try { return Charset.forName(value); } catch (IllegalCharsetNameException e) { throw new ParameterException("unknown encoding '" + value + "'"); } catch (UnsupportedCharsetException e) { throw new ParameterException("unknown encoding '" + value + "'"); } } Charset convert(String value); }### Answer: @Test public void testConvert() throws Exception { assertThat(cc.convert("UTF-8"), is(Charsets.UTF_8)); } @Test public void testIllegalCharsetName() throws Exception { thrown.expect(ParameterException.class); thrown.expectMessage("unknown encoding"); cc.convert("!@#$%^&*("); } @Test public void testUnknownCharset() throws Exception { assumeThat(Charset.isSupported(UNKNOWN_CHARSET_NAME), is(false)); thrown.expect(ParameterException.class); thrown.expectMessage("unknown encoding"); cc.convert(UNKNOWN_CHARSET_NAME); }
### Question: Main { private void version() { if (lint == null) { lint = lintBuilder.fromDefault(); } info("using jslint version " + lint.getEdition()); throw new DieException(null, 0); } static void main(String[] args); }### Answer: @Test public void testVersion() throws Exception { kaboom.expect(DieException.class); kaboom.expect(hasProperty("code", equalTo(0))); String edition = new JSLintBuilder().fromDefault().getEdition(); try { runLint("--version"); fail("should have thrown DieException"); } catch (DieException e) { List<String> expectedStdout = ImmutableList.of("using jslint version " + edition); assertLintOutput(e.getCode(), 0, expectedStdout, NO_OUTPUT); throw e; } }
### Question: JSFunction { @Override public String toString() { return String.format("function %s()", getName()); } private JSFunction(Builder builder); List<String> getClosure(); List<String> getException(); List<String> getGlobal(); List<String> getLabel(); int getLast(); int getLine(); String getName(); List<String> getOuter(); List<String> getParams(); List<String> getUnused(); List<String> getVars(); @Override String toString(); }### Answer: @Test public void testToString() { JSFunction f = new JSFunction.Builder("fred", 1).build(); assertThat(f.toString(), is("function fred()")); }
### Question: ConditionEvents implements Iterable<ConditionEvent> { @PublicAPI(usage = ACCESS) public boolean isEmpty() { return getAllowed().isEmpty() && getViolating().isEmpty(); } @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(); }### Answer: @Test @UseDataProvider("eventsWithEmpty") public void isEmpty(ConditionEvents events, boolean expectedEmpty) { assertThat(events.isEmpty()).as("events are empty").isEqualTo(expectedEmpty); }
### Question: ContainAnyCondition extends ArchCondition<Collection<? extends T>> { @Override public void check(Collection<? extends T> collection, ConditionEvents events) { ConditionEvents subEvents = new ConditionEvents(); for (T element : collection) { condition.check(element, subEvents); } if (!subEvents.isEmpty()) { events.add(new AnyConditionEvent(collection, subEvents)); } } ContainAnyCondition(ArchCondition<T> condition); @Override void check(Collection<? extends T> collection, ConditionEvents events); @Override String toString(); }### Answer: @Test public void if_there_are_no_input_events_no_ContainsAnyEvent_is_added() { ConditionEvents events = new ConditionEvents(); containOnlyElementsThat(IS_SERIALIZABLE).check(emptyList(), events); assertThat(events.isEmpty()).as("events are empty").isTrue(); } @Test public void satisfied_works_and_description_contains_mismatches() { ConditionEvents events = new ConditionEvents(); containAnyElementThat(IS_SERIALIZABLE).check(TWO_NONSERIALIZABLE_OBJECTS, events); assertThat(events).containViolations(messageForTwoTimes(isSerializableMessageFor(Object.class))); events = new ConditionEvents(); containAnyElementThat(IS_SERIALIZABLE).check(ONE_SERIALIZABLE_AND_ONE_NON_SERIALIZABLE_OBJECT, events); assertThat(events).containNoViolation(); } @Test public void inverting_works() throws Exception { ConditionEvents events = new ConditionEvents(); containAnyElementThat(IS_SERIALIZABLE).check(ONE_SERIALIZABLE_AND_ONE_NON_SERIALIZABLE_OBJECT, events); assertThat(events).containNoViolation(); assertThat(events.getAllowed()).as("Exactly one allowed event occurred").hasSize(1); assertThat(getInverted(events)).containViolations(isSerializableMessageFor(SerializableObject.class)); }
### Question: AccessTarget implements HasName.AndFullName, CanBeAnnotated, HasOwner<JavaClass> { @Override @PublicAPI(usage = ACCESS) public JavaClass getOwner() { return owner; } AccessTarget(JavaClass owner, String name, String fullName); @Override @PublicAPI(usage = ACCESS) String getName(); @Override @PublicAPI(usage = ACCESS) JavaClass getOwner(); @Override @PublicAPI(usage = ACCESS) String getFullName(); @Override int hashCode(); @PublicAPI(usage = ACCESS) abstract Set<? extends JavaMember> resolve(); @Override boolean equals(Object obj); @Override String toString(); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(Class<? extends Annotation> annotationType); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final String annotationTypeName); @Override @PublicAPI(usage = ACCESS) boolean isMetaAnnotatedWith(final DescribedPredicate<? super JavaAnnotation<?>> predicate); }### Answer: @Test public void no_throws_clause_is_resolved() { CodeUnitCallTarget target = getTarget("withoutThrowsDeclaration"); ThrowsClause<CodeUnitCallTarget> throwsClause = target.getThrowsClause(); assertThat(throwsClause).as("throws clause").isEmpty(); assertThat(throwsClause.getTypes()).isEmpty(); assertThat(throwsClause.getOwner()).isEqualTo(target); assertThatType(throwsClause.getDeclaringClass()).matches(Target.class); }
### Question: ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public boolean containsType(Class<?> type) { return containsType(type.getName()); } private ThrowsClause(LOCATION location, List<JavaClass> thrownTypes); @PublicAPI(usage = ACCESS) boolean containsType(Class<?> type); @PublicAPI(usage = ACCESS) boolean containsType(String typeName); @PublicAPI(usage = ACCESS) boolean containsType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) JavaClassList getTypes(); @Override @PublicAPI(usage = ACCESS) LOCATION getOwner(); @PublicAPI(usage = ACCESS) JavaClass getDeclaringClass(); @PublicAPI(usage = ACCESS) int size(); @Override @PublicAPI(usage = ACCESS) Iterator<ThrowsDeclaration<LOCATION>> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void containsType() { JavaMethod method = importMethod(SomeClass.class, "method"); assertAllTrue(contains(method, SQLDataException.class)); assertAllFalse(contains(method, Exception.class)); }
### Question: ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public int size() { return throwsDeclarations.size(); } private ThrowsClause(LOCATION location, List<JavaClass> thrownTypes); @PublicAPI(usage = ACCESS) boolean containsType(Class<?> type); @PublicAPI(usage = ACCESS) boolean containsType(String typeName); @PublicAPI(usage = ACCESS) boolean containsType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) JavaClassList getTypes(); @Override @PublicAPI(usage = ACCESS) LOCATION getOwner(); @PublicAPI(usage = ACCESS) JavaClass getDeclaringClass(); @PublicAPI(usage = ACCESS) int size(); @Override @PublicAPI(usage = ACCESS) Iterator<ThrowsDeclaration<LOCATION>> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void size() { assertThat(importMethod(SomeClass.class, "method").getThrowsClause().size()) .as("size of throws clause").isEqualTo(2); }
### Question: ThrowsClause implements HasOwner<LOCATION>, Iterable<ThrowsDeclaration<LOCATION>> { @PublicAPI(usage = ACCESS) public JavaClassList getTypes() { return new JavaClassList(FluentIterable.from(throwsDeclarations).transform(toGuava(GET_RAW_TYPE)).toList()); } private ThrowsClause(LOCATION location, List<JavaClass> thrownTypes); @PublicAPI(usage = ACCESS) boolean containsType(Class<?> type); @PublicAPI(usage = ACCESS) boolean containsType(String typeName); @PublicAPI(usage = ACCESS) boolean containsType(DescribedPredicate<? super JavaClass> predicate); @PublicAPI(usage = ACCESS) JavaClassList getTypes(); @Override @PublicAPI(usage = ACCESS) LOCATION getOwner(); @PublicAPI(usage = ACCESS) JavaClass getDeclaringClass(); @PublicAPI(usage = ACCESS) int size(); @Override @PublicAPI(usage = ACCESS) Iterator<ThrowsDeclaration<LOCATION>> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void getTypes() { JavaMethod method = importMethod(SomeClass.class, "method"); assertThatTypes(method.getThrowsClause().getTypes()).matchInAnyOrder(IOException.class, SQLDataException.class); }
### Question: JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public JavaClasses that(DescribedPredicate<? super JavaClass> predicate) { Map<String, JavaClass> matchingElements = Guava.Maps.filterValues(classes, predicate); String newDescription = String.format("%s that %s", description, predicate.getDescription()); return new JavaClasses(defaultPackage, matchingElements, newDescription); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void restriction_on_classes_should_filter_the_elements() { JavaClasses onlySomeClass = ALL_CLASSES.that(haveTheNameOf(SomeClass.class)); assertThat(onlySomeClass).containsExactly(SOME_CLASS); }
### Question: JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public boolean contain(Class<?> reflectedType) { return contain(reflectedType.getName()); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void contain_type() { assertThat(ALL_CLASSES.contain(getClass())).isFalse(); assertThat(ALL_CLASSES.contain(SomeOtherClass.class)).isTrue(); }
### Question: JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { @PublicAPI(usage = ACCESS) public JavaClass get(Class<?> reflectedType) { return get(reflectedType.getName()); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void get_returns_correct_JavaClass() { assertThat(ALL_CLASSES.get(SomeOtherClass.class)).isEqualTo(SOME_OTHER_CLASS); assertThat(ALL_CLASSES.get(SomeOtherClass.class.getName())).isEqualTo(SOME_OTHER_CLASS); }
### Question: JavaClasses extends ForwardingCollection<JavaClass> implements DescribedIterable<JavaClass>, CanOverrideDescription<JavaClasses> { static JavaClasses of(Iterable<JavaClass> classes) { Map<String, JavaClass> mapping = new HashMap<>(); for (JavaClass clazz : classes) { mapping.put(clazz.getName(), clazz); } JavaPackage defaultPackage = !Iterables.isEmpty(classes) ? getRoot(classes.iterator().next().getPackage()) : JavaPackage.from(classes); return new JavaClasses(defaultPackage, mapping); } private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes); private JavaClasses(JavaPackage defaultPackage, Map<String, JavaClass> classes, String description); @PublicAPI(usage = ACCESS) JavaClasses that(DescribedPredicate<? super JavaClass> predicate); @Override JavaClasses as(String description); @Override String getDescription(); @Override String toString(); @PublicAPI(usage = ACCESS) boolean contain(Class<?> reflectedType); @PublicAPI(usage = ACCESS) JavaClass get(Class<?> reflectedType); @PublicAPI(usage = ACCESS) boolean contain(String typeName); @PublicAPI(usage = ACCESS) JavaClass get(String typeName); @PublicAPI(usage = ACCESS) boolean containPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getPackage(String packageName); @PublicAPI(usage = ACCESS) JavaPackage getDefaultPackage(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void javaClasses_of_iterable() { ImmutableSet<JavaClass> iterable = ImmutableSet.of(importClassWithContext(JavaClassesTest.class), importClassWithContext(JavaClass.class)); JavaClasses classes = JavaClasses.of(iterable); assertThat(ImmutableSet.copyOf(classes)).isEqualTo(iterable); }
### Question: Source { @PublicAPI(usage = ACCESS) public Optional<String> getFileName() { return fileName; } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); @PublicAPI(usage = ACCESS) URI getUri(); @PublicAPI(usage = ACCESS) Optional<String> getFileName(); @PublicAPI(usage = ACCESS) Md5sum getMd5sum(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void source_file_name() throws URISyntaxException { Source source = new Source(urlOf(Object.class).toURI(), Optional.of("SomeClass.java"), false); assertThat(source.getFileName()).as("source file name").contains("SomeClass.java"); source = new Source(urlOf(Object.class).toURI(), Optional.<String>absent(), false); assertThat(source.getFileName()).as("source file name").isAbsent(); }
### Question: Source { @Override public int hashCode() { return Objects.hash(uri, md5sum); } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); @PublicAPI(usage = ACCESS) URI getUri(); @PublicAPI(usage = ACCESS) Optional<String> getFileName(); @PublicAPI(usage = ACCESS) Md5sum getMd5sum(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test @UseDataProvider("equalMd5Sums") public void positive_equals_hashcode_of_md5sums(Md5sum first, Md5sum second) { assertThat(first).isEqualTo(second); assertThat(first.hashCode()).isEqualTo(second.hashCode()); }
### Question: Source { @PublicAPI(usage = ACCESS) public Md5sum getMd5sum() { return md5sum; } Source(URI uri, Optional<String> fileName, boolean md5InClassSourcesEnabled); @PublicAPI(usage = ACCESS) URI getUri(); @PublicAPI(usage = ACCESS) Optional<String> getFileName(); @PublicAPI(usage = ACCESS) Md5sum getMd5sum(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void compensates_error_on_md5_calculation() throws Exception { Source source = newSource(new URI("bummer")); assertThat(source.getMd5sum()).isEqualTo(Md5sum.UNDETERMINED); }
### Question: Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { @Override @PublicAPI(usage = ACCESS) public String getDescription() { return description; } private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description); @PublicAPI(usage = ACCESS) JavaClass getOriginClass(); @PublicAPI(usage = ACCESS) JavaClass getTargetClass(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) int compareTo(Dependency o); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static JavaClasses toTargetClasses(Iterable<Dependency> dependencies); }### Answer: @Test public void Dependency_from_origin_and_target() { JavaClass origin = importClassWithContext(getClass()); JavaClass target = importClassWithContext(DependencyClass.class); Dependency dependency = createDependency(origin, target); assertThat(dependency.getDescription()).as("description") .contains("Class <" + origin.getName() + "> extends class <" + target.getName() + ">"); target = importClassWithContext(DependencyInterface.class); dependency = createDependency(origin, target); assertThat(dependency.getDescription()).as("description") .contains("Class <" + origin.getName() + "> implements interface <" + target.getName() + ">"); origin = importClassWithContext(DependencySubInterface.class); dependency = createDependency(origin, target); assertThat(dependency.getDescription()).as("description") .contains("Interface <" + origin.getName() + "> extends interface <" + target.getName() + ">"); }
### Question: Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { static Optional<Dependency> tryCreateFromInstanceofCheck(InstanceofCheck instanceofCheck) { return tryCreateDependencyFromJavaMemberWithLocation(instanceofCheck.getOwner(), "checks instanceof", instanceofCheck.getRawType(), instanceofCheck.getLineNumber()); } private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description); @PublicAPI(usage = ACCESS) JavaClass getOriginClass(); @PublicAPI(usage = ACCESS) JavaClass getTargetClass(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) int compareTo(Dependency o); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static JavaClasses toTargetClasses(Iterable<Dependency> dependencies); }### Answer: @Test @UseDataProvider("with_instanceof_check_members") public void Dependency_from_instanceof_check_in_code_unit(JavaCodeUnit memberWithInstanceofCheck, int expectedLineNumber) { InstanceofCheck instanceofCheck = getOnlyElement(memberWithInstanceofCheck.getInstanceofChecks()); Dependency dependency = Dependency.tryCreateFromInstanceofCheck(instanceofCheck).get(); Assertions.assertThatDependency(dependency) .matches(ClassWithDependencyOnInstanceofCheck.class, InstanceOfCheckTarget.class) .hasDescription(memberWithInstanceofCheck.getFullName(), "checks instanceof", InstanceOfCheckTarget.class.getName()) .inLocation(ClassWithDependencyOnInstanceofCheck.class, expectedLineNumber); }
### Question: Dependency implements HasDescription, Comparable<Dependency>, HasSourceCodeLocation { private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description) { this.originClass = originClass; this.targetClass = targetClass; this.lineNumber = lineNumber; this.description = description; this.sourceCodeLocation = SourceCodeLocation.of(originClass, lineNumber); } private Dependency(JavaClass originClass, JavaClass targetClass, int lineNumber, String description); @PublicAPI(usage = ACCESS) JavaClass getOriginClass(); @PublicAPI(usage = ACCESS) JavaClass getTargetClass(); @Override @PublicAPI(usage = ACCESS) String getDescription(); @Override @PublicAPI(usage = ACCESS) SourceCodeLocation getSourceCodeLocation(); @Override @PublicAPI(usage = ACCESS) int compareTo(Dependency o); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @PublicAPI(usage = ACCESS) static JavaClasses toTargetClasses(Iterable<Dependency> dependencies); }### Answer: @Test public void dependency_predicates_descriptions() { assertThat(dependency(Origin.class, Target.class)) .hasSameDescriptionAs(dependency(Origin.class.getName(), Target.class.getName())) .hasDescription("dependency " + Origin.class.getName() + " -> " + Target.class.getName()); assertThat(dependency(predicateWithDescription("first"), predicateWithDescription("second"))) .hasDescription("dependency first -> second"); }
### Question: Transformers { static ClassesTransformer<JavaClass> classes() { return new AbstractClassesTransformer<JavaClass>("classes") { @Override public Iterable<JavaClass> doTransform(JavaClasses collection) { return collection; } }; } }### Answer: @Test public void test_classes() { JavaClasses input = importClasses(Object.class, String.class); DescribedIterable<JavaClass> output = Transformers.classes().transform(input); assertThat(output).containsOnlyElementsOf(input); }
### Question: JavaTypeVariable implements JavaType, HasUpperBounds { @Override @PublicAPI(usage = ACCESS) public String getName() { return name; } JavaTypeVariable(String name, JavaClass erasure); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) List<JavaType> getBounds(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); }### Answer: @Test public void type_variable_name() { @SuppressWarnings("unused") class ClassWithUnboundTypeParameter<SOME_NAME> { } JavaTypeVariable type = new ClassFileImporter().importClass(ClassWithUnboundTypeParameter.class).getTypeParameters().get(0); assertThat(type.getName()).isEqualTo("SOME_NAME"); }
### Question: JavaTypeVariable implements JavaType, HasUpperBounds { @Override public String toString() { String bounds = printExtendsClause() ? " extends " + joinTypeNames(upperBounds) : ""; return getClass().getSimpleName() + '{' + getName() + bounds + '}'; } JavaTypeVariable(String name, JavaClass erasure); @Override @PublicAPI(usage = ACCESS) String getName(); @PublicAPI(usage = ACCESS) List<JavaType> getBounds(); @Override @PublicAPI(usage = ACCESS) List<JavaType> getUpperBounds(); @Override @PublicAPI(usage = ACCESS) JavaClass toErasure(); @Override String toString(); }### Answer: @Test public void toString_unbounded() { @SuppressWarnings("unused") class Unbounded<NAME> { } JavaTypeVariable typeVariable = new ClassFileImporter().importClass(Unbounded.class).getTypeParameters().get(0); assertThat(typeVariable.toString()) .contains(JavaTypeVariable.class.getSimpleName()) .contains("NAME") .doesNotContain("extends"); } @Test public void toString_upper_bounded_by_single_bound() { @SuppressWarnings("unused") class BoundedBySingleBound<NAME extends String> { } JavaTypeVariable typeVariable = new ClassFileImporter().importClass(BoundedBySingleBound.class).getTypeParameters().get(0); assertThat(typeVariable.toString()) .contains(JavaTypeVariable.class.getSimpleName()) .contains("NAME extends java.lang.String"); } @Test public void toString_upper_bounded_by_multiple_bounds() { @SuppressWarnings("unused") class BoundedByMultipleBounds<NAME extends String & Serializable> { } JavaTypeVariable typeVariable = new ClassFileImporter().importClass(BoundedByMultipleBounds.class).getTypeParameters().get(0); assertThat(typeVariable.toString()) .contains(JavaTypeVariable.class.getSimpleName()) .contains("NAME extends java.lang.String & java.io.Serializable"); }
### Question: AbstractClassesTransformer implements ClassesTransformer<T> { @Override public final DescribedIterable<T> transform(JavaClasses collection) { return DescribedIterable.From.iterable(doTransform(collection), description); } protected AbstractClassesTransformer(String description); @Override final DescribedIterable<T> transform(JavaClasses collection); abstract Iterable<T> doTransform(JavaClasses collection); @Override final ClassesTransformer<T> that(final DescribedPredicate<? super T> predicate); @Override final String getDescription(); @Override final ClassesTransformer<T> as(String description); @Override String toString(); }### Answer: @Test public void transform_javaclasses() { AbstractClassesTransformer<String> transformer = toNameTransformer(); JavaClasses classes = importClassesWithContext(AbstractClassesTransformer.class, AbstractClassesTransformerTest.class); DescribedIterable<String> transformed = transformer.transform(classes); assertThat(transformed).containsOnly(AbstractClassesTransformer.class.getName(), AbstractClassesTransformerTest.class.getName()); }
### Question: PluginLoader { public T load() { return supplier.get(); } private PluginLoader(Class<T> pluginType, Map<JavaVersion, String> versionToPlugins, T fallback); static Creator<T> forType(Class<T> pluginType); T load(); }### Answer: @Test public void loads_correct_plugin_for_version() { System.setProperty("java.version", "1.7.0_55"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBeforeJava9); System.setProperty("java.version", "1.8.0_122"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBeforeJava9); System.setProperty("java.version", "9"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "9.0.1"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "11-ea"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "13"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeBetweenJava9AndJava13); System.setProperty("java.version", "14"); assertThat(createPluginLoader().load()).isInstanceOf(pluginTypeAfterJava13); }
### Question: DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysTrue() { return (DescribedPredicate<T>) ALWAYS_TRUE; } 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); }### Answer: @Test public void alwaysTrue_works() { assertThat(alwaysTrue()).accepts(new Object()).hasDescription("always true"); }
### Question: DescribedPredicate implements Predicate<T> { @SuppressWarnings("unchecked") public static <T> DescribedPredicate<T> alwaysFalse() { return (DescribedPredicate<T>) ALWAYS_FALSE; } 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); }### Answer: @Test public void alwaysFalse_works() { assertThat(alwaysFalse()).rejects(new Object()).hasDescription("always false"); }
### Question: 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); }### Answer: @Test public void empty_works() { assertThat(empty()) .hasDescription("empty") .accepts(Collections.emptyList()) .accepts(Collections.emptySet()) .rejects(ImmutableList.of(1)) .rejects(Collections.singleton("")); }
### Question: 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; }### Answer: @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("somepackage"); } @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); }
### Question: 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); }### Answer: @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..']"); }
### Question: 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); }### Answer: @Test public void after() { Integer result = plus(7).after(parseInteger()).apply("11"); assertThat(result).as("Adding 7 after parseInt('11')").isEqualTo(18); }
### Question: 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); }### Answer: @Test public void then() { Integer result = parseInteger().then(plus(7)).apply("11"); assertThat(result).as("parseInt('11') then adding 7").isEqualTo(18); }
### Question: 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); }### Answer: @Test public void is() { assertThat(parseInteger().is(greaterThan(7))) .rejects("7") .accepts("8"); }
### Question: 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); }### Answer: @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); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @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) ); }
### Question: 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(); }### Answer: @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) ); }
### Question: 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(); }### Answer: @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()); }
### Question: JavaClassDiagramAssociation { Set<String> getPackageIdentifiersFromComponentOf(JavaClass javaClass) { return getPackageIdentifiersFromComponentOf(getComponentOf(javaClass)); } JavaClassDiagramAssociation(PlantUmlDiagram diagram); }### Answer: @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); }
### Question: JavaClassDiagramAssociation { boolean contains(JavaClass javaClass) { return !getAssociatedComponents(javaClass).isEmpty(); } JavaClassDiagramAssociation(PlantUmlDiagram diagram); }### Answer: @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(); }
### Question: 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); }### Answer: @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"); }
### Question: ViolationLineMatcherFactory { static ViolationLineMatcher create() { return ArchConfiguration.get().containsProperty(FREEZE_LINE_MATCHER_PROPERTY) ? createInstance(ArchConfiguration.get().getProperty(FREEZE_LINE_MATCHER_PROPERTY)) : DEFAULT_MATCHER; } }### Answer: @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); }
### Question: 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(); }### Answer: @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")); }
### Question: 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(); }### Answer: @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")); }
### Question: 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(); }### Answer: @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 ); }
### Question: 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(); }### Answer: @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"); }
### Question: 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(); }### Answer: @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); }
### Question: 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); }### Answer: @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"); }
### Question: 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(); }### Answer: @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"); }
### Question: InitialConfiguration { public synchronized T get() { checkState(value != null, "No value was ever set"); return value; } synchronized void set(T object); synchronized T get(); }### Answer: @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(); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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(); }### Answer: @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() ); }
### Question: 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(); }### Answer: @Test public void locations_in_classpath() throws Exception { assertThat(urisOf(Locations.inClassPath())).contains( getClass().getResource("/").toURI(), resolvedUri(DataProvider.class, "/"), resolvedUri(Test.class, "/") ); }
### Question: 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); }### Answer: @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(); }
### Question: 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); }### Answer: @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(); }
### Question: 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); }### Answer: @Test public void asUri() throws URISyntaxException { URL url = getClass().getResource("."); assertThat(Location.of(url).asURI()).isEqualTo(url.toURI()); }
### Question: 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); }### Answer: @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); }
### Question: 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(); }### Answer: @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(); }
### Question: JavaClassDescriptorImporter { static JavaClassDescriptor createFromAsmObjectTypeName(String objectTypeName) { return importAsmType(Type.getObjectType(objectTypeName)); } }### Answer: @Test public void asm_object_type() { JavaClassDescriptor objectType = JavaClassDescriptorImporter.createFromAsmObjectTypeName("java/lang/Object"); assertThat(objectType).isEquivalentTo(Object.class); }
### Question: JavaClassDescriptorImporter { static JavaClassDescriptor importAsmType(Type type) { return JavaClassDescriptor.From.name(type.getClassName()); } }### Answer: @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); }
### Question: 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(); }### Answer: @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)"); }
### Question: 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); }### Answer: @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); }
### Question: 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(); }### Answer: @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"); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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(); }### Answer: @Test public void wildcard_name() { @SuppressWarnings("unused") class ClassWithUnboundTypeParameter<T extends List<?>> { } JavaWildcardType type = importWildcardTypeOf(ClassWithUnboundTypeParameter.class); assertThat(type.getName()).isEqualTo("?"); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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"); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void queryFindsMultipleTitles(){ ProductLookup pl = new ResourceBasedProductLookup(); List<String> pis = pl.byQuery("title=D&title=B"); Assert.assertEquals(pis.size(),3); }
### Question: UniqueGuesser extends Guesser { @Override protected Guess nextGuess() { Guess guess = super.nextGuess(); while (guess.isNotUnique()) { guess = super.nextGuess(); } return guess; } @Inject UniqueGuesser(Table table); }### Answer: @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); }
### Question: 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; }### Answer: @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))); }
### Question: 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(); }### Answer: @Test public void canAddNewGuess() { createTestGame(); game.addNewGuess(secret); } @Test(expected = IllegalArgumentException.class) public void throwsExceptionForFinishedGame() { createTestGame(); game.addNewGuess(secret); game.addNewGuess(secret); }
### Question: 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(); }### Answer: @Test public void thereIsAFirstColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNotNull(manager.firstColor()); }
### Question: 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(); }### Answer: @Test public void noColorHasNoNextColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNull(manager.nextColor(Color.none)); }
### Question: UniqueGuesser extends Guesser { @Override protected Guess nextGuess() { Guess guess = super.nextGuess(); while (!guess.isUnique()) { guess = super.nextGuess(); } return guess; } UniqueGuesser(Table table); }### Answer: @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); }
### Question: 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; }### Answer: @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))); }
### Question: 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(); }### Answer: @Test public void canAddNewGuess() { createTestGame(); game.addNewGuess(secret); } @Test(expected = IllegalArgumentException.class) public void throwsExceptionForFinishedGame() { createTestGame(); game.addNewGuess(secret); game.addNewGuess(secret); }
### Question: ColorManager { public Color firstColor() { return first; } ColorManager(int nrColors, ColorFactory factory); Color firstColor(); boolean thereIsNextColor(Color color); Color nextColor(Color color); int getNrColors(); }### Answer: @Test public void thereIsAFirstColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNotNull(manager.firstColor()); }
### Question: 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(); }### Answer: @Test public void noColorHasNoNextColor() { ColorManager manager = new ColorManager(NR_COLORS, Color::new); Assert.assertNull(manager.nextColor(Color.none)); }
### Question: 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); }### Answer: @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); }
### Question: UniqueGuesser extends Guesser { @Override protected Color[] nextGuess() { Color[] guess = super.nextGuess(); while (isNotUnique(guess)) { guess = super.nextGuess(); } return guess; } UniqueGuesser(Table table); }### Answer: @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); }
### Question: 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; }### Answer: @Test(expected = IllegalArgumentException.class) public void throwsIAEForInvalidMatchParameters(){ Row row = new Row(new Color[NR_COLUMNS]); row.setMatch(NR_COLUMNS,1); }
### Question: 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(); }### Answer: @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)); }
### Question: ColorManager { public Color firstColor() { return first; } ColorManager(int nrColors); Color firstColor(); Color nextColor(Color color); }### Answer: @Test public void thereIsAFirstColor() { ColorManager manager = new ColorManager(NR_COLORS); System.out.println(manager.firstColor()); Assert.assertNotNull(manager.firstColor()); }
### Question: ColorManager { public Color nextColor(Color color) { return successor.get(color); } ColorManager(int nrColors); Color firstColor(); Color nextColor(Color color); }### Answer: @Test public void noColorHasNoNextColor() { ColorManager manager = new ColorManager(NR_COLORS); Assert.assertNull(manager.nextColor(Color.none)); }
### Question: 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); }### Answer: @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"); }
### Question: 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); }### Answer: @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); }
### Question: SnapshotPostProcessor { @VisibleForTesting static long updateVersionAndCheckConsistency(long localVersion, long newVersion, String errorMessage) { if (localVersion == -1) { return newVersion; } else { if (localVersion != newVersion) { throw new UnrecoverableStoreException(errorMessage, args -> args.add("localVersion", localVersion).add("newVersion", newVersion)); } } return localVersion; } SnapshotPostProcessor(BiFunction<SerializableSnapshot, String, SerializableSnapshot> processor); }### Answer: @Test public void shouldSucceedWhenInitializionSnapshotToAppModelVersion() { assertThat(updateVersionAndCheckConsistency(-1L, 5L, "shouldSucceed because the applicationVersion was not yet initialized")) .as("Whenever the Version is not initialized we can set it").isEqualTo(5L); } @Test(expectedExceptions = UnrecoverableStoreException.class) public void shouldFailwhenUpdatingSnapshotToOtherVersion() { updateVersionAndCheckConsistency(8L, 88L, "should fail because the applicationModelVersion are not consistent between the stores"); }
### Question: SnapshotPostProcessor { long getConsistentApplicationModelVersion() { long applicationModelVersion = 0; if (m_beforePostProcessingVersion > 0) { applicationModelVersion = m_beforePostProcessingVersion; } if (m_afterPostProcessingVersion > 0) { applicationModelVersion = m_afterPostProcessingVersion; } return applicationModelVersion; } SnapshotPostProcessor(BiFunction<SerializableSnapshot, String, SerializableSnapshot> processor); }### Answer: @Test public void shouldReturn0WhenNoApplicationVersionDefined() { SnapshotPostProcessor snapshotPostProcessor = new SnapshotPostProcessor((snapshot, storeName) -> snapshot); assertThat(snapshotPostProcessor.getConsistentApplicationModelVersion()).isEqualTo(0L); }
### Question: SnapshotPostProcessor { SerializableSnapshot apply(String storeName, SerializableSnapshot serializableSnapshot) { m_beforePostProcessingVersion = updateVersionAndCheckConsistency(m_beforePostProcessingVersion, serializableSnapshot.getApplicationModelVersion(), "Snapshot serializable application model version differs among the stores"); SerializableSnapshot finalSnapshot = m_processor.apply(serializableSnapshot, storeName); m_afterPostProcessingVersion = updateVersionAndCheckConsistency(m_afterPostProcessingVersion, finalSnapshot.getApplicationModelVersion(), "Snapshot serializable application model version differs among the stores after post processing"); if (m_afterPostProcessingVersion < m_beforePostProcessingVersion) { throw new UnrecoverableStoreException("Application model version can not be decreased", args -> args.add("oldApplicationModelVersion", m_beforePostProcessingVersion) .add("newApplicationModelVersion", m_afterPostProcessingVersion)); } return finalSnapshot; } SnapshotPostProcessor(BiFunction<SerializableSnapshot, String, SerializableSnapshot> processor); }### Answer: @Test(expectedExceptions = UnrecoverableStoreException.class) public void shouldFailWhenValidatingPostProcessingUpdatingApplicationModelVersion() { SerializableSnapshot initialSnapshot = new SerializableSnapshot(); long initialSnapshotModelVersion = 10L; long finalSnapshotModelVersion = 9L; initialSnapshot.setApplicationModelVersion(initialSnapshotModelVersion); initialSnapshot.setSnapshotModelVersion(SNAPSHOT_MODEL_VERSION); BiFunction<SerializableSnapshot, String, SerializableSnapshot> updateTheApplicationModelVersion = (snapshot, storeName) -> { snapshot.setApplicationModelVersion(finalSnapshotModelVersion); return snapshot; }; SnapshotPostProcessor snapshotPostProcessor = new SnapshotPostProcessor(updateTheApplicationModelVersion); snapshotPostProcessor.apply("shouldSucceedWhenValidatingPostProcessingIdentity", initialSnapshot); }
### Question: OAuthAsyncCompletionHandler extends AsyncCompletionHandler<T> { @Override public T onCompleted(com.ning.http.client.Response ningResponse) { try { final Map<String, String> headersMap = new HashMap<>(); for (Map.Entry<String, List<String>> header : ningResponse.getHeaders().entrySet()) { final StringBuilder value = new StringBuilder(); for (String str : header.getValue()) { value.append(str); } headersMap.put(header.getKey(), value.toString()); } final Response response = new Response(ningResponse.getStatusCode(), ningResponse.getStatusText(), headersMap, ningResponse.getResponseBodyAsStream()); @SuppressWarnings("unchecked") final T t = converter == null ? (T) response : converter.convert(response); if (callback != null) { callback.onCompleted(t); } return t; } catch (IOException \| RuntimeException e) { onThrowable(e); return null; } } OAuthAsyncCompletionHandler(OAuthAsyncRequestCallback<T> callback, OAuthRequest.ResponseConverter<T> converter); @Override T onCompleted(com.ning.http.client.Response ningResponse); @Override void onThrowable(Throwable t); }### Answer: @Test public void shouldReleaseLatchOnSuccess() throws Exception { handler = new OAuthAsyncCompletionHandler<>(callback, ALL_GOOD_RESPONSE_CONVERTER); final com.ning.http.client.Response response = new MockResponse(200, "ok", new FluentCaseInsensitiveStringsMap(), new byte[0]); handler.onCompleted(response); assertNotNull(callback.getResponse()); assertNull(callback.getThrowable()); assertEquals("All good", callback.getResponse()); } @Test public void shouldReportOAuthException() throws Exception { handler = new OAuthAsyncCompletionHandler<>(callback, OAUTH_EXCEPTION_RESPONSE_CONVERTER); final com.ning.http.client.Response response = new MockResponse(200, "ok", new FluentCaseInsensitiveStringsMap(), new byte[0]); handler.onCompleted(response); assertNull(callback.getResponse()); assertNotNull(callback.getThrowable()); assertTrue(callback.getThrowable() instanceof OAuthException); }
### Question: HMACSha1SignatureService implements SignatureService { @Override public String getSignature(String baseString, String apiSecret, String tokenSecret) { try { Preconditions.checkEmptyString(baseString, "Base string cant be null or empty string"); Preconditions.checkEmptyString(apiSecret, "Api secret cant be null or empty string"); return doSign(baseString, OAuthEncoder.encode(apiSecret) + '&' + OAuthEncoder.encode(tokenSecret)); } catch (UnsupportedEncodingException \| NoSuchAlgorithmException \| InvalidKeyException \| RuntimeException e) { throw new OAuthSignatureException(baseString, e); } } @Override String getSignature(String baseString, String apiSecret, String tokenSecret); @Override String getSignatureMethod(); }### Answer: @Test(expected = OAuthException.class) public void shouldThrowExceptionIfBaseStringIsEmpty() { service.getSignature(" ", "apiSecret", "tokenSecret"); } @Test(expected = OAuthException.class) public void shouldThrowExceptionIfApiSecretIsNull() { service.getSignature("base string", null, "tokenSecret"); } @Test(expected = OAuthException.class) public void shouldThrowExceptionIfApiSecretIsEmpty() { service.getSignature("base string", " ", "tokenSecret"); } @Test public void shouldReturnSignature() { final String apiSecret = "api secret"; final String tokenSecret = "token secret"; final String baseString = "base string"; final String signature = "uGymw2KHOTWI699YEaoi5xyLT50="; assertEquals(signature, service.getSignature(baseString, apiSecret, tokenSecret)); } @Test(expected = OAuthException.class) public void shouldThrowExceptionIfBaseStringIsNull() { service.getSignature(null, "apiSecret", "tokenSecret"); }
### Question: RSASha1SignatureService implements SignatureService { @Override public String getSignatureMethod() { return METHOD; } RSASha1SignatureService(PrivateKey privateKey); @Override String getSignature(String baseString, String apiSecret, String tokenSecret); @Override String getSignatureMethod(); }### Answer: @Test public void shouldReturnSignatureMethodString() { final String expected = "RSA-SHA1"; assertEquals(expected, service.getSignatureMethod()); }
### Question: RSASha1SignatureService implements SignatureService { @Override public String getSignature(String baseString, String apiSecret, String tokenSecret) { try { final Signature signature = Signature.getInstance(RSA_SHA1); signature.initSign(privateKey); signature.update(baseString.getBytes(UTF8)); return BASE_64_ENCODER.encodeToString(signature.sign()); } catch (NoSuchAlgorithmException \| InvalidKeyException \| SignatureException \| UnsupportedEncodingException \| RuntimeException e) { throw new OAuthSignatureException(baseString, e); } } RSASha1SignatureService(PrivateKey privateKey); @Override String getSignature(String baseString, String apiSecret, String tokenSecret); @Override String getSignatureMethod(); }### Answer: @Test public void shouldReturnSignature() { final String apiSecret = "api secret"; final String tokenSecret = "token secret"; final String baseString = "base string"; final String signature = "LUNRzQAlpdNyM9mLXm96Va6g/qVNnEAb7p7K1KM0g8IopOFQJPoOO7cvppgt7w3QyhijWJnCmvqXaaIAGrqvd" + "yr3fIzBULh8D/iZQUNLMi08GCOA34P81XBvsc7A5uJjPDsGhJg2MzoVJ8nWJhU/lMMk4c92S1WGskeoDofRwpo="; assertEquals(signature, service.getSignature(baseString, apiSecret, tokenSecret)); }
### Question: ParameterList { public String appendTo(String url) { Preconditions.checkNotNull(url, "Cannot append to null URL"); final String queryString = asFormUrlEncodedString(); if (queryString.equals(EMPTY_STRING)) { return url; } else { return url + (url.indexOf(QUERY_STRING_SEPARATOR) == -1 ? QUERY_STRING_SEPARATOR : PARAM_SEPARATOR) + queryString; } } ParameterList(); ParameterList(List<Parameter> params); ParameterList(Map<String, String> map); void add(String key, String value); String appendTo(String url); String asOauthBaseString(); String asFormUrlEncodedString(); void addAll(ParameterList other); void addQuerystring(String queryString); boolean contains(Parameter param); int size(); List<Parameter> getParams(); ParameterList sort(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionWhenAppendingNullMapToQuerystring() { params.appendTo(null); } @Test public void shouldAppendNothingToQuerystringIfGivenEmptyMap() { final String url = "http: Assert.assertEquals(url, params.appendTo(url)); }
### Question: Token implements Serializable { public String getParameter(String parameter) { String value = null; for (String str : rawResponse.split("&")) { if (str.startsWith(parameter + '=')) { final String[] part = str.split("="); if (part.length > 1) { value = part[1].trim(); } break; } } return value; } protected Token(String rawResponse); String getRawResponse(); String getParameter(String parameter); }### Answer: @Test public void shouldReturnUrlParam() { final Token actual = new OAuth1AccessToken("acccess", "secret", "user_id=3107154759&screen_name=someuser&empty=&="); assertEquals("someuser", actual.getParameter("screen_name")); assertEquals("3107154759", actual.getParameter("user_id")); assertEquals(null, actual.getParameter("empty")); assertEquals(null, actual.getParameter(null)); }
### Question: MultipartUtils { public static void checkBoundarySyntax(String boundary) { if (boundary == null \|\| !BOUNDARY_REGEXP.matcher(boundary).matches()) { throw new IllegalArgumentException("{'boundary'='" + boundary + "'} has invalid syntax. Should be '" + BOUNDARY_PATTERN + "'."); } } private MultipartUtils(); static void checkBoundarySyntax(String boundary); static String parseBoundaryFromHeader(String contentTypeHeader); static String generateDefaultBoundary(); static ByteArrayOutputStream getPayload(MultipartPayload multipartPayload); }### Answer: @Test public void testValidCheckBoundarySyntax() { MultipartUtils.checkBoundarySyntax("0aA'()+_,-./:=?"); MultipartUtils.checkBoundarySyntax("0aA'()+_,- ./:=?"); MultipartUtils.checkBoundarySyntax(" 0aA'()+_,-./:=?"); MultipartUtils.checkBoundarySyntax("1234567890123456789012345678901234567890123456789012345678901234567890"); }
### Question: Preconditions { public static void checkNotNull(Object object, String errorMsg) { check(object != null, errorMsg); } static void checkNotNull(Object object, String errorMsg); static void checkEmptyString(String string, String errorMsg); static boolean hasText(String str); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionForNullObjects() { Preconditions.checkNotNull(null, ERROR_MSG); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.