How to use filter method of org.mockito.internal.util.reflection.Fields class

Best Mockito code snippet using org.mockito.internal.util.reflection.Fields.filter

Source:PropertyAndSetterInjection.java

...14import java.util.Iterator;15import java.util.List;16import java.util.Set;17import org.mockito.exceptions.base.MockitoException;18import org.mockito.internal.configuration.injection.filter.MockCandidateFilter;19import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter;20import org.mockito.internal.configuration.injection.filter.TerminalMockCandidateFilter;21import org.mockito.internal.configuration.injection.filter.TypeBasedCandidateFilter;22import org.mockito.internal.util.collections.ListUtil;23import org.mockito.internal.util.reflection.FieldInitializationReport;24import org.mockito.internal.util.reflection.FieldInitializer;25/**26 * Inject mocks using first setters then fields, if no setters available.27 *28 * <p>29 * <u>Algorithm :<br></u>30 * for each field annotated by @InjectMocks31 *   <ul>32 *   <li>initialize field annotated by @InjectMocks33 *   <li>for each fields of a class in @InjectMocks type hierarchy34 *     <ul>35 *     <li>make a copy of mock candidates36 *     <li>order fields from sub-type to super-type, then by field name37 *     <li>for the list of fields in a class try two passes of :38 *         <ul>39 *             <li>find mock candidate by type40 *             <li>if more than <b>*one*</b> candidate find mock candidate on name41 *             <li>if one mock candidate then42 *                 <ul>43 *                     <li>set mock by property setter if possible44 *                     <li>else set mock by field injection45 *                 </ul>46 *             <li>remove mock from mocks copy (mocks are just injected once in a class)47 *             <li>remove injected field from list of class fields48 *         </ul>49 *     <li>else don't fail, user will then provide dependencies50 *     </ul>51 *   </ul>52 * </p>53 *54 * <p>55 * <u>Note:</u> If the field needing injection is not initialized, the strategy tries56 * to create one using a no-arg constructor of the field type.57 * </p>58 */59public class PropertyAndSetterInjection extends MockInjectionStrategy {60    private final MockCandidateFilter mockCandidateFilter =61            new TypeBasedCandidateFilter(62                    new NameBasedCandidateFilter(63                            new TerminalMockCandidateFilter()));64    private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {65        public boolean isOut(Field object) {66            return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers());67        }68    };69    public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {70        FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);71        // for each field in the class hierarchy72        boolean injectionOccurred = false;73        Class<?> fieldClass = report.fieldClass();74        Object fieldInstanceNeedingInjection = report.fieldInstance();75        while (fieldClass != Object.class) {76            injectionOccurred |= injectMockCandidates(fieldClass, fieldInstanceNeedingInjection, newMockSafeHashSet(mockCandidates));77            fieldClass = fieldClass.getSuperclass();78        }79        return injectionOccurred;80    }81    private FieldInitializationReport initializeInjectMocksField(Field field, Object fieldOwner) {82        try {83            return new FieldInitializer(fieldOwner, field).initialize();84        } catch (MockitoException e) {85            if(e.getCause() instanceof InvocationTargetException) {86                Throwable realCause = e.getCause().getCause();87                throw fieldInitialisationThrewException(field, realCause);88            }89            throw cannotInitializeForInjectMocksAnnotation(field.getName(),e.getMessage());90        }91    }92    private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Object injectee, Set<Object> mocks) {93        boolean injectionOccurred;94        List<Field> orderedCandidateInjecteeFields = orderedInstanceFieldsFrom(awaitingInjectionClazz);95        // pass 196        injectionOccurred = injectMockCandidatesOnFields(mocks, injectee, false, orderedCandidateInjecteeFields);97        // pass 298        injectionOccurred |= injectMockCandidatesOnFields(mocks, injectee, injectionOccurred, orderedCandidateInjecteeFields);99        return injectionOccurred;100    }101    private boolean injectMockCandidatesOnFields(Set<Object> mocks,102                                                 Object injectee,103                                                 boolean injectionOccurred,104                                                 List<Field> orderedCandidateInjecteeFields) {105        for (Iterator<Field> it = orderedCandidateInjecteeFields.iterator(); it.hasNext(); ) {106            Field candidateField = it.next();107            Object injected = mockCandidateFilter.filterCandidate(mocks, candidateField, orderedCandidateInjecteeFields, injectee)108                                                 .thenInject();109            if (injected != null) {110                injectionOccurred |= true;111                mocks.remove(injected);112                it.remove();113            }114        }115        return injectionOccurred;116    }117    private List<Field> orderedInstanceFieldsFrom(Class<?> awaitingInjectionClazz) {118        List<Field> declaredFields = Arrays.asList(awaitingInjectionClazz.getDeclaredFields());119        declaredFields = ListUtil.filter(declaredFields, notFinalOrStatic);120        return sortSuperTypesLast(declaredFields);121    }122}...

