How to use method of org.easymock.tests.UsageVerifyTest class

1/*
2 * Copyright 2001-2021 the original author or authors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.easymock.tests;
17
18import org.easymock.internal.ReplayState;
19import org.junit.Before;
20import org.junit.Test;
21
22import java.io.IOException;
23
24import static org.easymock.EasyMock.*;
25import static org.junit.Assert.*;
26
27/**
28 * @author OFFIS, Tammo Freese
29 */
30public class UsageVerifyTest {
31
32    private IMethods mock;
33
34    @Before
35    public void setup() {
36        mock = createMock(IMethods.class);
37    }
38
39    @Test
40    public void twoReturns() {
41        expect(mock.throwsNothing(true)).andReturn("Test").andReturn("Test2");
42
43        replay(mock);
44
45        assertEquals("Test", mock.throwsNothing(true));
46
47        boolean failed = true;
48
49        try {
50            verify(mock);
51            failed = false;
52        } catch (AssertionError expected) {
53            assertEquals("\n  Expectation failure on verify:"
54                    + "\n    IMethods.throwsNothing(true): expected: 2, actual: 1", expected.getMessage());
55            assertEquals("stack trace must be filled in", Util.getStackTrace(expected).indexOf(
56                ReplayState.class.getName()), -1);
57        }
58
59        if (!failed)
60            fail("AssertionError expected");
61
62        assertEquals("Test2", mock.throwsNothing(true));
63
64        verify(mock);
65
66        try {
67            mock.throwsNothing(true);
68            fail("AssertionError expected");
69        } catch (AssertionError expected) {
70            assertEquals("\n  Unexpected method call IMethods.throwsNothing(true):"
71                    + "\n    IMethods.throwsNothing(true): expected: 2, actual: 3", expected.getMessage());
72        }
73    }
74
75    @Test
76    public void atLeastTwoReturns() {
77        expect(mock.throwsNothing(true)).andReturn("Test").andReturn("Test2").atLeastOnce();
78
79        replay(mock);
80
81        assertEquals("Test", mock.throwsNothing(true));
82
83        try {
84            verify(mock);
85            fail("AssertionError expected");
86        } catch (AssertionError expected) {
87
88            assertEquals("\n  Expectation failure on verify:"
89                    + "\n    IMethods.throwsNothing(true): expected: at least 2, actual: 1", expected
90                    .getMessage());
91        }
92
93        assertEquals("Test2", mock.throwsNothing(true));
94        assertEquals("Test2", mock.throwsNothing(true));
95
96        verify(mock);
97    }
98
99    @Test
100    public void twoThrows() throws IOException {
101        expect(mock.throwsIOException(0)).andThrow(new IOException()).andThrow(new IOException());
102        expect(mock.throwsIOException(1)).andThrow(new IOException());
103
104        replay(mock);
105
106        try {
107            mock.throwsIOException(0);
108            fail("IOException expected");
109        } catch (IOException expected) {
110        }
111
112        try {
113            verify(mock);
114            fail("AssertionError expected");
115        } catch (AssertionError expected) {
116            assertEquals("\n  Expectation failure on verify:"
117                    + "\n    IMethods.throwsIOException(0 (int)): expected: 2, actual: 1"
118                    + "\n    IMethods.throwsIOException(1 (int)): expected: 1, actual: 0", expected.getMessage());
119        }
120
121        try {
122            mock.throwsIOException(0);
123            fail("IOException expected");
124        } catch (IOException expected) {
125        }
126
127        try {
128            verify(mock);
129            fail("AssertionError expected");
130        } catch (AssertionError expected) {
131            assertEquals("\n  Expectation failure on verify:"
132                    + "\n    IMethods.throwsIOException(1 (int)): expected: 1, actual: 0", expected.getMessage());
133        }
134
135        try {
136            mock.throwsIOException(1);
137            fail("IOException expected");
138        } catch (IOException expected) {
139        }
140
141        verify(mock);
142
143        try {
144            mock.throwsIOException(0);
145            fail("AssertionError expected");
146        } catch (AssertionError expected) {
147            assertEquals("\n  Unexpected method call IMethods.throwsIOException(0 (int)):"
148                    + "\n    IMethods.throwsIOException(0 (int)): expected: 2, actual: 3", expected.getMessage());
149        }
150    }
151
152    @Test
153    public void manyMocks() {
154        IMethods otherMock = mock(IMethods.class);
155        expect(otherMock.oneArg(1)).andReturn("test");
156        replay(mock, otherMock);
157
158        try {
159            verify(mock, otherMock);
160            fail("Should fail on otherMock");
161        } catch (AssertionError e) {
162            assertEquals(AssertionError.class, e.getClass());
163            assertEquals("On mock #1 (zero indexed): \n  Expectation failure on verify:\n    IMethods.oneArg(1 (int)): expected: 1, actual: 0", e.getMessage());
164        }
165    }
166
167    @Test
168    public void callExtraMethodsCheckedInVerify() {
169        IMethods mock = mock(IMethods.class);
170        replay(mock);
171
172        try {
173            mock.simpleMethod();
174        } catch(AssertionError e) {
175            // eat the exception and so prevent the test from failing
176        }
177
178        try {
179            mock.oneArg(1);
180        } catch(AssertionError e) {
181            // eat the exception and so prevent the test from failing
182        }
183
184        // the verify should notice an assertion failed earlier
185        try {
186            verify(mock);
187            fail("Should find unexpected calls");
188        } catch(AssertionError e) {
189            assertEquals("\n  Unexpected method calls:" +
190                "\n    IMethods.simpleMethod()" +
191                "\n    IMethods.oneArg(1 (int))", e.getMessage());
192        }
193    }
194
195    @Test
196    public void uncalledAndUnexpected() {
197        IMethods mock = mock(IMethods.class);
198        expect(mock.oneArg(1)).andReturn("test");
199        replay(mock);
200
201        try {
202            mock.simpleMethod();
203        } catch(AssertionError e) {
204            // eat the exception and so prevent the test from failing
205        }
206
207        // the verify should notice an assertion failed earlier
208        try {
209            verify(mock);
210            fail("Should find unexpected calls");
211        } catch(AssertionError e) {
212            assertEquals(
213                "\n  Expectation failure on verify:" +
214                    "\n    IMethods.oneArg(1 (int)): expected: 1, actual: 0" +
215                    "\n  Unexpected method calls:" +
216                    "\n    IMethods.simpleMethod()", e.getMessage());
217        }
218    }
219
220    @Test
221    public void verifyRecordingTest() {
222        IMethods mock = mock(IMethods.class);
223        expect(mock.oneArg(1)).andReturn("test");
224        replay(mock);
225
226        try {
227            verifyRecording(mock);
228            fail("Should see unused expectations");
229        } catch(AssertionError e) {
230            assertEquals(
231                "\n  Expectation failure on verify:" +
232                    "\n    IMethods.oneArg(1 (int)): expected: 1, actual: 0", e.getMessage());
233        }
234    }
235
236    @Test
237    public void verifyUnexpectedCallsTest() {
238        IMethods mock = mock(IMethods.class);
239        replay(mock);
240
241        try {
242            mock.simpleMethod();
243        } catch(AssertionError e) {
244            // eat the exception and so prevent the test from failing
245        }
246
247        // the verify should notice an assertion failed earlier
248        try {
249            verifyUnexpectedCalls(mock);
250            fail("Should find unexpected calls");
251        } catch(AssertionError e) {
252            assertEquals("\n  Unexpected method calls:" +
253                    "\n    IMethods.simpleMethod()", e.getMessage());
254        }
255    }
256}
257

