mockit

Class MockUp<T>

java.lang.Object

mockit.MockUp<T>

Type Parameters:

T - specifies the type (class, interface, etc.) to be mocked; multiple interfaces can be mocked by defining a type variable in the test class or test method, and using it as the type argument; if a type variable is used but it extends a single type, then all implementation classes extending/implementing that base type are also mocked; if the type argument itself is a parameterized type, then only its raw type is considered for mocking

public abstract class MockUp<T>
extends Object

A base class used in the creation of a mock-up for a class or interface. Such mock-ups can be used in state-based unit tests or as fake implementations for use in integration tests.

 // Define and apply one or more mock-ups:
 new MockUp<SomeClass>() {
    @Mock int someMethod(int i) { assertTrue(i > 0); return 123; }
    @Mock(maxInvocations = 2) void anotherMethod(int i, String s) { /* validate arguments */ }
 };

 // Exercise code under test:
 codeUnderTest.doSomething();
 

One or more mock methods annotated as such must be defined in the concrete subclass. Each @Mock method should have a matching method or constructor in the mocked class/interface. At runtime, the execution of a mocked method/constructor will get redirected to the corresponding mock method.

When mocking an interface, an implementation class is generated where all methods are empty, with non-void methods returning a default value according to the return type: 0 for int, null for a reference type, and so on.

When the type to be mocked is specified indirectly through a type variable, there are two other possible outcomes:

1. If the type variable "extends" two or more interfaces, a mocked proxy class that implements all interfaces is created, with the proxy instance made available through a call to getMockInstance(). Example:

   
    @Test
    public <M extends Runnable & ResultSet> void someTest() {
        M mock = new MockUp<M>() {
           @Mock void run() { ...do something... }
           @Mock boolean next() { return true; }
        }.getMockInstance();
   
        mock.run();
        assertTrue(mock.next());
    }
    

2. If the type variable extends a single type (either an interface or a class), then that type is taken as a base type whose concrete implementation classes should also get mocked. Example:

   
    @Test
    public <BC extends SomeBaseClass> void someTest() {
        new MockUp<BC>() {
           @Mock int someMethod(int i) { return i + 1; }
        };
   
        int i = new AConcreteSubclass().someMethod(1);
        assertEquals(2, i);
    }
    

See Also:

MockUp(), MockUp(Class), MockUp(Object), getMockInstance(), tearDown(), Tutorial

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	MockUp() Applies the mock methods defined in the concrete subclass to the class or interface specified through the type parameter.
protected	MockUp(Class<?> classToMock) Applies the mock methods defined in the mock-up subclass to the given class/interface.
protected	MockUp(T instanceToMock) Applies the mock methods defined in the mock-up subclass to the type specified through the type parameter, but only affecting the given instance.

Method Summary

Modifier and Type	Method and Description
T	getMockInstance() Returns the mock instance exclusively associated with this mock-up instance.
void	tearDown() Discards the mock methods originally set up by instantiating this mock-up object, restoring mocked methods to their original behaviors.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MockUp

protected MockUp()

Applies the mock methods defined in the concrete subclass to the class or interface specified through the type parameter.

Throws:

IllegalArgumentException - if no type to be mocked was specified; or if multiple types were specified through a type variable but not all of them are interfaces; or if there is a mock method for which no corresponding real method or constructor is found; or if the real method matching a mock method is abstract

See Also:

MockUp(Class), MockUp(Object)

MockUp

protected MockUp(Class<?> classToMock)

Applies the mock methods defined in the mock-up subclass to the given class/interface.

In most cases, the constructor with no parameters can be used. This variation should be used only when the type to be mocked is not accessible or known to the test.

See Also:

MockUp(), MockUp(Object)

MockUp

protected MockUp(T instanceToMock)

Applies the mock methods defined in the mock-up subclass to the type specified through the type parameter, but only affecting the given instance.

In most cases, the constructor with no parameters should be adequate. This variation can be used when mock data or behavior is desired only for a particular instance, with other instances remaining unaffected; or when multiple mock-up objects carrying different states are desired, with one mock-up instance per real instance to be mocked.

If getMockInstance() later gets called on this mock-up instance, it will return the instance that was given here.

Parameters:

instanceToMock - a real instance of the type to be mocked, meant to be the only one of that type that should be affected by this mock-up instance; must not be null

See Also:

MockUp(), MockUp(Class)

Method Detail

getMockInstance

public final T getMockInstance()

Returns the mock instance exclusively associated with this mock-up instance. If the mocked type was an interface, then said instance is the one that was automatically created when the mock-up was applied. If it was a class, and no such instance is currently associated with this mock-up object, then a new uninitialized instance of the mocked class is created and returned, becoming associated with the mock-up. If a regular initialized instance was desired, then the MockUp(Object) constructor should have been used instead.

In any case, for a given mock-up instance this method will always return the same mock instance.

See Also:

Tutorial

tearDown

public final void tearDown()

Discards the mock methods originally set up by instantiating this mock-up object, restoring mocked methods to their original behaviors.

Note that JMockit will automatically restore classes mocked by a test at the end of its execution, as well as classes mocked for the whole test class before the first test in the next test class is executed.