Source:19PropertyAndSetterInjection.java

...4 */5package org.mockito.internal.configuration.injection;6import org.mockito.exceptions.Reporter;7import org.mockito.exceptions.base.MockitoException;8import org.mockito.internal.configuration.injection.filter.FinalMockCandidateFilter;9import org.mockito.internal.configuration.injection.filter.MockCandidateFilter;10import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter;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:Mockito_19_53.java

...4 */5package org.mockito.internal.configuration.injection;6import org.mockito.exceptions.Reporter;7import org.mockito.exceptions.base.MockitoException;8import org.mockito.internal.configuration.injection.filter.FinalMockCandidateFilter;9import org.mockito.internal.configuration.injection.filter.MockCandidateFilter;10import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter;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:Mockito_19_136.java

...4 */5package org.mockito.internal.configuration.injection;6import org.mockito.exceptions.Reporter;7import org.mockito.exceptions.base.MockitoException;8import org.mockito.internal.configuration.injection.filter.FinalMockCandidateFilter;9import org.mockito.internal.configuration.injection.filter.MockCandidateFilter;10import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter;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                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:Mockito_19_137.java

...4 */5package org.mockito.internal.configuration.injection;6import org.mockito.exceptions.Reporter;7import org.mockito.exceptions.base.MockitoException;8import org.mockito.internal.configuration.injection.filter.FinalMockCandidateFilter;9import org.mockito.internal.configuration.injection.filter.MockCandidateFilter;10import org.mockito.internal.configuration.injection.filter.NameBasedCandidateFilter;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                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}...

filter

Using AI Code Generation