Source: UsageVerifyTest.java

/*
 * Copyright 2001-2021 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.easymock.tests;

import org.easymock.internal.ReplayState;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

import static org.easymock.EasyMock.*;
import static org.junit.Assert.*;

/**
 * @author OFFIS, Tammo Freese
 */
public class UsageVerifyTest {

    private IMethods mock;

    @Before
    public void setup() {
        mock = createMock(IMethods.class);
    }

    @Test
    public void twoReturns() {
        expect(mock.throwsNothing(true)).andReturn("Test").andReturn("Test2");

        replay(mock);

        assertEquals("Test", mock.throwsNothing(true));

        boolean failed = true;

        try {
            verify(mock);
            failed = false;
        } catch (AssertionError expected) {
            assertEquals("\n  Expectation failure on verify:"
                    + "\n    IMethods.throwsNothing(true): expected: 2, actual: 1", expected.getMessage());
            assertEquals("stack trace must be filled in", Util.getStackTrace(expected).indexOf(
                ReplayState.class.getName()), -1);
        }

        if (!failed)
            fail("AssertionError expected");

        assertEquals("Test2", mock.throwsNothing(true));

        verify(mock);

        try {
            mock.throwsNothing(true);
            fail("AssertionError expected");
        } catch (AssertionError expected) {
            assertEquals("\n  Unexpected method call IMethods.throwsNothing(true):"
                    + "\n    IMethods.throwsNothing(true): expected: 2, actual: 3", expected.getMessage());
        }
    }

    @Test
    public void atLeastTwoReturns() {
        expect(mock.throwsNothing(true)).andReturn("Test").andReturn("Test2").atLeastOnce();

        replay(mock);

        assertEquals("Test", mock.throwsNothing(true));

        try {
            verify(mock);
            fail("AssertionError expected");
        } catch (AssertionError expected) {

            assertEquals("\n  Expectation failure on verify:"
                    + "\n    IMethods.throwsNothing(true): expected: at least 2, actual: 1", expected
                    .getMessage());
        }

        assertEquals("Test2", mock.throwsNothing(true));
        assertEquals("Test2", mock.throwsNothing(true));

        verify(mock);
    }

