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

1/*
2 * Copyright (c) 2001-2007 OFFIS, Tammo Freese.
3 * This program is made available under the terms of the MIT License.
4 */
5package org.easymock.tests;
6
7import static org.easymock.EasyMock.*;
8import static org.junit.Assert.*;
9
10import org.easymock.MockControl;
11import org.junit.Before;
12import org.junit.Test;
13
14/**
15 * Same as UsageExpectAndThrowTest except that each mocked method is called twice to make sure the defaulting works
16 * fine.
17 * 
18 * @author Henri Tremblay
19 */
20public class UsageExpectAndDefaultThrowTest {
21    private MockControl<IMethods> control;
22
23    private IMethods mock;
24
25    private static RuntimeException EXCEPTION = new RuntimeException();
26
27    @Before
28    public void setup() {
29        control = MockControl.createControl(IMethods.class);
30        mock = control.getMock();
31    }
32
33    @Test
34    public void booleanType() {
35        control.expectAndDefaultThrow(mock.booleanReturningMethod(4), EXCEPTION);
36        control.replay();
37        try {
38            mock.booleanReturningMethod(4);
39            fail();
40        } catch (RuntimeException exception) {
41            assertSame(EXCEPTION, exception);
42        }
43        try {
44            mock.booleanReturningMethod(4);
45            fail();
46        } catch (RuntimeException exception) {
47            assertSame(EXCEPTION, exception);
48        }
49        control.verify();
50    }
51
52    @Test
53    public void longType() {
54        control.expectAndDefaultThrow(mock.longReturningMethod(4), EXCEPTION);
55        control.replay();
56        try {
57            mock.longReturningMethod(4);
58            fail();
59        } catch (RuntimeException exception) {
60            assertSame(EXCEPTION, exception);
61        }
62        try {
63            mock.longReturningMethod(4);
64            fail();
65        } catch (RuntimeException exception) {
66            assertSame(EXCEPTION, exception);
67        }
68        control.verify();
69    }
70
71    @Test
72    public void floatType() {
73        control.expectAndDefaultThrow(mock.floatReturningMethod(4), EXCEPTION);
74        control.replay();
75        try {
76            mock.floatReturningMethod(4);
77            fail();
78        } catch (RuntimeException exception) {
79            assertSame(EXCEPTION, exception);
80        }
81        try {
82            mock.floatReturningMethod(4);
83            fail();
84        } catch (RuntimeException exception) {
85            assertSame(EXCEPTION, exception);
86        }
87        control.verify();
88    }
89
90    @Test
91    public void doubleType() {
92        control.expectAndDefaultThrow(mock.doubleReturningMethod(4), EXCEPTION);
93        control.replay();
94        try {
95            mock.doubleReturningMethod(4);
96            fail();
97        } catch (RuntimeException exception) {
98            assertSame(EXCEPTION, exception);
99        }
100        try {
101            mock.doubleReturningMethod(4);
102            fail();
103        } catch (RuntimeException exception) {
104            assertSame(EXCEPTION, exception);
105        }
106        control.verify();
107    }
108
109    @Test
110    public void object() {
111        control.expectAndDefaultThrow(mock.objectReturningMethod(4), EXCEPTION);
112        control.replay();
113        try {
114            mock.objectReturningMethod(4);
115            fail();
116        } catch (RuntimeException exception) {
117            assertSame(EXCEPTION, exception);
118        }
119        try {
120            mock.objectReturningMethod(4);
121            fail();
122        } catch (RuntimeException exception) {
123            assertSame(EXCEPTION, exception);
124        }
125        control.verify();
126    }
127
128    @Test
129    public void throwableAndDefaultThrowable() throws Exception {
130
131        mock.oneArg("1");
132
133        expectLastCall().andThrow(new IllegalArgumentException());
134        control.setDefaultThrowable(new IllegalStateException());
135
136        control.replay();
137
138        try {
139            mock.oneArg("1");
140        } catch (IllegalArgumentException ignored) {
141        }
142        try {
143            mock.oneArg("1");
144        } catch (IllegalStateException ignored) {
145        }
146        try {
147            mock.oneArg("2");
148        } catch (IllegalStateException ignored) {
149        }
150        control.verify();
151    }
152
153}
154

Source: UsageExpectAndDefaultThrowTest.java

/*
 * Copyright (c) 2001-2007 OFFIS, Tammo Freese.
 * This program is made available under the terms of the MIT License.
 */
package org.easymock.tests;

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

import org.easymock.MockControl;
import org.junit.Before;
import org.junit.Test;

/**
 * Same as UsageExpectAndThrowTest except that each mocked method is called twice to make sure the defaulting works
 * fine.
 * 
 * @author Henri Tremblay
 */
public class UsageExpectAndDefaultThrowTest {
    private MockControl<IMethods> control;

    private IMethods mock;

    private static RuntimeException EXCEPTION = new RuntimeException();

    @Before
    public void setup() {
        control = MockControl.createControl(IMethods.class);
        mock = control.getMock();
    }

    @Test
    public void booleanType() {
        control.expectAndDefaultThrow(mock.booleanReturningMethod(4), EXCEPTION);
        control.replay();
        try {
            mock.booleanReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        try {
            mock.booleanReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        control.verify();
    }

    @Test
    public void longType() {
        control.expectAndDefaultThrow(mock.longReturningMethod(4), EXCEPTION);
        control.replay();
        try {
            mock.longReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        try {
            mock.longReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        control.verify();
    }

    @Test
    public void floatType() {
        control.expectAndDefaultThrow(mock.floatReturningMethod(4), EXCEPTION);
        control.replay();
        try {
            mock.floatReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        try {
            mock.floatReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        control.verify();
    }

    @Test
    public void doubleType() {
        control.expectAndDefaultThrow(mock.doubleReturningMethod(4), EXCEPTION);
        control.replay();
        try {
            mock.doubleReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        try {
            mock.doubleReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        control.verify();
    }

    @Test
    public void object() {
        control.expectAndDefaultThrow(mock.objectReturningMethod(4), EXCEPTION);
        control.replay();
        try {
            mock.objectReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        try {
            mock.objectReturningMethod(4);
            fail();
        } catch (RuntimeException exception) {
            assertSame(EXCEPTION, exception);
        }
        control.verify();
    }

    @Test
    public void throwableAndDefaultThrowable() throws Exception {

        mock.oneArg("1");

        expectLastCall().andThrow(new IllegalArgumentException());
        control.setDefaultThrowable(new IllegalStateException());

        control.replay();

        try {
            mock.oneArg("1");
        } catch (IllegalArgumentException ignored) {
        }
        try {
            mock.oneArg("1");
        } catch (IllegalStateException ignored) {
        }
        try {
            mock.oneArg("2");
        } catch (IllegalStateException ignored) {
        }
        control.verify();
    }

}