1import org.mockito.internal.util.reflection.Fields;2import org.mockito.internal.util.reflection.FieldFilter;3public class 1 {4    public static void main(String[] args) {5        Fields fields = new Fields();6        FieldFilter filter = new FieldFilter() {7            public boolean accept(Field field) {8                return Modifier.isStatic(field.getModifiers());9            }10        };

filter

Using AI Code Generation

1import org.mockito.internal.util.reflection.Fields;2import org.mockito.internal.util.reflection.FieldFilter;3import org.mockito.internal.util.reflection.FieldReader;4import org.mockito.internal.util.reflection.FieldInitializer;5import org.mockito.internal.util.reflection.FieldWriter;6import java.lang.reflect.Field;7import java.lang.reflect.Modifier;8import java.util.List;9import java.util.ArrayList;10import java.util.Arrays;11public class FieldsTest {12    public static void main(String[] args) {13        List<Field> fields = Fields.allDeclaredFieldsOf(FieldsTest.class);14        printFields(fields);15    }16    private static void printFields(List<Field> fields) {17        for (Field field : fields) {18            System.out.println("Field name: " + field.getName());19            System.out.println("Field type: " + field.getType());20            System.out.println("Field modifiers: " + Modifier.toString(field.getModifiers()));21        }22    }23}24import org.mockito.internal.util.reflection.Fields;25import org.mockito.internal.util.reflection.FieldFilter;26import org.mockito.internal.util.reflection.FieldReader;27import org.mockito.internal.util.reflection.FieldInitializer;28import org.mockito.internal.util.reflection.FieldWriter;29import java.lang.reflect.Field;30import java.lang.reflect.Modifier;31import java.util.List;32import java.util.ArrayList;33import java.util.Arrays;34public class FieldsTest {35    public static void main(String[] args) {36        List<Field> fields = Fields.allDeclaredFieldsOf(FieldsTest.class, new FieldFilter() {37            public boolean accepts(Field field) {38                return field.getName().startsWith("f");39            }40        });41        printFields(fields);42    }43    private static void printFields(List<Field> fields) {44        for (Field field : fields) {45            System.out.println("Field name: " + field.getName());46            System.out.println("Field type: " + field.getType());47            System.out.println("Field modifiers: " + Modifier.toString(field.getModifiers()));48        }49    }50}

filter

Using AI Code Generation

1package org.mockito.internal.util.reflection;2import org.mockito.internal.util.reflection.Fields;3import java.lang.reflect.Field;4public class FieldsTest {5    public static void main(String[] args) throws Exception {6        Class<?> clazz = Class.forName("org.mockito.internal.util.reflection.FieldsTest");7        Field[] fields = Fields.filter(clazz.getDeclaredFields(), new Fields.Filter() {8            public boolean accept(Field field) {9                return field.getName().equals("test");10            }11        });12        for (Field field : fields) {13            System.out.println(field.getName());14        }15    }16    private String test = "test";17}18package org.mockito.internal.util.reflection;19import org.mockito.internal.util.reflection.Fields;20import java.lang.reflect.Field;21public class FieldsTest {22    public static void main(String[] args) throws Exception {23        Class<?> clazz = Class.forName("org.mockito.internal.util.reflection.FieldsTest");24        Field[] fields = Fields.filter(clazz.getDeclaredFields(), new Fields.Filter() {25            public boolean accept(Field field) {26                return field.getName().equals("test");27            }28        });29        for (Field field : fields) {30            System.out.println(field.getName());31        }32    }33    private String test = "test";34}35package org.mockito.internal.util.reflection;36import org.mockito.internal.util.reflection.Fields;37import java.lang.reflect.Field;38public class FieldsTest {39    public static void main(String[] args) throws Exception {40        Class<?> clazz = Class.forName("org.mockito.internal.util.reflection.FieldsTest");41        Field[] fields = Fields.filter(clazz.getDeclaredFields(), new Fields.Filter() {42            public boolean accept(Field field) {43                return field.getName().equals("test");44            }45        });46        for (Field field : fields) {47            System.out.println(field.getName());48        }49    }50    private String test = "test";51}52package org.mockito.internal.util.reflection;53import org.mockito.internal.util.reflection.Fields;54import java.lang.reflect.Field;55public class FieldsTest {56    public static void main(String[] args) throws Exception {57        Class<?> clazz = Class.forName("

filter

Using AI Code Generation

1import org.mockito.internal.util.reflection.Fields;2import java.lang.reflect.Field;3import java.util.List;4import java.util.ArrayList;5import java.util.Arrays;6import java.util.Collection;7import java.util.Collections;8import java.io.Serializable;9import java.lang.reflect.Modifier;10import java.lang.reflect.Type;11import java.lang.reflect.ParameterizedType;12public class Test1 {13    public static void main(String[] args) {14        List<Field> fields = Fields.filter(Fields.allDeclaredFieldsOf(Test1.class), 15                new Fields.Filter() {16            public boolean isOut(Field field) {17                return field.getName().equals("serialVersionUID");18            }19        });20        for (Field field : fields) {21            System.out.println(field.getName());22        }23    }24}

filter

Using AI Code Generation

1import org.mockito.internal.util.reflection.Fields;2import org.mockito.internal.util.reflection.FieldFilter;3import java.util.Map;4public class 1 {5    public static void main(String[] args) {6        Fields fields = new Fields();7        FieldFilter filter = new FieldFilter() {8            public boolean accept(Field field) {9                return Map.class.isAssignableFrom(field.getType());10            }11        };12        List<Field> filteredFields = fields.filter(filter, new ClassWithMapFields());13        System.out.println(filteredFields);14    }15}16import org.mockito.internal.util.reflection.Fields;17import org.mockito.internal.util.reflection.FieldFilter;18import java.util.Map;19public class 1 {20    public static void main(String[] args) {21        Fields fields = new Fields();22        FieldFilter filter = new FieldFilter() {23            public boolean accept(Field field) {24                return Map.class.isAssignableFrom(field.getType());25            }26        };27        List<Field> filteredFields = fields.filter(filter, new ClassWithMapFields());28        System.out.println(filteredFields);29    }30}31import org.mockito.internal.util.reflection.Fields;32import org.mockito.internal.util.reflection.FieldFilter;33import java.util.Map;34public class 1 {35    public static void main(String[] args) {36        Fields fields = new Fields();37        FieldFilter filter = new FieldFilter() {38            public boolean accept(Field field) {39                return Map.class.isAssignableFrom(field.getType());40            }41        };42        List<Field> filteredFields = fields.filter(filter, new ClassWithMapFields());43        System.out.println(filteredFields);44    }45}46import org.mockito.internal.util.reflection.Fields;47import

filter

Using AI Code Generation

1public class Test {2  public static void main(String[] args) {3    Fields fields = new Fields();4    Field[] field = fields.filter(new FieldFilter() {5      public boolean isOut(Field field) {6        return field.getName().equals("name");7      }8    });9    System.out.println(field.length);10  }11}12public class Test {13  public static void main(String[] args) {14    Methods methods = new Methods();15    Method[] method = methods.filter(new MethodFilter() {16      public boolean isOut(Method method) {17        return method.getName().equals("getName");18      }19    });20    System.out.println(method.length);21  }22}23public class Test {24  public static void main(String[] args) {25    Constructors constructors = new Constructors();26    Constructor[] constructor = constructors.filter(new ConstructorFilter() {27      public boolean isOut(Constructor constructor) {28        return constructor.getParameterTypes().length == 0;29      }30    });31    System.out.println(constructor.length);32  }33}34public class Test {35  public static void main(String[] args) {36    Invocations invocations = new Invocations();37    Invocation[] invocation = invocations.filter(new InvocationFilter() {38      public boolean isOut(Invocation invocation) {39        return invocation.getMethod().getName().equals("getName");40      }41    });42    System.out.println(invocation.length);43  }44}45public class Test {46  public static void main(String[] args) {47    Invocations invocations = new Invocations();48    Invocation[] invocation = invocations.filter(new InvocationFilter() {49      public boolean isOut(Invocation invocation) {50        return invocation.getMethod().getName().equals("getName");51      }52    });53    System.out.println(invocation.length);54  }55}56public class Test {57  public static void main(String[] args) {58    Invocations invocations = new Invocations();59    Invocation[] invocation = invocations.filter(new Invocation

filter

Using AI Code Generation

1package com.ack.j2se.mockito;2import java.util.List;3import org.mockito.internal.util.reflection.Fields;4import org.mockito.internal.util.reflection.Fields.FieldFilter;5public class FieldsTest {6  public static void main( String[] args ) {7    FieldFilter filter = new FieldFilter() {8      public boolean accept( Field field ) {9        return field.getType().equals( int.class );10      }11    };12    List<Field> fields = Fields.filter( SomeClass.class, filter );13    for( Field field : fields ) {14      System.out.println( "Field: " + field.getName() );15    }16  }17}18class SomeClass {19  private int field1;20  private int field2;21  private String field3;22  private int field4;23  private int field5;24}

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.