    @Test
    public void twoThrows() throws IOException {
        expect(mock.throwsIOException(0)).andThrow(new IOException()).andThrow(new IOException());
        expect(mock.throwsIOException(1)).andThrow(new IOException());

        replay(mock);

        try {
            mock.throwsIOException(0);
            fail("IOException expected");
        } catch (IOException expected) {
        }

        try {
            verify(mock);
            fail("AssertionError expected");
        } catch (AssertionError expected) {
            assertEquals("\n  Expectation failure on verify:"
                    + "\n    IMethods.throwsIOException(0 (int)): expected: 2, actual: 1"
                    + "\n    IMethods.throwsIOException(1 (int)): expected: 1, actual: 0", expected.getMessage());
        }

        try {
            mock.throwsIOException(0);
            fail("IOException expected");
        } catch (IOException expected) {
        }

        try {
            verify(mock);
            fail("AssertionError expected");
        } catch (AssertionError expected) {
            assertEquals("\n  Expectation failure on verify:"
                    + "\n    IMethods.throwsIOException(1 (int)): expected: 1, actual: 0", expected.getMessage());
        }

        try {
            mock.throwsIOException(1);
            fail("IOException expected");
        } catch (IOException expected) {
        }

        verify(mock);

        try {
            mock.throwsIOException(0);
            fail("AssertionError expected");
        } catch (AssertionError expected) {
            assertEquals("\n  Unexpected method call IMethods.throwsIOException(0 (int)):"
                    + "\n    IMethods.throwsIOException(0 (int)): expected: 2, actual: 3", expected.getMessage());
        }
    }

    @Test
    public void manyMocks() {
        IMethods otherMock = mock(IMethods.class);
        expect(otherMock.oneArg(1)).andReturn("test");
        replay(mock, otherMock);

        try {
            verify(mock, otherMock);
            fail("Should fail on otherMock");
        } catch (AssertionError e) {
            assertEquals(AssertionError.class, e.getClass());
            assertEquals("On mock #1 (zero indexed): \n  Expectation failure on verify:\n    IMethods.oneArg(1 (int)): expected: 1, actual: 0", e.getMessage());
        }
    }

    @Test
    public void callExtraMethodsCheckedInVerify() {
        IMethods mock = mock(IMethods.class);
        replay(mock);

        try {
            mock.simpleMethod();
        } catch(AssertionError e) {
            // eat the exception and so prevent the test from failing
        }

        try {
            mock.oneArg(1);
        } catch(AssertionError e) {
            // eat the exception and so prevent the test from failing
        }

        // the verify should notice an assertion failed earlier
        try {
            verify(mock);
            fail("Should find unexpected calls");
        } catch(AssertionError e) {
            assertEquals("\n  Unexpected method calls:" +
                "\n    IMethods.simpleMethod()" +
                "\n    IMethods.oneArg(1 (int))", e.getMessage());
        }
    }

    @Test
    public void uncalledAndUnexpected() {
        IMethods mock = mock(IMethods.class);
        expect(mock.oneArg(1)).andReturn("test");
        replay(mock);

        try {
            mock.simpleMethod();
        } catch(AssertionError e) {
            // eat the exception and so prevent the test from failing
        }

        // the verify should notice an assertion failed earlier
        try {
            verify(mock);
            fail("Should find unexpected calls");
        } catch(AssertionError e) {
            assertEquals(
                "\n  Expectation failure on verify:" +
                    "\n    IMethods.oneArg(1 (int)): expected: 1, actual: 0" +
                    "\n  Unexpected method calls:" +
                    "\n    IMethods.simpleMethod()", e.getMessage());
        }
    }

    @Test
    public void verifyRecordingTest() {
        IMethods mock = mock(IMethods.class);
        expect(mock.oneArg(1)).andReturn("test");
        replay(mock);

        try {
            verifyRecording(mock);
            fail("Should see unused expectations");
        } catch(AssertionError e) {
            assertEquals(
                "\n  Expectation failure on verify:" +
                    "\n    IMethods.oneArg(1 (int)): expected: 1, actual: 0", e.getMessage());
        }
    }

    @Test
    public void verifyUnexpectedCallsTest() {
        IMethods mock = mock(IMethods.class);
        replay(mock);

        try {
            mock.simpleMethod();
        } catch(AssertionError e) {
            // eat the exception and so prevent the test from failing
        }

        // the verify should notice an assertion failed earlier
        try {
            verifyUnexpectedCalls(mock);
            fail("Should find unexpected calls");
        } catch(AssertionError e) {
            assertEquals("\n  Unexpected method calls:" +
                    "\n    IMethods.simpleMethod()", e.getMessage());
        }
    }
}