KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

How to use ObjectMethodExpectationBouncer class of org.jmock.internal package

Best Jmock-library code snippet using org.jmock.internal.ObjectMethodExpectationBouncer

Source:Mockery.java

...19import org.jmock.internal.InvocationDispatcher;20import org.jmock.internal.InvocationDiverter;21import org.jmock.internal.InvocationToExpectationTranslator;22import org.jmock.internal.NamedSequence;23import org.jmock.internal.ObjectMethodExpectationBouncer;24import org.jmock.internal.ProxiedObjectIdentity;25import org.jmock.internal.ReturnDefaultValueAction;26import org.jmock.internal.SingleThreadedPolicy;27import org.jmock.lib.CamelCaseNamingScheme;28import org.jmock.lib.IdentityExpectationErrorTranslator;29import org.jmock.lib.JavaReflectionImposteriser;30import org.jmock.lib.concurrent.Synchroniser;31/**32 * A Mockery represents the context, or neighbourhood, of the object(s) under test.  33 * 34 * The neighbouring objects in that context are mocked out. The test specifies the 35 * expected interactions between the object(s) under test and its  neighbours and 36 * the Mockery checks those expectations while the test is running.37 * 38 * @author npryce39 * @author smgf40 * @author named by Ivan Moore.41 */42public class Mockery implements SelfDescribing {43    private Set<String> mockNames = new HashSet<String>();44    private Imposteriser imposteriser = JavaReflectionImposteriser.INSTANCE;45    private ExpectationErrorTranslator expectationErrorTranslator = IdentityExpectationErrorTranslator.INSTANCE;46    private MockObjectNamingScheme namingScheme = CamelCaseNamingScheme.INSTANCE;47    private ThreadingPolicy threadingPolicy = new SingleThreadedPolicy();48    49    private ReturnDefaultValueAction defaultAction = new ReturnDefaultValueAction(imposteriser);50    51    private InvocationDispatcher dispatcher = new InvocationDispatcher();52    private Error firstError = null;53    54    private List<Invocation> actualInvocations = new ArrayList<Invocation>();55    56    57    /* 58     * Policies59     */60    61    /**62     * Sets the result returned for the given type when no return value has been explicitly63     * specified in the expectation.64     * 65     * @param type66     *    The type for which to return <var>result</var>.67     * @param result68     *    The value to return when a method of return type <var>type</var>69     *    is invoked for which an explicit return value has has not been specified.70     */71    public void setDefaultResultForType(Class<?> type, Object result) {72        defaultAction.addResult(type, result);73    }74    75    /**76     * Changes the imposteriser used to adapt mock objects to the mocked type.77     * 78     * The default imposteriser allows a test to mock interfaces but not79     * classes, so you'll have to plug a different imposteriser into the80     * Mockery if you want to mock classes.81     */82    public void setImposteriser(Imposteriser imposteriser) {83        this.imposteriser = imposteriser;84        this.defaultAction.setImposteriser(imposteriser);85    }86    87    /**88     * Changes the naming scheme used to generate names for mock objects that 89     * have not been explicitly named in the test.90     * 91     * The default naming scheme names mock objects by lower-casing the first92     * letter of the class name, so a mock object of type BananaSplit will be93     * called "bananaSplit" if it is not explicitly named in the test.94     */95    public void setNamingScheme(MockObjectNamingScheme namingScheme) {96        this.namingScheme = namingScheme;97    }98    99    /**100     * Changes the expectation error translator used to translate expectation101     * errors into errors that report test failures.102     * 103     * By default, expectation errors are not translated and are thrown as104     * errors of type {@link ExpectationError}.  Plug in a new expectation error105     * translator if you want your favourite test framework to report expectation 106     * failures using its own error type.107     */108    public void setExpectationErrorTranslator(ExpectationErrorTranslator expectationErrorTranslator) {109        this.expectationErrorTranslator = expectationErrorTranslator;110    }111    112    /**113     * Changes the policy by which the Mockery copes with multiple threads.114     * 115     *  The default policy throws an exception if the Mockery is called from different116     *  threads.117     *  118     *  @see Synchroniser119     */120    public void setThreadingPolicy(ThreadingPolicy threadingPolicy) {121        this.threadingPolicy = threadingPolicy;122    }123    124    /*125     * API126     */127    128    /**129     * Creates a mock object of type <var>typeToMock</var> and generates a name for it.130     */131    public <T> T mock(Class<T> typeToMock) {132		return mock(typeToMock, namingScheme.defaultNameFor(typeToMock));133	}134    135    /**136     * Creates a mock object of type <var>typeToMock</var> with the given name.137     */138    public <T> T mock(Class<T> typeToMock, String name) {139        if (mockNames.contains(name)) {140            throw new IllegalArgumentException("a mock with name " + name + " already exists");141        }142        143        MockObject mock = new MockObject(typeToMock, name);144        mockNames.add(name);145        146        Invokable invokable =147            threadingPolicy.synchroniseAccessTo(148                new ProxiedObjectIdentity(149                    new InvocationDiverter<CaptureControl>(150                        CaptureControl.class, mock, mock)));151        152        return imposteriser.imposterise(invokable, typeToMock, CaptureControl.class);153    }154    155    /** 156     * Returns a new sequence that is used to constrain the order in which 157     * expectations can occur.158     * 159     * @param name160     *     The name of the sequence.161     * @return162     *     A new sequence with the given name.163     */164    public Sequence sequence(String name) {165        return new NamedSequence(name);166    }167    168    /** 169     * Returns a new state machine that is used to constrain the order in which 170     * expectations can occur.171     * 172     * @param name173     *     The name of the state machine.174     * @return175     *     A new state machine with the given name.176     */177    public States states(String name) {178        return dispatcher.newStateMachine(name);179    }180    181    /**182     * Specifies the expected invocations that the object under test will perform upon183     * objects in its context during the test.184     * 185     * The builder is responsible for interpreting high-level, readable API calls to 186     * construct an expectation.187     * 188     * This method can be called multiple times per test and the expectations defined in189     * each block are combined as if they were defined in same order within a single block.190     */191	public void checking(ExpectationBuilder expectations) {192	    expectations.buildExpectations(defaultAction, dispatcher);193    }194	195    /**196     * Adds an expected invocation that the object under test will perform upon197     * objects in its context during the test.198     * 199     * This method allows a test to define an expectation explicitly, bypassing the200     * high-level API, if desired.201     */202    public void addExpectation(Expectation expectation) {203        dispatcher.add(expectation);204    }205	206    /**207     * Fails the test if there are any expectations that have not been met.208     */209	public void assertIsSatisfied() {210	    if (firstError != null) {211	        throw firstError;212	    }213	    else if (!dispatcher.isSatisfied()) {214            throw expectationErrorTranslator.translate(215                new ExpectationError("not all expectations were satisfied", this));216        }217	}218    219    public void describeTo(Description description) {220        description.appendDescriptionOf(dispatcher);221        describeHistory(description);222    }223    private void describeMismatch(Invocation invocation, Description description) {224        dispatcher.describeMismatch(invocation, description);225        describeHistory(description);226    }227    228    private void describeHistory(Description description) {229        description.appendText("\nwhat happened before this:");230        231        if (actualInvocations.isEmpty()) {232            description.appendText(" nothing!");233        }234        else {235            description.appendList("\n  ", "\n  ", "\n", actualInvocations);236        }237    }238    private Object dispatch(Invocation invocation) throws Throwable {239        if (firstError != null) {240            throw firstError;241        }242        243        try {244            Object result = dispatcher.dispatch(invocation);245            actualInvocations.add(invocation);246            return result;247        }248        catch (ExpectationError e) {249            firstError = expectationErrorTranslator.translate(mismatchDescribing(e));250            firstError.setStackTrace(e.getStackTrace());251            throw firstError;252        }253        catch (Throwable t) {254            actualInvocations.add(invocation);255            throw t;256        }257    }258    259    private ExpectationError mismatchDescribing(final ExpectationError e) {260        ExpectationError filledIn = new ExpectationError(e.getMessage(), new SelfDescribing() {261            public void describeTo(Description description) {262                describeMismatch(e.invocation, description);263            }264        }, e.invocation);265        filledIn.setStackTrace(e.getStackTrace());266        return filledIn;267    }268    private class MockObject implements Invokable, CaptureControl {269        private Class<?> mockedType;270        private String name;271        272        public MockObject(Class<?> mockedType, String name) {273            this.name = name;274            this.mockedType = mockedType;275        }276        277        @Override278        public String toString() {279            return name;280        }281        282        public Object invoke(Invocation invocation) throws Throwable {283            return dispatch(invocation);284        }285        public Object captureExpectationTo(ExpectationCapture capture) {286            return imposteriser.imposterise(287                new ObjectMethodExpectationBouncer(new InvocationToExpectationTranslator(capture, defaultAction)), 288                mockedType);289        }290    }291}