Class MockRepository


  • public class MockRepository
    extends java.lang.Object
    Hold mock objects that should be used instead of the concrete implementation. Mock transformers may use this class to gather information on which classes and methods that are mocked.
    • Field Detail

      • objectsToAutomaticallyReplayAndVerify

        private static java.util.Set<java.lang.Object> objectsToAutomaticallyReplayAndVerify
      • newSubstitutions

        private static java.util.Map<java.lang.Class<?>,​NewInvocationControl<?>> newSubstitutions
      • classMocks

        private static java.util.Map<java.lang.Class<?>,​MethodInvocationControl> classMocks
        Holds info about general method invocation mocks for classes.
      • instanceMocks

        private static java.util.Map<java.lang.Object,​MethodInvocationControl> instanceMocks
        Holds info about general method invocation mocks for instances.
      • substituteReturnValues

        private static java.util.Map<java.lang.reflect.Method,​java.lang.Object> substituteReturnValues
        Holds info about which methods that should return a substitute/another instance instead of the default instance.
      • methodProxies

        private static java.util.Map<java.lang.reflect.Method,​java.lang.reflect.InvocationHandler> methodProxies
        Holds info about which methods that are proxied.
      • suppressStaticInitializers

        private static java.util.Set<java.lang.String> suppressStaticInitializers
        Holds info about which class that should have their static initializers suppressed.
      • additionalState

        private static java.util.Map<java.lang.String,​java.lang.Object> additionalState
        Sometimes mock frameworks needs to store additional state. They can do this using this key/value based approach.
      • suppressConstructor

        private static final java.util.Set<java.lang.reflect.Constructor<?>> suppressConstructor
        Set of constructors that should be suppressed.
      • suppressMethod

        private static final java.util.Set<java.lang.reflect.Method> suppressMethod
        Set of methods that should be suppressed.
      • suppressField

        private static final java.util.Set<java.lang.reflect.Field> suppressField
        Set of methods that should be suppressed.
      • suppressFieldTypes

        private static final java.util.Set<java.lang.String> suppressFieldTypes
        Set of field types that should always be suppressed regardless of instance.
      • afterMethodRunners

        private static final java.util.Set<java.lang.Runnable> afterMethodRunners
        Set of runnables that will be executed after the test (method) is completed.
    • Constructor Detail

      • MockRepository

        public MockRepository()
    • Method Detail

      • clear

        public static void clear()
        Clear all state of the mock repository except for static initializers. The reason for not clearing static initializers is that when running in a suite with many tests the clear method is invoked after each test. This means that before the test that needs to suppress the static initializer has been reach the state of the MockRepository would have been wiped out. This is generally not a problem because most state will be added again but suppression of static initializers are different because this state can only be set once per class per CL. That's why we cannot remove this state.
      • remove

        public static void remove​(java.lang.Object mock)
        Removes an object from the MockRepository if it exists.
      • getStaticMethodInvocationControl

        public static MethodInvocationControl getStaticMethodInvocationControl​(java.lang.Class<?> type)
      • removeClassMethodInvocationControl

        public static MethodInvocationControl removeClassMethodInvocationControl​(java.lang.Class<?> type)
      • getInstanceMethodInvocationControl

        public static MethodInvocationControl getInstanceMethodInvocationControl​(java.lang.Object instance)
      • removeInstanceMethodInvocationControl

        public static MethodInvocationControl removeInstanceMethodInvocationControl​(java.lang.Class<?> type)
      • getNewInstanceControl

        public static NewInvocationControl<?> getNewInstanceControl​(java.lang.Class<?> type)
      • addSuppressStaticInitializer

        public static void addSuppressStaticInitializer​(java.lang.String className)
        Add a fully qualified class name for a class that should have its static initializers suppressed.
        Parameters:
        className - The fully qualified class name for a class that should have its static initializers suppressed.
      • removeSuppressStaticInitializer

        public static void removeSuppressStaticInitializer​(java.lang.String className)
        Remove a fully qualified class name for a class that should no longer have its static initializers suppressed.
        Parameters:
        className - The fully qualified class name for a class that should no longer have its static initializers suppressed.
      • shouldSuppressStaticInitializerFor

        public static boolean shouldSuppressStaticInitializerFor​(java.lang.String className)
        Check whether or not a class with the fully qualified name should have its static initializers suppressed.
        Parameters:
        className - true if class with the fully qualified name className should have its static initializers suppressed, false otherwise.
      • getObjectsToAutomaticallyReplayAndVerify

        public static java.util.Set<java.lang.Object> getObjectsToAutomaticallyReplayAndVerify()
        Returns:
        All classes that should be automatically replayed or verified.
      • addObjectsToAutomaticallyReplayAndVerify

        public static void addObjectsToAutomaticallyReplayAndVerify​(java.lang.Object... objects)
        Add classes that should be automatically replayed or verified.
      • putAdditionalState

        public static java.lang.Object putAdditionalState​(java.lang.String key,
                                                          java.lang.Object value)
        When a mock framework API needs to store additional state not applicable for the other methods, it may use this method to do so.
        Parameters:
        key - The key under which the value is stored.
        value - The value to store under the specified key.
        Returns:
        The previous object under the specified key or null.
      • removeAdditionalState

        public static java.lang.Object removeAdditionalState​(java.lang.String key)
      • removeMethodProxy

        public static java.lang.reflect.InvocationHandler removeMethodProxy​(java.lang.reflect.Method method)
      • getAdditionalState

        public static <T> T getAdditionalState​(java.lang.String key)
        Retrieve state based on the supplied key.
      • addMethodToSuppress

        public static void addMethodToSuppress​(java.lang.reflect.Method method)
        Add a method to suppress.
        Parameters:
        method - The method to suppress.
      • addFieldToSuppress

        public static void addFieldToSuppress​(java.lang.reflect.Field field)
        Add a field to suppress.
        Parameters:
        field - The field to suppress.
      • addFieldTypeToSuppress

        public static void addFieldTypeToSuppress​(java.lang.String fieldType)
        Add a field type to suppress. All fields of this type will be suppressed.
        Parameters:
        fieldType - The fully-qualified name to a type. All fields of this type will be suppressed.
      • addConstructorToSuppress

        public static void addConstructorToSuppress​(java.lang.reflect.Constructor<?> constructor)
        Add a constructor to suppress.
        Parameters:
        constructor - The constructor to suppress.
      • hasMethodProxy

        public static boolean hasMethodProxy​(java.lang.reflect.Method method)
        Returns:
        true if the method should be proxied.
      • shouldSuppressMethod

        public static boolean shouldSuppressMethod​(java.lang.reflect.Method method,
                                                   java.lang.Class<?> objectType)
                                            throws java.lang.ClassNotFoundException
        Returns:
        true if the method should be suppressed.
        Throws:
        java.lang.ClassNotFoundException
      • shouldSuppressField

        public static boolean shouldSuppressField​(java.lang.reflect.Field field)
        Returns:
        true if the field should be suppressed.
      • shouldSuppressConstructor

        public static boolean shouldSuppressConstructor​(java.lang.reflect.Constructor<?> constructor)
        Returns:
        true if the constructor should be suppressed.
      • shouldStubMethod

        public static boolean shouldStubMethod​(java.lang.reflect.Method method)
        Returns:
        true if the method has a substitute return value.
      • getMethodToStub

        public static java.lang.Object getMethodToStub​(java.lang.reflect.Method method)
        Returns:
        The substitute return value for a particular method, may be null.
      • putMethodToStub

        public static java.lang.Object putMethodToStub​(java.lang.reflect.Method method,
                                                       java.lang.Object value)
        Set a substitute return value for a method. Whenever this method will be called the value will be returned instead.
        Returns:
        The previous substitute value if any.
      • getMethodProxy

        public static java.lang.reflect.InvocationHandler getMethodProxy​(java.lang.reflect.Method method)
        Returns:
        The proxy for a particular method, may be null.
      • putMethodProxy

        public static java.lang.reflect.InvocationHandler putMethodProxy​(java.lang.reflect.Method method,
                                                                         java.lang.reflect.InvocationHandler invocationHandler)
        Set a proxy for a method. Whenever this method is called the invocation handler will be invoked instead.
        Returns:
        The method proxy if any.
      • addAfterMethodRunner

        public static void addAfterMethodRunner​(java.lang.Runnable runnable)
        Add a Runnable that will be executed after each test
        Parameters:
        runnable -