diff --git a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java b/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java index 06e340e500..7f267d2c5e 100644 --- a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java +++ b/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java @@ -16,13 +16,13 @@ import java.util.Iterator; import java.util.List; import java.util.Set; +import java.util.stream.Collectors; import org.mockito.exceptions.base.MockitoException; import org.mockito.internal.configuration.injection.filter.MockCandidateFilter; import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter; import org.mockito.internal.configuration.injection.filter.TerminalMockCandidateFilter; import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter; -import org.mockito.internal.util.collections.ListUtil; import org.mockito.internal.util.reflection.FieldInitializationReport; import org.mockito.internal.util.reflection.FieldInitializer; @@ -66,15 +66,6 @@ public class PropertyAndSetterInjection extends MockInjectionStrategy { new TypeBasedCandidateFilter( new NameBasedCandidateFilter(new TerminalMockCandidateFilter())); - private final ListUtil.Filter notFinalOrStatic = - new ListUtil.Filter() { - @Override - public boolean isOut(Field object) { - return Modifier.isFinal(object.getModifiers()) - || Modifier.isStatic(object.getModifiers()); - } - }; - @Override public boolean processInjection( Field injectMocksField, Object injectMocksFieldOwner, Set mockCandidates) { @@ -146,9 +137,12 @@ private boolean injectMockCandidatesOnFields( } private List orderedInstanceFieldsFrom(Class awaitingInjectionClazz) { - List declaredFields = Arrays.asList(awaitingInjectionClazz.getDeclaredFields()); - declaredFields = ListUtil.filter(declaredFields, notFinalOrStatic); - - return sortSuperTypesLast(declaredFields); + return sortSuperTypesLast( + Arrays.stream(awaitingInjectionClazz.getDeclaredFields()) + .filter( + field -> + !Modifier.isFinal(field.getModifiers()) + && !Modifier.isStatic(field.getModifiers())) + .collect(Collectors.toList())); } } diff --git a/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java b/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java index 7e26169ef3..d53abf107a 100644 --- a/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java +++ b/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java @@ -5,10 +5,10 @@ package org.mockito.internal.debugging; import java.util.Collection; -import java.util.LinkedList; +import java.util.List; +import java.util.stream.Collectors; import org.mockito.Mockito; -import org.mockito.internal.util.collections.ListUtil; import org.mockito.invocation.Invocation; import org.mockito.stubbing.Stubbing; @@ -37,15 +37,10 @@ public String printInvocations(Object mock) { } } - LinkedList unused = - ListUtil.filter( - stubbings, - new ListUtil.Filter() { - @Override - public boolean isOut(Stubbing s) { - return s.wasUsed(); - } - }); + List unused = + stubbings.stream() + .filter(stubbing -> !stubbing.wasUsed()) + .collect(Collectors.toList()); if (unused.isEmpty()) { return sb.toString(); diff --git a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java index fc0cb22135..111b588ccf 100644 --- a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java +++ b/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java @@ -6,9 +6,8 @@ import java.util.LinkedList; import java.util.List; +import java.util.stream.Collectors; -import org.mockito.internal.util.collections.ListUtil; -import org.mockito.internal.util.collections.ListUtil.Filter; import org.mockito.internal.verification.api.InOrderContext; import org.mockito.invocation.Invocation; import org.mockito.invocation.Location; @@ -20,7 +19,7 @@ private InvocationsFinder() {} public static List findInvocations( List invocations, MatchableInvocation wanted) { - return ListUtil.filter(invocations, new RemoveNotMatching(wanted)); + return invocations.stream().filter(wanted::matches).collect(Collectors.toList()); } public static List findAllMatchingUnverifiedChunks( @@ -28,7 +27,7 @@ public static List findAllMatchingUnverifiedChunks( MatchableInvocation wanted, InOrderContext orderingContext) { List unverified = removeVerifiedInOrder(invocations, orderingContext); - return ListUtil.filter(unverified, new RemoveNotMatching(wanted)); + return unverified.stream().filter(wanted::matches).collect(Collectors.toList()); } /** @@ -127,13 +126,13 @@ public static Location getLastLocation(List invocations) { public static Invocation findPreviousVerifiedInOrder( List invocations, InOrderContext context) { - LinkedList verifiedOnly = - ListUtil.filter(invocations, new RemoveUnverifiedInOrder(context)); + List verifiedOnly = + invocations.stream().filter(context::isVerified).collect(Collectors.toList()); if (verifiedOnly.isEmpty()) { return null; } else { - return verifiedOnly.getLast(); + return verifiedOnly.get(verifiedOnly.size() - 1); } } @@ -158,32 +157,6 @@ public static List getAllLocations(List invocations) { return locations; } - private static class RemoveNotMatching implements Filter { - private final MatchableInvocation wanted; - - private RemoveNotMatching(MatchableInvocation wanted) { - this.wanted = wanted; - } - - @Override - public boolean isOut(Invocation invocation) { - return !wanted.matches(invocation); - } - } - - private static class RemoveUnverifiedInOrder implements Filter { - private final InOrderContext orderingContext; - - public RemoveUnverifiedInOrder(InOrderContext orderingContext) { - this.orderingContext = orderingContext; - } - - @Override - public boolean isOut(Invocation invocation) { - return !orderingContext.isVerified(invocation); - } - } - /** * i3 is unverified here: * diff --git a/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java index 19b0ac054f..9f60910af0 100644 --- a/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java +++ b/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java @@ -5,9 +5,8 @@ package org.mockito.internal.invocation.finder; import java.util.List; +import java.util.stream.Collectors; -import org.mockito.internal.util.collections.ListUtil; -import org.mockito.internal.util.collections.ListUtil.Filter; import org.mockito.invocation.Invocation; /** @@ -18,14 +17,8 @@ public class VerifiableInvocationsFinder { private VerifiableInvocationsFinder() {} public static List find(List mocks) { - List invocations = AllInvocationsFinder.find(mocks); - return ListUtil.filter(invocations, new RemoveIgnoredForVerification()); - } - - private static class RemoveIgnoredForVerification implements Filter { - @Override - public boolean isOut(Invocation invocation) { - return invocation.isIgnoredForVerification(); - } + return AllInvocationsFinder.find(mocks).stream() + .filter(invocation -> !invocation.isIgnoredForVerification()) + .collect(Collectors.toList()); } } diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java b/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java index c7fd12a7b6..e51d2ebd45 100644 --- a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java +++ b/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java @@ -4,18 +4,15 @@ */ package org.mockito.internal.junit; -import static org.mockito.internal.util.collections.ListUtil.filter; - import java.util.Collection; import java.util.HashSet; import java.util.LinkedHashMap; -import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Collectors; import org.mockito.internal.invocation.finder.AllInvocationsFinder; import org.mockito.internal.stubbing.UnusedStubbingReporting; -import org.mockito.internal.util.collections.ListUtil.Filter; import org.mockito.invocation.Invocation; import org.mockito.stubbing.Stubbing; @@ -29,19 +26,10 @@ public class UnusedStubbingsFinder { * Stubbings explicitily marked as LENIENT are not included. */ public UnusedStubbings getUnusedStubbings(Iterable mocks) { - Set stubbings = AllInvocationsFinder.findStubbings(mocks); - - List unused = - filter( - stubbings, - new Filter() { - @Override - public boolean isOut(Stubbing s) { - return !UnusedStubbingReporting.shouldBeReported(s); - } - }); - - return new UnusedStubbings(unused); + return new UnusedStubbings( + AllInvocationsFinder.findStubbings(mocks).stream() + .filter(UnusedStubbingReporting::shouldBeReported) + .collect(Collectors.toList())); } /** diff --git a/src/main/java/org/mockito/internal/util/collections/ListUtil.java b/src/main/java/org/mockito/internal/util/collections/ListUtil.java deleted file mode 100644 index f94afd89f2..0000000000 --- a/src/main/java/org/mockito/internal/util/collections/ListUtil.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.internal.util.collections; - -import java.util.Collection; -import java.util.LinkedList; - -/** - * Basic list/collection operators. We know that there are existing libraries that implement those - * use cases neatly. However, we want to keep Mockito dependencies minimal. In Java8 we should be - * able to get rid of this class. - */ -public final class ListUtil { - - public static LinkedList filter(Collection collection, Filter filter) { - LinkedList filtered = new LinkedList(); - for (T t : collection) { - if (!filter.isOut(t)) { - filtered.add(t); - } - } - return filtered; - } - - public static LinkedList convert( - Collection collection, Converter converter) { - LinkedList converted = new LinkedList(); - for (FromT f : collection) { - converted.add(converter.convert(f)); - } - return converted; - } - - public interface Filter { - boolean isOut(T object); - } - - public interface Converter { - To convert(FromT from); - } - - private ListUtil() {} -} diff --git a/src/main/java/org/mockito/internal/util/reflection/Fields.java b/src/main/java/org/mockito/internal/util/reflection/Fields.java deleted file mode 100644 index f749649aa7..0000000000 --- a/src/main/java/org/mockito/internal/util/reflection/Fields.java +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.internal.util.reflection; - -import java.lang.annotation.Annotation; -import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.List; - -import org.mockito.internal.util.Checks; -import org.mockito.internal.util.collections.ListUtil; -import org.mockito.internal.util.collections.ListUtil.Filter; - -/** - * Small fluent reflection tools to work with fields. - * - * Code is very new and might need rework. - */ -public abstract class Fields { - - /** - * Instance fields declared in the class and superclasses of the given instance. - * - * @param instance Instance from which declared fields will be retrieved. - * @return InstanceFields of this object instance. - */ - public static InstanceFields allDeclaredFieldsOf(Object instance) { - List instanceFields = new ArrayList<>(); - for (Class clazz = instance.getClass(); - clazz != Object.class; - clazz = clazz.getSuperclass()) { - instanceFields.addAll(instanceFieldsIn(instance, clazz.getDeclaredFields())); - } - return new InstanceFields(instance, instanceFields); - } - - /** - * Instance fields declared in the class of the given instance. - * - * @param instance Instance from which declared fields will be retrieved. - * @return InstanceFields of this object instance. - */ - public static InstanceFields declaredFieldsOf(Object instance) { - List instanceFields = new ArrayList<>(); - instanceFields.addAll(instanceFieldsIn(instance, instance.getClass().getDeclaredFields())); - return new InstanceFields(instance, instanceFields); - } - - private static List instanceFieldsIn(Object instance, Field[] fields) { - List instanceDeclaredFields = new ArrayList<>(); - for (Field field : fields) { - InstanceField instanceField = new InstanceField(field, instance); - instanceDeclaredFields.add(instanceField); - } - return instanceDeclaredFields; - } - - /** - * Accept fields annotated by the given annotations. - * - * @param annotations Annotation types to check. - * @return The filter. - */ - @SuppressWarnings({"unchecked", "vararg"}) - public static Filter annotatedBy( - final Class... annotations) { - return new Filter() { - @Override - public boolean isOut(InstanceField instanceField) { - Checks.checkNotNull(annotations, "Provide at least one annotation class"); - - for (Class annotation : annotations) { - if (instanceField.isAnnotatedBy(annotation)) { - return false; - } - } - return true; - } - }; - } - - /** - * Accept fields with non null value. - * - * @return The filter. - */ - private static Filter nullField() { - return new Filter() { - @Override - public boolean isOut(InstanceField instanceField) { - return instanceField.isNull(); - } - }; - } - - /** - * Accept fields with non null value. - * - * @return The filter. - */ - public static Filter syntheticField() { - return new Filter() { - @Override - public boolean isOut(InstanceField instanceField) { - return instanceField.isSynthetic(); - } - }; - } - - public static class InstanceFields { - private final Object instance; - - private final List instanceFields; - - public InstanceFields(Object instance, List instanceFields) { - this.instance = instance; - this.instanceFields = instanceFields; - } - - public InstanceFields filter(Filter withFilter) { - return new InstanceFields(instance, ListUtil.filter(instanceFields, withFilter)); - } - - public InstanceFields notNull() { - return filter(nullField()); - } - - public List instanceFields() { - return new ArrayList<>(instanceFields); - } - - public List assignedValues() { - List values = new ArrayList<>(instanceFields.size()); - for (InstanceField instanceField : instanceFields) { - values.add(instanceField.read()); - } - return values; - } - - public List names() { - List fieldNames = new ArrayList<>(instanceFields.size()); - for (InstanceField instanceField : instanceFields) { - fieldNames.add(instanceField.name()); - } - return fieldNames; - } - } -} diff --git a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java index f81a53792e..b32a5a458d 100644 --- a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java +++ b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java @@ -9,9 +9,8 @@ import java.io.Serializable; import java.util.LinkedList; import java.util.List; +import java.util.stream.Collectors; -import org.mockito.internal.util.collections.ListUtil; -import org.mockito.internal.util.collections.ListUtil.Filter; import org.mockito.invocation.Invocation; public class DefaultRegisteredInvocations implements RegisteredInvocations, Serializable { @@ -44,7 +43,9 @@ public List getAll() { copiedList = new LinkedList<>(invocations); } - return ListUtil.filter(copiedList, new RemoveToString()); + return copiedList.stream() + .filter(invocation -> !isToStringMethod(invocation.getMethod())) + .collect(Collectors.toList()); } @Override @@ -60,11 +61,4 @@ public boolean isEmpty() { return invocations.isEmpty(); } } - - private static class RemoveToString implements Filter { - @Override - public boolean isOut(Invocation invocation) { - return isToStringMethod(invocation.getMethod()); - } - } } diff --git a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java index aeb86b962d..9ceb483008 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java @@ -16,9 +16,9 @@ import java.util.List; import java.util.Set; +import java.util.stream.Collectors; import org.mockito.internal.reporting.SmartPrinter; -import org.mockito.internal.util.collections.ListUtil; import org.mockito.internal.verification.api.InOrderContext; import org.mockito.invocation.Invocation; import org.mockito.invocation.Location; @@ -49,14 +49,7 @@ public static void checkMissingInvocation( new SmartPrinter( wanted, invocations, indexesOfSuspiciousArgs, classesWithSameSimpleName); List actualLocations = - ListUtil.convert( - invocations, - new ListUtil.Converter() { - @Override - public Location convert(Invocation invocation) { - return invocation.getLocation(); - } - }); + invocations.stream().map(Invocation::getLocation).collect(Collectors.toList()); throw argumentsAreDifferent( smartPrinter.getWanted(), smartPrinter.getActuals(), actualLocations); diff --git a/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java b/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java index 3443c79c83..a56330cee5 100644 --- a/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java +++ b/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java @@ -34,7 +34,6 @@ import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValuesTest; import org.mockito.internal.stubbing.defaultanswers.ReturnsGenericDeepStubsTest; import org.mockito.internal.util.MockUtilTest; -import org.mockito.internal.util.collections.ListUtilTest; import org.mockito.internal.verification.DefaultRegisteredInvocationsTest; import org.mockito.internal.verification.checkers.MissingInvocationCheckerTest; import org.mockito.internal.verification.checkers.MissingInvocationInOrderCheckerTest; @@ -57,7 +56,20 @@ import org.mockitousage.stubbing.BasicStubbingTest; import org.mockitousage.stubbing.ReturningDefaultValuesTest; import org.mockitousage.stubbing.StubbingWithThrowablesTest; -import org.mockitousage.verification.*; +import org.mockitousage.verification.AtMostXVerificationTest; +import org.mockitousage.verification.BasicVerificationInOrderTest; +import org.mockitousage.verification.BasicVerificationTest; +import org.mockitousage.verification.DescriptiveMessagesOnVerificationInOrderErrorsTest; +import org.mockitousage.verification.DescriptiveMessagesWhenTimesXVerificationFailsTest; +import org.mockitousage.verification.DescriptiveMessagesWhenVerificationFailsTest; +import org.mockitousage.verification.ExactNumberOfTimesVerificationTest; +import org.mockitousage.verification.NoMoreInteractionsVerificationTest; +import org.mockitousage.verification.RelaxedVerificationInOrderTest; +import org.mockitousage.verification.SelectedMocksInOrderVerificationTest; +import org.mockitousage.verification.VerificationInOrderMixedWithOrdinaryVerificationTest; +import org.mockitousage.verification.VerificationInOrderTest; +import org.mockitousage.verification.VerificationOnMultipleMocksUsingMatchersTest; +import org.mockitousage.verification.VerificationUsingMatchersTest; import org.mockitoutil.TestBase; public class ThreadsRunAllTestsHalfManualTest extends TestBase { @@ -70,7 +82,6 @@ public void run() { Result result = JUnitCore.runClasses( EqualsTest.class, - ListUtilTest.class, MockingProgressImplTest.class, TimesTest.class, MockHandlerImplTest.class, diff --git a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java b/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java deleted file mode 100644 index 6f47fe29b5..0000000000 --- a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.internal.util.collections; - -import static java.util.Arrays.asList; - -import static org.junit.Assert.assertTrue; - -import java.util.LinkedList; -import java.util.List; - -import org.assertj.core.api.Assertions; -import org.junit.Test; -import org.mockito.internal.util.collections.ListUtil.Filter; -import org.mockitoutil.TestBase; - -public class ListUtilTest extends TestBase { - - @Test - public void shouldFilterList() throws Exception { - List list = asList("one", "x", "two", "x", "three"); - List filtered = - ListUtil.filter( - list, - new Filter() { - public boolean isOut(String object) { - return object == "x"; - } - }); - - Assertions.assertThat(filtered).containsSequence("one", "two", "three"); - } - - @Test - public void shouldReturnEmptyIfEmptyListGiven() throws Exception { - List list = new LinkedList(); - List filtered = ListUtil.filter(list, null); - assertTrue(filtered.isEmpty()); - } -} diff --git a/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java b/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java deleted file mode 100644 index 270cfaefdf..0000000000 --- a/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java +++ /dev/null @@ -1,91 +0,0 @@ -/* - * Copyright (c) 2007 Mockito contributors - * This program is made available under the terms of the MIT License. - */ -package org.mockito.internal.util.reflection; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.internal.util.reflection.Fields.syntheticField; - -import java.lang.reflect.Field; - -import org.junit.Test; - -public class FieldsTest { - - @Test - public void fields_should_return_all_declared_fields_in_hierarchy() throws Exception { - assertThat( - Fields.allDeclaredFieldsOf(new HierarchyOfClasses()) - .filter(syntheticField()) - .names()) - .containsOnly("a", "b", "static_a", "static_b"); - } - - @Test - public void fields_should_return_declared_fields() throws Exception { - assertThat( - Fields.declaredFieldsOf(new HierarchyOfClasses()) - .filter(syntheticField()) - .names()) - .containsOnly("b", "static_b"); - } - - @Test - public void can_filter_not_null_fields() throws Exception { - assertThat( - Fields.declaredFieldsOf(new NullOrNotNullFields()) - .notNull() - .filter(syntheticField()) - .names()) - .containsOnly("c"); - } - - @Test - public void can_get_values_of_instance_fields() throws Exception { - assertThat( - Fields.declaredFieldsOf(new ValuedFields()) - .filter(syntheticField()) - .assignedValues()) - .containsOnly("a", "b"); - } - - @Test - public void can_get_list_of_InstanceField() throws Exception { - ValuedFields instance = new ValuedFields(); - - assertThat(Fields.declaredFieldsOf(instance).filter(syntheticField()).instanceFields()) - .containsOnly( - new InstanceField(field("a", instance), instance), - new InstanceField(field("b", instance), instance)); - } - - private Field field(String name, Object instance) throws NoSuchFieldException { - return instance.getClass().getDeclaredField(name); - } - - interface AnInterface { - int someStaticInInterface = 0; - } - - public static class ParentClass implements AnInterface { - static int static_a; - int a; - } - - public static class HierarchyOfClasses extends ParentClass { - static int static_b; - int b = 1; - } - - public static class NullOrNotNullFields { - static Object static_b; - Object b; - Object c = new Object(); - } - - public static class ValuedFields { - String a = "a"; - String b = "b"; - } -}