How to use SuperTypesLastSorter class of org.mockito.internal.util.reflection package

Best Mockito code snippet using org.mockito.internal.util.reflection.SuperTypesLastSorter

Source:19PropertyAndSetterInjection.java

...11import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter;12import org.mockito.internal.util.collections.ListUtil;13import org.mockito.internal.util.reflection.FieldInitializationReport;14import org.mockito.internal.util.reflection.FieldInitializer;15import org.mockito.internal.util.reflection.SuperTypesLastSorter;16import java.lang.reflect.Field;17import java.lang.reflect.InvocationTargetException;18import java.lang.reflect.Modifier;19import java.util.*;20import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;21/**22 * Inject mocks using first setters then fields, if no setters available.23 *24 * <p>25 * <u>Algorithm :<br></u>26 * for each field annotated by @InjectMocks27 *   <ul>28 *   <li>initialize field annotated by @InjectMocks29 *   <li>for each fields of a class in @InjectMocks type hierarchy30 *     <ul>31 *     <li>make a copy of mock candidates32 *     <li>order fields from sub-type to super-type, then by field name33 *     <li>for the list of fields in a class try two passes of :34 *         <ul>35 *             <li>find mock candidate by type36 *             <li>if more than <b>*one*</b> candidate find mock candidate on name37 *             <li>if one mock candidate then38 *                 <ul>39 *                     <li>set mock by property setter if possible40 *                     <li>else set mock by field injection41 *                 </ul>42 *             <li>remove mock from mocks copy (mocks are just injected once in a class)43 *             <li>remove injected field from list of class fields44 *         </ul>45 *     <li>else don't fail, user will then provide dependencies46 *     </ul>47 *   </ul>48 * </p>49 *50 * <p>51 * <u>Note:</u> If the field needing injection is not initialized, the strategy tries52 * to create one using a no-arg constructor of the field type.53 * </p>54 */55public class PropertyAndSetterInjection extends MockInjectionStrategy {56    private final MockCandidateFilter mockCandidateFilter = new TypeBasedCandidateFilter(new NameBasedCandidateFilter(new FinalMockCandidateFilter()));57    private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {58        public boolean isOut(Field object) {59            return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers());60        }61    };62    public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {63        // Set<Object> mocksToBeInjected = new HashSet<Object>(mockCandidates);64        FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);65        // for each field in the class hierarchy66        boolean injectionOccurred = false;67        Class<?> fieldClass = report.fieldClass();68        Object fieldInstanceNeedingInjection = report.fieldInstance();69        while (fieldClass != Object.class) {70            injectionOccurred |= injectMockCandidates(fieldClass, newMockSafeHashSet(mockCandidates), fieldInstanceNeedingInjection);71            fieldClass = fieldClass.getSuperclass();72        }73        return injectionOccurred;74    }75    private FieldInitializationReport initializeInjectMocksField(Field field, Object fieldOwner) {76        FieldInitializationReport report = null;77        try {78            report = new FieldInitializer(fieldOwner, field).initialize();79        } catch (MockitoException e) {80            if(e.getCause() instanceof InvocationTargetException) {81                Throwable realCause = e.getCause().getCause();82                new Reporter().fieldInitialisationThrewException(field, realCause);83            }84            new Reporter().cannotInitializeForInjectMocksAnnotation(field.getName(), e);85        }86        return report; // never null87    }88    private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Set<Object> mocks, Object instance) {89        boolean injectionOccurred = false;90        List<Field> orderedInstanceFields = orderedInstanceFieldsFrom(awaitingInjectionClazz);91        // pass 192        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);93        // pass 294        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);95        return injectionOccurred;96    }97    private boolean injectMockCandidatesOnFields(Set<Object> mocks, Object instance, boolean injectionOccurred, List<Field> orderedInstanceFields) {98        for (Iterator<Field> it = orderedInstanceFields.iterator(); it.hasNext(); ) {99            Field field = it.next();100            Object injected = mockCandidateFilter.filterCandidate(mocks, field, orderedInstanceFields, instance).thenInject();101            if (injected != null) {102                injectionOccurred |= true;103                mocks.remove(injected);104                it.remove();105            }106        }107        return injectionOccurred;108    }109    private List<Field> orderedInstanceFieldsFrom(Class<?> awaitingInjectionClazz) {110        List<Field> declaredFields = Arrays.asList(awaitingInjectionClazz.getDeclaredFields());111        declaredFields = ListUtil.filter(declaredFields, notFinalOrStatic);112        return new SuperTypesLastSorter().sort(declaredFields);113    }114}...

Source:src_org_mockito_internal_configuration_injection_PropertyAndSetterInjection.java

...11import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter;12import org.mockito.internal.util.collections.ListUtil;13import org.mockito.internal.util.reflection.FieldInitializationReport;14import org.mockito.internal.util.reflection.FieldInitializer;15import org.mockito.internal.util.reflection.SuperTypesLastSorter;16import java.lang.reflect.Field;17import java.lang.reflect.InvocationTargetException;18import java.lang.reflect.Modifier;19import java.util.*;20import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;21/**22 * Inject mocks using first setters then fields, if no setters available.23 *24 * <p>25 * <u>Algorithm :<br></u>26 * for each field annotated by @InjectMocks27 *   <ul>28 *   <li>initialize field annotated by @InjectMocks29 *   <li>for each fields of a class in @InjectMocks type hierarchy30 *     <ul>31 *     <li>make a copy of mock candidates32 *     <li>order fields from sub-type to super-type, then by field name33 *     <li>for the list of fields in a class try two passes of :34 *         <ul>35 *             <li>find mock candidate by type36 *             <li>if more than <b>*one*</b> candidate find mock candidate on name37 *             <li>if one mock candidate then38 *                 <ul>39 *                     <li>set mock by property setter if possible40 *                     <li>else set mock by field injection41 *                 </ul>42 *             <li>remove mock from mocks copy (mocks are just injected once in a class)43 *             <li>remove injected field from list of class fields44 *         </ul>45 *     <li>else don't fail, user will then provide dependencies46 *     </ul>47 *   </ul>48 * </p>49 *50 * <p>51 * <u>Note:</u> If the field needing injection is not initialized, the strategy tries52 * to create one using a no-arg constructor of the field type.53 * </p>54 */55public class PropertyAndSetterInjection extends MockInjectionStrategy {56    private final MockCandidateFilter mockCandidateFilter = new TypeBasedCandidateFilter(new NameBasedCandidateFilter(new FinalMockCandidateFilter()));57    private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {58        public boolean isOut(Field object) {59            return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers());60        }61    };62    public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {63        // Set<Object> mocksToBeInjected = new HashSet<Object>(mockCandidates);64        FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);65        // for each field in the class hierarchy66        boolean injectionOccurred = false;67        Class<?> fieldClass = report.fieldClass();68        Object fieldInstanceNeedingInjection = report.fieldInstance();69        while (fieldClass != Object.class) {70            injectionOccurred |= injectMockCandidates(fieldClass, newMockSafeHashSet(mockCandidates), fieldInstanceNeedingInjection);71            fieldClass = fieldClass.getSuperclass();72        }73        return injectionOccurred;74    }75    private FieldInitializationReport initializeInjectMocksField(Field field, Object fieldOwner) {76        FieldInitializationReport report = null;77        try {78            report = new FieldInitializer(fieldOwner, field).initialize();79        } catch (MockitoException e) {80            if(e.getCause() instanceof InvocationTargetException) {81                Throwable realCause = e.getCause().getCause();82                new Reporter().fieldInitialisationThrewException(field, realCause);83            }84            new Reporter().cannotInitializeForInjectMocksAnnotation(field.getName(), e);85        }86        return report; // never null87    }88    private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Set<Object> mocks, Object instance) {89        boolean injectionOccurred = false;90        List<Field> orderedInstanceFields = orderedInstanceFieldsFrom(awaitingInjectionClazz);91        // pass 192        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);93        // pass 294        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);95        return injectionOccurred;96    }97    private boolean injectMockCandidatesOnFields(Set<Object> mocks, Object instance, boolean injectionOccurred, List<Field> orderedInstanceFields) {98        for (Iterator<Field> it = orderedInstanceFields.iterator(); it.hasNext(); ) {99            Field field = it.next();100            Object injected = mockCandidateFilter.filterCandidate(mocks, field, orderedInstanceFields, instance).thenInject();101            if (injected != null) {102                injectionOccurred |= true;103                mocks.remove(injected);104                it.remove();105            }106        }107        return injectionOccurred;108    }109    private List<Field> orderedInstanceFieldsFrom(Class<?> awaitingInjectionClazz) {110        List<Field> declaredFields = Arrays.asList(awaitingInjectionClazz.getDeclaredFields());111        declaredFields = ListUtil.filter(declaredFields, notFinalOrStatic);112        return new SuperTypesLastSorter().sort(declaredFields);113    }114}...

Source:patched-PropertyAndSetterInjection.java

...11import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter;12import org.mockito.internal.util.collections.ListUtil;13import org.mockito.internal.util.reflection.FieldInitializationReport;14import org.mockito.internal.util.reflection.FieldInitializer;15import org.mockito.internal.util.reflection.SuperTypesLastSorter;16import java.lang.reflect.Field;17import java.lang.reflect.InvocationTargetException;18import java.lang.reflect.Modifier;19import java.util.*;20import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;21/**22 * Inject mocks using first setters then fields, if no setters available.23 *24 * <p>25 * <u>Algorithm :<br></u>26 * for each field annotated by @InjectMocks27 *   <ul>28 *   <li>initialize field annotated by @InjectMocks29 *   <li>for each fields of a class in @InjectMocks type hierarchy30 *     <ul>31 *     <li>make a copy of mock candidates32 *     <li>order fields from sub-type to super-type, then by field name33 *     <li>for the list of fields in a class try two passes of :34 *         <ul>35 *             <li>find mock candidate by type36 *             <li>if more than <b>*one*</b> candidate find mock candidate on name37 *             <li>if one mock candidate then38 *                 <ul>39 *                     <li>set mock by property setter if possible40 *                     <li>else set mock by field injection41 *                 </ul>42 *             <li>remove mock from mocks copy (mocks are just injected once in a class)43 *             <li>remove injected field from list of class fields44 *         </ul>45 *     <li>else don't fail, user will then provide dependencies46 *     </ul>47 *   </ul>48 * </p>49 *50 * <p>51 * <u>Note:</u> If the field needing injection is not initialized, the strategy tries52 * to create one using a no-arg constructor of the field type.53 * </p>54 */55public class PropertyAndSetterInjection extends MockInjectionStrategy {56    private final MockCandidateFilter mockCandidateFilter = new TypeBasedCandidateFilter(new NameBasedCandidateFilter(new FinalMockCandidateFilter()));57    private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {58        public boolean isOut(Field object) {59            return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers());60        }61    };62    public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {63        // Set<Object> mocksToBeInjected = new HashSet<Object>(mockCandidates);64        FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);65        // for each field in the class hierarchy66        boolean injectionOccurred = false;67        Class<?> fieldClass = report.fieldClass();68        Object fieldInstanceNeedingInjection = report.fieldInstance();69        while (fieldClass != Object.class) {70            injectionOccurred |= injectMockCandidates(fieldClass, newMockSafeHashSet(mockCandidates), fieldInstanceNeedingInjection);71            fieldClass = fieldClass.getSuperclass();72        }73        return injectionOccurred;74    }75    private FieldInitializationReport initializeInjectMocksField(Field field, Object fieldOwner) {76        FieldInitializationReport report = null;77        try {78            report = new FieldInitializer(fieldOwner, field).initialize();79        } catch (MockitoException e) {80            if(e.getCause() instanceof InvocationTargetException) {81                Throwable realCause = e.getCause().getCause();82                new Reporter().fieldInitialisationThrewException(field, realCause);83            }84            new Reporter().cannotInitializeForInjectMocksAnnotation(field.getName(), e);85        }86        return report; // never null87    }88    private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Set<Object> mocks, Object instance) {89        boolean injectionOccurred = false;90        List<Field> orderedInstanceFields = orderedInstanceFieldsFrom(awaitingInjectionClazz);91        // pass 192        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);93        // pass 294        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);95        return injectionOccurred;96    }97    private boolean injectMockCandidatesOnFields(Set<Object> mocks, Object instance, boolean injectionOccurred, List<Field> orderedInstanceFields) {98        for (Iterator<Field> it = orderedInstanceFields.iterator(); it.hasNext(); ) {99            Field field = it.next();100            Object injected = mockCandidateFilter.filterCandidate(mocks, field, orderedInstanceFields, instance).thenInject();101            if (injected != null) {102                injectionOccurred |= true;103                mocks.remove(injected);104                it.remove();105            }106        }107        return injectionOccurred;108    }109    private List<Field> orderedInstanceFieldsFrom(Class<?> awaitingInjectionClazz) {110        List<Field> declaredFields = Arrays.asList(awaitingInjectionClazz.getDeclaredFields());111        declaredFields = ListUtil.filter(declaredFields, notFinalOrStatic);112        return new SuperTypesLastSorter().sort(declaredFields);113    }114}...

Source:buggy-PropertyAndSetterInjection.java

...11import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter;12import org.mockito.internal.util.collections.ListUtil;13import org.mockito.internal.util.reflection.FieldInitializationReport;14import org.mockito.internal.util.reflection.FieldInitializer;15import org.mockito.internal.util.reflection.SuperTypesLastSorter;16import java.lang.reflect.Field;17import java.lang.reflect.InvocationTargetException;18import java.lang.reflect.Modifier;19import java.util.*;20import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;21/**22 * Inject mocks using first setters then fields, if no setters available.23 *24 * <p>25 * <u>Algorithm :<br></u>26 * for each field annotated by @InjectMocks27 *   <ul>28 *   <li>initialize field annotated by @InjectMocks29 *   <li>for each fields of a class in @InjectMocks type hierarchy30 *     <ul>31 *     <li>make a copy of mock candidates32 *     <li>order fields from sub-type to super-type, then by field name33 *     <li>for the list of fields in a class try two passes of :34 *         <ul>35 *             <li>find mock candidate by type36 *             <li>if more than <b>*one*</b> candidate find mock candidate on name37 *             <li>if one mock candidate then38 *                 <ul>39 *                     <li>set mock by property setter if possible40 *                     <li>else set mock by field injection41 *                 </ul>42 *             <li>remove mock from mocks copy (mocks are just injected once in a class)43 *             <li>remove injected field from list of class fields44 *         </ul>45 *     <li>else don't fail, user will then provide dependencies46 *     </ul>47 *   </ul>48 * </p>49 *50 * <p>51 * <u>Note:</u> If the field needing injection is not initialized, the strategy tries52 * to create one using a no-arg constructor of the field type.53 * </p>54 */55public class PropertyAndSetterInjection extends MockInjectionStrategy {56    private final MockCandidateFilter mockCandidateFilter = new TypeBasedCandidateFilter(new NameBasedCandidateFilter(new FinalMockCandidateFilter()));57    private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {58        public boolean isOut(Field object) {59            return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers());60        }61    };62    public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {63        // Set<Object> mocksToBeInjected = new HashSet<Object>(mockCandidates);64        FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);65        // for each field in the class hierarchy66        boolean injectionOccurred = false;67        Class<?> fieldClass = report.fieldClass();68        Object fieldInstanceNeedingInjection = report.fieldInstance();69        while (fieldClass != Object.class) {70            injectionOccurred |= injectMockCandidates(fieldClass, newMockSafeHashSet(mockCandidates), fieldInstanceNeedingInjection);71            fieldClass = fieldClass.getSuperclass();72        }73        return injectionOccurred;74    }75    private FieldInitializationReport initializeInjectMocksField(Field field, Object fieldOwner) {76        FieldInitializationReport report = null;77        try {78            report = new FieldInitializer(fieldOwner, field).initialize();79        } catch (MockitoException e) {80            if(e.getCause() instanceof InvocationTargetException) {81                Throwable realCause = e.getCause().getCause();82                new Reporter().fieldInitialisationThrewException(field, realCause);83            }84            new Reporter().cannotInitializeForInjectMocksAnnotation(field.getName(), e);85        }86        return report; // never null87    }88    private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Set<Object> mocks, Object instance) {89        boolean injectionOccurred = false;90        List<Field> orderedInstanceFields = orderedInstanceFieldsFrom(awaitingInjectionClazz);91        // pass 192        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);93        // pass 294        injectionOccurred |= injectMockCandidatesOnFields(mocks, instance, injectionOccurred, orderedInstanceFields);95        return injectionOccurred;96    }97    private boolean injectMockCandidatesOnFields(Set<Object> mocks, Object instance, boolean injectionOccurred, List<Field> orderedInstanceFields) {98        for (Iterator<Field> it = orderedInstanceFields.iterator(); it.hasNext(); ) {99            Field field = it.next();100            Object injected = mockCandidateFilter.filterCandidate(mocks, field, instance).thenInject();101            if (injected != null) {102                injectionOccurred |= true;103                mocks.remove(injected);104                it.remove();105            }106        }107        return injectionOccurred;108    }109    private List<Field> orderedInstanceFieldsFrom(Class<?> awaitingInjectionClazz) {110        List<Field> declaredFields = Arrays.asList(awaitingInjectionClazz.getDeclaredFields());111        declaredFields = ListUtil.filter(declaredFields, notFinalOrStatic);112        return new SuperTypesLastSorter().sort(declaredFields);113    }114}...

Source:SuperTypesLastSorterTest.java

1package org.mockito.internal.util.reflection;2import org.fest.assertions.Condition;3import org.junit.Test;4import org.mockito.internal.util.reflection.SuperTypesLastSorter;5import java.lang.reflect.Field;6import java.util.ArrayList;7import java.util.Arrays;8import java.util.Collections;9import java.util.Comparator;10import java.util.HashSet;11import java.util.List;12import java.util.Set;13import static org.fest.assertions.Assertions.assertThat;14@SuppressWarnings("unused")15public class SuperTypesLastSorterTest {16    /**17     * A Comparator that behaves like the old one, so the existing tests18     * continue to work.19     */20    private static Comparator<Field> cmp = new Comparator<Field>()21    {22        public int compare(Field o1, Field o2)23        {24            if (o1.equals(o2)) {25                return 0;26            }27            List<Field> l = new SuperTypesLastSorter().sort(Arrays.asList(o1, o2));28            if (l.get(0) == o1) {29                return -1;30            } else {31                return 1;32            }33        }34    };35    private Object objectA;36    private Object objectB;37    private Number numberA;38    private Number numberB;39    private Integer integerA;40    private Integer integerB;41    private Iterable<?> iterableA;42    private Number xNumber;43    private Iterable<?> yIterable;44    private Integer zInteger;45    @Test46    public void when_same_type_the_order_is_based_on_field_name() throws Exception {47        assertThat(cmp.compare(field("objectA"), field("objectB"))).isEqualTo(-1);48        assertThat(cmp.compare(field("objectB"), field("objectA"))).isEqualTo(1);49        assertThat(cmp.compare(field("objectB"), field("objectB"))).isEqualTo(0);50    }51    @Test52    public void when_type_is_different_the_supertype_comes_last() throws Exception {53        assertThat(cmp.compare(field("numberA"), field("objectB"))).isEqualTo(-1);54        assertThat(cmp.compare(field("objectB"), field("numberA"))).isEqualTo(1);55    }56    @Test57    public void using_Collections_dot_sort() throws Exception {58        List<Field> unsortedFields = Arrays.asList(59                field("objectB"),60                field("integerB"),61                field("numberA"),62                field("numberB"),63                field("objectA"),64                field("integerA")65        );66        List<Field> sortedFields = new SuperTypesLastSorter().sort(unsortedFields);67        assertThat(sortedFields).containsSequence(68                field("integerA"),69                field("integerB"),70                field("numberA"),71                field("numberB"),72                field("objectA"),73                field("objectB")74        );75    }76    @Test77    public void issue_352_order_was_different_between_JDK6_and_JDK7() throws Exception {78        List<Field> unsortedFields = Arrays.asList(79                field("objectB"),80                field("objectA")81        );82        Collections.sort(unsortedFields, cmp);83        assertThat(unsortedFields).containsSequence(84                field("objectA"),85                field("objectB")86        );87    }88    @Test89    public void fields_sort_consistently_when_interfaces_are_included() throws NoSuchFieldException90    {91        assertSortConsistently(field("iterableA"), field("numberA"), field("integerA"));92    }93    @Test94    public void fields_sort_consistently_when_names_and_type_indicate_different_order() throws NoSuchFieldException95    {96        assertSortConsistently(field("xNumber"), field("yIterable"), field("zInteger"));97    }98    /**99     * Assert that these fields sort in the same order no matter which order100     * they start in.101     */102    private static void assertSortConsistently(Field a, Field b, Field c)103    {104        Field[][] initialOrderings = {105                {a, b, c},106                {a, c, b},107                {b, a, c},108                {b, c, a},109                {c, a, b},110                {c, b, a}111        };112        Set<List<Field>> results = new HashSet<List<Field>>();113        for (Field[] o : initialOrderings) {114            results.add(new SuperTypesLastSorter().sort(Arrays.asList(o)));115        }116        assertThat(results).hasSize(1);117    }118    private Field field(String field) throws NoSuchFieldException {119        return getClass().getDeclaredField(field);120    }121}...

Source:PropertyAndSetterInjection.java

...15import org.mockito.internal.util.collections.ListUtil;16import org.mockito.internal.util.collections.Sets;17import org.mockito.internal.util.reflection.FieldInitializationReport;18import org.mockito.internal.util.reflection.FieldInitializer;19import org.mockito.internal.util.reflection.SuperTypesLastSorter;20public class PropertyAndSetterInjection extends MockInjectionStrategy {21    private final MockCandidateFilter mockCandidateFilter = new TypeBasedCandidateFilter(new NameBasedCandidateFilter(new TerminalMockCandidateFilter()));22    private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {23        public boolean isOut(Field field) {24            return Modifier.isFinal(field.getModifiers()) || Modifier.isStatic(field.getModifiers());25        }26    };27    public boolean processInjection(Field field, Object obj, Set<Object> set) {28        FieldInitializationReport initializeInjectMocksField = initializeInjectMocksField(field, obj);29        Object fieldInstance = initializeInjectMocksField.fieldInstance();30        boolean z = false;31        for (Class fieldClass = initializeInjectMocksField.fieldClass(); fieldClass != Object.class; fieldClass = fieldClass.getSuperclass()) {32            z |= injectMockCandidates(fieldClass, fieldInstance, Sets.newMockSafeHashSet((Iterable<Object>) set));33        }34        return z;35    }36    private FieldInitializationReport initializeInjectMocksField(Field field, Object obj) {37        try {38            return new FieldInitializer(obj, field).initialize();39        } catch (MockitoException e) {40            if (e.getCause() instanceof InvocationTargetException) {41                throw Reporter.fieldInitialisationThrewException(field, e.getCause().getCause());42            }43            throw Reporter.cannotInitializeForInjectMocksAnnotation(field.getName(), e.getMessage());44        }45    }46    private boolean injectMockCandidates(Class<?> cls, Object obj, Set<Object> set) {47        List<Field> orderedInstanceFieldsFrom = orderedInstanceFieldsFrom(cls);48        boolean injectMockCandidatesOnFields = injectMockCandidatesOnFields(set, obj, false, orderedInstanceFieldsFrom);49        return injectMockCandidatesOnFields(set, obj, injectMockCandidatesOnFields, orderedInstanceFieldsFrom) | injectMockCandidatesOnFields;50    }51    private boolean injectMockCandidatesOnFields(Set<Object> set, Object obj, boolean z, List<Field> list) {52        Iterator<Field> it = list.iterator();53        while (it.hasNext()) {54            Object thenInject = this.mockCandidateFilter.filterCandidate(set, it.next(), list, obj).thenInject();55            if (thenInject != null) {56                z |= true;57                set.remove(thenInject);58                it.remove();59            }60        }61        return z;62    }63    private List<Field> orderedInstanceFieldsFrom(Class<?> cls) {64        return SuperTypesLastSorter.sortSuperTypesLast(ListUtil.filter(Arrays.asList(cls.getDeclaredFields()), this.notFinalOrStatic));65    }66}...

Source:SuperTypesLastSorter.java

...12/**13 * Sort fields in an order suitable for injection, by name with superclasses14 * moved after their subclasses.15 */16public class SuperTypesLastSorter {17    private SuperTypesLastSorter() {18    }19    /**20     * Return a new collection with the fields sorted first by name,21     * then with any fields moved after their supertypes.22     */23    public static List<Field> sortSuperTypesLast(Collection<? extends Field> unsortedFields) {24        List<Field> fields = new ArrayList<Field>(unsortedFields);25        Collections.sort(fields, compareFieldsByName);26        int i = 0;27        while (i < fields.size() - 1) {28            Field f = fields.get(i);29            Class<?> ft = f.getType();30            int newPos = i;31            for (int j = i + 1; j < fields.size(); j++) {...

SuperTypesLastSorter

Using AI Code Generation

1package com.mockitotest;2import java.util.ArrayList;3import java.util.List;4import org.mockito.internal.util.reflection.SuperTypesLastSorter;5public class SuperTypesLastSorterTest {6	public static void main(String[] args) {7		List<Class<?>> list = new ArrayList<Class<?>>();8		list.add(String.class);9		list.add(Object.class);10		list.add(Integer.class);11		list.add(Number.class);12		list.add(Double.class);13		list.add(Long.class);14		list.add(Float.class);15		list.add(Short.class);16		list.add(Byte.class);17		list.add(Character.class);18		list.add(Boolean.class);19		System.out.println("Before sorting");20		for (Class<?> c : list) {21			System.out.println(c);22		}23		System.out.println("After sorting");24		for (Class<?> c : new SuperTypesLastSorter().sort(list)) {25			System.out.println(c);26		}27	}28}

SuperTypesLastSorter

Using AI Code Generation

1package org.mockito.internal.util.reflection;2import java.util.ArrayList;3import java.util.Collections;4import java.util.List;5public class SuperTypesLastSorterTest {6    public static void main(String[] args) {7        List<Class<?>> types = new ArrayList<Class<?>>();8        types.add(String.class);9        types.add(Object.class);10        types.add(Number.class);11        Collections.sort(types, new SuperTypesLastSorter());12        System.out.println(types);13    }14}

SuperTypesLastSorter

Using AI Code Generation

1import org.mockito.internal.util.reflection.SuperTypesLastSorter;2import java.util.List;3import java.util.ArrayList;4import java.util.Arrays;5import java.util.Collections;6import java.util.Comparator;7import java.util.Iterator;8import java.util.LinkedList;9import java.util.List;10import java.util.Map;11import java.util.Set;12import java.util.TreeMap;13import java.util.TreeSet;14import java.util.concurrent.ConcurrentHashMap;15import java.util.concurrent.CopyOnWriteArrayList;16import java.util.concurrent.CopyOnWriteArraySet;17import java.util.concurrent.atomic.AtomicReference;18public class Sorter {19	public static void main(String[] args) {20		SuperTypesLastSorter sorter = new SuperTypesLastSorter();21		List<Class<?>> list = new ArrayList<Class<?>>();22		list.add(String.class);23		list.add(Integer.class);24		list.add(Object.class);25		list.add(Number.class);26		list.add(Comparable.class);27		list.add(Iterable.class);28		list.add(Iterator.class);29		list.add(LinkedList.class);30		list.add(TreeSet.class);31		list.add(TreeMap.class);32		list.add(CopyOnWriteArrayList.class);33		list.add(CopyOnWriteArraySet.class);34		list.add(ConcurrentHashMap.class);35		list.add(AtomicReference.class);36		list.add(Collections.class);37		list.add(Comparator.class);38		list.add(Map.class);39		list.add(Set.class);40		list.add(Arrays.class);41		list.add(ArrayList.class);42		list.add(List.class);43		list.add(Class.class);44		list.add(Object.class);45		list.add(String.class);46		sorter.sort(list);47		System.out.println(list);48	}49}

SuperTypesLastSorter

Using AI Code Generation

1import org.mockito.internal.util.reflection.SuperTypesLastSorter;2import org.mockito.internal.util.reflection.GenericMetadataSupport;3import java.lang.reflect.Method;4import java.lang.reflect.Type;5import java.util.ArrayList;6import java.util.List;7public class Example {8    public static void main(String[] args) throws Exception {9        Method method = Example.class.getMethod("method", String.class, Integer.class);10        Type[] parameterTypes = method.getGenericParameterTypes();11        List<Type> parameterTypeList = new ArrayList<Type>();12        for (Type parameterType : parameterTypes) {13            parameterTypeList.add(parameterType);14        }15        SuperTypesLastSorter sorter = new SuperTypesLastSorter();16        List<Type> sortedParameterTypeList = sorter.sort(parameterTypeList);17        for (Type sortedParameterType : sortedParameterTypeList) {18            System.out.println(sortedParameterType);19        }20    }21    public void method(String string, Integer integer) {22    }23}

SuperTypesLastSorter

Using AI Code Generation

1package org.mockito.internal.util.reflection;2import java.util.ArrayList;3import java.util.Collections;4import java.util.List;5import org.mockito.exceptions.base.MockitoException;6import org.mockito.internal.util.collections.ListUtil;7import org.mockito.internal.util.reflection.SuperTypesLastSorter;8import org.mockito.internal.util.reflection.Types;9import org.mockito.invocation.InvocationOnMock;10import org.mockito.invocation.MockHandler;11import org.mockito.invocation.StubInfo;12import org.mockito.mock.MockCreationSettings;13import org.mockito.plugins.MockMaker;14import org.mockito.plugins.MockMaker.TypeMockability;15import org.mockito.stubbing.Answer;16import org.mockito.stubbing.OngoingStubbing;

SuperTypesLastSorter

Using AI Code Generation

1import org.mockito.internal.util.reflection.SuperTypesLastSorter;2import java.util.List;3import java.util.ArrayList;4import java.util.Collections;5import java.util.Comparator;6import java.lang.reflect.Type;7public class SuperTypesLastSorterTest {8   public static void main(String[] args) {9      List<Type> types = new ArrayList<Type>();10      types.add(Integer.class);11      types.add(Number.class);12      types.add(Object.class);13      Collections.sort(types, new SuperTypesLastSorter());14      System.out.println(types);15   }16}

SuperTypesLastSorter

Using AI Code Generation

1package org.mockito.internal.util.reflection;2import java.util.*;3public class SuperTypesLastSorterTest {4public static void main(String[] args) {5    List<Class<?>> classes = new ArrayList<Class<?>>();6    classes.add(SuperTypesLastSorter.class);7    classes.add(SuperTypesLastSorterTest.class);8    classes.add(List.class);9    classes.add(ArrayList.class);10    classes.add(Object.class);11    classes.add(Comparable.class);12    classes.add(Comparator.class);13    classes.add(Iterable.class);14    classes.add(Collection.class);15    classes.add(Iterator.class);16    classes.add(Enumeration.class);17    classes.add(RandomAccess.class);18    classes.add(Cloneable.class);19    classes.add(Serializable.class);20    classes.add(AbstractList.class);21    classes.add(AbstractCollection.class);22    classes.add(AbstractSequentialList.class);23    classes.add(AbstractSet.class);24    classes.add(HashSet.class);25    classes.add(LinkedHashSet.class);26    classes.add(TreeSet.class);27    classes.add(EnumSet.class);28    classes.add(CopyOnWriteArrayList.class);29    classes.add(CopyOnWriteArraySet.class);30    classes.add(Arrays.class);31    classes.add(Collections.class);32    classes.add(AbstractMap.class);33    classes.add(HashMap.class);34    classes.add(LinkedHashMap.class);35    classes.add(TreeMap.class);36    classes.add(WeakHashMap.class);37    classes.add(IdentityHashMap.class);38    classes.add(EnumMap.class);39    classes.add(ConcurrentHashMap.class);40    classes.add(ConcurrentSkipListMap.class);41    classes.add(ConcurrentSkipListSet.class);42    classes.add(Hashtable.class);43    classes.add(Properties.class);44    classes.add(Stack.class);45    classes.add(Vector.class);46    classes.add(BitSet.class);47    classes.add(Dictionary.clas

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.