From 375e79df526d874f9cd180294bfca81c30b52267 Mon Sep 17 00:00:00 2001 From: Andrei Silviu Dragnea Date: Thu, 7 May 2020 21:40:47 +0300 Subject: [PATCH] Remove ListUtil and Fields classes --- .../injection/PropertyAndSetterInjection.java | 19 +-- .../debugging/InvocationsPrinter.java | 13 +- .../invocation/InvocationsFinder.java | 53 +++---- .../finder/VerifiableInvocationsFinder.java | 16 +- .../internal/junit/UnusedStubbingsFinder.java | 25 ++- .../internal/util/collections/ListUtil.java | 43 ------ .../internal/util/reflection/Fields.java | 144 ------------------ .../DefaultRegisteredInvocations.java | 18 +-- .../checkers/MissingInvocationChecker.java | 12 +- .../ThreadsRunAllTestsHalfManualTest.java | 23 ++- .../util/collections/ListUtilTest.java | 39 ----- .../internal/util/reflection/FieldsTest.java | 80 ---------- 12 files changed, 76 insertions(+), 409 deletions(-) delete mode 100644 src/main/java/org/mockito/internal/util/collections/ListUtil.java delete mode 100644 src/main/java/org/mockito/internal/util/reflection/Fields.java delete mode 100644 src/test/java/org/mockito/internal/util/collections/ListUtilTest.java delete mode 100644 src/test/java/org/mockito/internal/util/reflection/FieldsTest.java 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 38f5760226..729a23fbaa 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; @@ -67,13 +67,6 @@ public class PropertyAndSetterInjection extends MockInjectionStrategy { new NameBasedCandidateFilter( new TerminalMockCandidateFilter())); - private final ListUtil.Filter notFinalOrStatic = new ListUtil.Filter() { - public boolean isOut(Field object) { - return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers()); - } - }; - - public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set mockCandidates) { FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner); @@ -129,9 +122,11 @@ private boolean injectMockCandidatesOnFields(Set mocks, } 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(object -> !Modifier.isFinal(object.getModifiers()) && !Modifier.isStatic(object.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 a643190cf0..01adbf2010 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,11 +37,10 @@ public String printInvocations(Object mock) { } } - LinkedList unused = ListUtil.filter(stubbings, new ListUtil.Filter() { - public boolean isOut(Stubbing s) { - return s.wasUsed(); - } - }); + List unused = stubbings + .stream() + .filter(s -> !s.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 75002c74da..e7a53289bc 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,12 +19,17 @@ 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(List invocations, MatchableInvocation wanted, InOrderContext orderingContext) { - List unverified = removeVerifiedInOrder(invocations, orderingContext); - return ListUtil.filter(unverified, new RemoveNotMatching(wanted)); + return removeVerifiedInOrder(invocations, orderingContext) + .stream() + .filter(wanted::matches) + .collect(Collectors.toList()); } /** @@ -55,7 +59,7 @@ public static List findMatchingChunk(List invocations, M } private static List getFirstMatchingChunk(MatchableInvocation wanted, List unverified) { - List firstChunk = new LinkedList(); + List firstChunk = new LinkedList<>(); for (Invocation invocation : unverified) { if (wanted.matches(invocation)) { firstChunk.add(invocation); @@ -116,17 +120,20 @@ 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); } } private static List removeVerifiedInOrder(List invocations, InOrderContext orderingContext) { - List unverified = new LinkedList(); + List unverified = new LinkedList<>(); for (Invocation i : invocations) { if (orderingContext.isVerified(i)) { unverified.clear(); @@ -138,37 +145,13 @@ private static List removeVerifiedInOrder(List invocatio } public static List getAllLocations(List invocations) { - List locations = new LinkedList(); + List locations = new LinkedList<>(); for (Invocation invocation : invocations) { locations.add(invocation.getLocation()); } return locations; } - private static class RemoveNotMatching implements Filter { - private final MatchableInvocation wanted; - - private RemoveNotMatching(MatchableInvocation wanted) { - this.wanted = wanted; - } - - 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; - } - - public boolean isOut(Invocation invocation) { - return !orderingContext.isVerified(invocation); - } - } - /** * i3 is unverified here: * @@ -185,7 +168,7 @@ public boolean isOut(Invocation invocation) { */ public static Invocation findFirstUnverifiedInOrder(InOrderContext context, List orderedInvocations) { Invocation candidate = null; - for(Invocation i : orderedInvocations) { + for (Invocation i : orderedInvocations) { if (!context.isVerified(i)) { candidate = candidate != null ? candidate : i; } else { 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 e3a4677c0b..acd341e65c 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,13 +17,10 @@ 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{ - 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 c602b0771a..e32ead770c 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,15 +26,13 @@ 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() { - 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()) + ); } /** @@ -55,7 +50,7 @@ public Collection getUnusedStubbingsByLocation(Iterable mock //1st pass, collect all the locations of the stubbings that were used //note that those are _not_ locations where the stubbings was used - Set locationsOfUsedStubbings = new HashSet(); + Set locationsOfUsedStubbings = new HashSet<>(); for (Stubbing s : stubbings) { if (!UnusedStubbingReporting.shouldBeReported(s)) { String location = s.getInvocation().getLocation().toString(); @@ -67,7 +62,7 @@ public Collection getUnusedStubbingsByLocation(Iterable mock //If the location matches we assume the stubbing was used in at least one test method //Also, using map to deduplicate reported unused stubbings // if unused stubbing appear in the setup method / constructor we don't want to report it per each test case - Map out = new LinkedHashMap(); + Map out = new LinkedHashMap<>(); for (Stubbing s : stubbings) { String location = s.getInvocation().getLocation().toString(); if (!locationsOfUsedStubbings.contains(location)) { 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 ecad009f48..0000000000 --- a/src/main/java/org/mockito/internal/util/collections/ListUtil.java +++ /dev/null @@ -1,43 +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 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 (From f: collection) { - converted.add(converter.convert(f)); - } - return converted; - } - - public interface Filter { - boolean isOut(T object); - } - - public interface Converter { - To convert(From from); - } -} 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 3d3fb9c3dc..0000000000 --- a/src/main/java/org/mockito/internal/util/reflection/Fields.java +++ /dev/null @@ -1,144 +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() { - 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() { - public boolean isOut(InstanceField instanceField) { - return instanceField.isNull(); - } - }; - } - - /** - * Accept fields with non null value. - * - * @return The filter. - */ - public static Filter syntheticField() { - return new Filter() { - 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 c69871e688..40b48167fd 100644 --- a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java +++ b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java @@ -9,16 +9,15 @@ 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 { private static final long serialVersionUID = -2674402327380736290L; - private final LinkedList invocations = new LinkedList(); + private final LinkedList invocations = new LinkedList<>(); public void add(Invocation invocation) { synchronized (invocations) { @@ -38,10 +37,13 @@ public void removeLast() { public List getAll() { List copiedList; synchronized (invocations) { - copiedList = new LinkedList(invocations) ; + copiedList = new LinkedList<>(invocations); } - return ListUtil.filter(copiedList, new RemoveToString()); + return copiedList + .stream() + .filter(invocation -> !isToStringMethod(invocation.getMethod())) + .collect(Collectors.toList()); } public void clear() { @@ -56,10 +58,4 @@ public boolean isEmpty() { } } - private static class RemoveToString implements Filter { - 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 73ad4879d0..47b1b34132 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java @@ -14,9 +14,9 @@ import static org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes; import java.util.List; +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; @@ -41,12 +41,10 @@ public static void checkMissingInvocation(List invocations, Matchabl Integer[] indexesOfSuspiciousArgs = getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments()); SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs); - List actualLocations = ListUtil.convert(invocations, new ListUtil.Converter() { - @Override - public Location convert(Invocation invocation) { - return invocation.getLocation(); - } - }); + List actualLocations = 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 66ffaa33b2..fa9e274543 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,19 +56,31 @@ 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.VerificationInOrderMixedWithOrdiraryVerificationTest; +import org.mockitousage.verification.VerificationInOrderTest; +import org.mockitousage.verification.VerificationOnMultipleMocksUsingMatchersTest; +import org.mockitousage.verification.VerificationUsingMatchersTest; import org.mockitoutil.TestBase; public class ThreadsRunAllTestsHalfManualTest extends TestBase { private static class AllTestsRunner extends Thread { - private Set> failed = new HashSet>(); + private Set> failed = new HashSet<>(); public void run() { Result result = JUnitCore.runClasses( EqualsTest.class, - ListUtilTest.class, MockingProgressImplTest.class, TimesTest.class, MockHandlerImplTest.class, @@ -149,7 +160,7 @@ public void shouldRunInMultipleThreads() throws Exception { } public static Set> runInMultipleThreads(int numberOfThreads) throws Exception { - List threads = new LinkedList(); + List threads = new LinkedList<>(); for (int i = 1; i <= numberOfThreads; i++) { threads.add(new AllTestsRunner()); } @@ -158,7 +169,7 @@ public static Set> runInMultipleThreads(int numberOfThreads) throws Exc t.start(); } - Set> failed = new HashSet>(); + Set> failed = new HashSet<>(); for (AllTestsRunner t : threads) { t.join(); failed.addAll(t.getFailed()); 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 ea8ad66bb9..0000000000 --- a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java +++ /dev/null @@ -1,39 +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 897cc2a218..0000000000 --- a/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java +++ /dev/null @@ -1,80 +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"; - } -}