How to use method of org.easymock.tests2.CallbackTest 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 org.junit.runner.RunWith;
8import org.junit.runners.Suite;
9import org.junit.runners.Suite.SuiteClasses;
10
11@RunWith(Suite.class)
12@SuiteClasses(value = { ArgumentsMatcherTest.class, ArrayMatcherTest.class, DefaultMatcherTest.class,
13        EqualsMatcherTest.class, ExpectedMethodCallTest.class, LegacyBehaviorTests.class, MatchableArgumentsTest.class,
14        InvocationTest.class, MockNameTest.class, NiceMockControlTest.class,
15        NiceMockControlLongCompatibleReturnValueTest.class, ObjectMethodsTest.class,
16        RecordStateInvalidDefaultReturnValueTest.class, RecordStateInvalidDefaultThrowableTest.class,
17        RecordStateInvalidMatcherTest.class, RecordStateInvalidRangeTest.class,
18        RecordStateInvalidReturnValueTest.class, RecordStateInvalidStateChangeTest.class,
19        RecordStateInvalidThrowableTest.class, RecordStateInvalidUsageTest.class,
20        RecordStateMethodCallMissingTest.class, ReplayStateInvalidCallsTest.class, ReplayStateInvalidUsageTest.class,
21        StacktraceTest.class, UsageCallCountTest.class, UsageDefaultReturnValueTest.class,
22        UsageExpectAndDefaultReturnTest.class, UsageExpectAndDefaultThrowTest.class, UsageExpectAndReturnTest.class,
23        UsageExpectAndThrowTest.class, UsageFloatingPointReturnValueTest.class,
24        UsageLongCompatibleReturnValueTest.class, UsageOverloadedDefaultValueTest.class,
25        UsageOverloadedMethodTest.class, UsageUnorderedTest.class, UsageRangeTest.class, UsageStrictMockTest.class,
26        UsageTest.class, UsageThrowableTest.class, UsageVarargTest.class, UsageVerifyTest.class,
27        org.easymock.tests2.UsageStrictMockTest.class, org.easymock.tests2.UsageTest.class,
28        org.easymock.tests2.StubTest.class, org.easymock.tests2.UsageMatchersTest.class,
29        org.easymock.tests2.NiceMockTest.class, org.easymock.tests2.ConstraintsToStringTest.class,
30        org.easymock.tests2.CallbackTest.class, org.easymock.tests2.CallbackAndArgumentsTest.class,
31        org.easymock.tests2.UsageConstraintsTest.class, org.easymock.tests2.AnswerTest.class,
32        org.easymock.tests2.NameTest.class, org.easymock.tests2.CompareToTest.class })
33public class AllTests {
34}
35

Source: AllTests.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 org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses(value = { ArgumentsMatcherTest.class, ArrayMatcherTest.class, DefaultMatcherTest.class,
        EqualsMatcherTest.class, ExpectedMethodCallTest.class, LegacyBehaviorTests.class, MatchableArgumentsTest.class,
        InvocationTest.class, MockNameTest.class, NiceMockControlTest.class,
        NiceMockControlLongCompatibleReturnValueTest.class, ObjectMethodsTest.class,
        RecordStateInvalidDefaultReturnValueTest.class, RecordStateInvalidDefaultThrowableTest.class,
        RecordStateInvalidMatcherTest.class, RecordStateInvalidRangeTest.class,
        RecordStateInvalidReturnValueTest.class, RecordStateInvalidStateChangeTest.class,
        RecordStateInvalidThrowableTest.class, RecordStateInvalidUsageTest.class,
        RecordStateMethodCallMissingTest.class, ReplayStateInvalidCallsTest.class, ReplayStateInvalidUsageTest.class,
        StacktraceTest.class, UsageCallCountTest.class, UsageDefaultReturnValueTest.class,
        UsageExpectAndDefaultReturnTest.class, UsageExpectAndDefaultThrowTest.class, UsageExpectAndReturnTest.class,
        UsageExpectAndThrowTest.class, UsageFloatingPointReturnValueTest.class,
        UsageLongCompatibleReturnValueTest.class, UsageOverloadedDefaultValueTest.class,
        UsageOverloadedMethodTest.class, UsageUnorderedTest.class, UsageRangeTest.class, UsageStrictMockTest.class,
        UsageTest.class, UsageThrowableTest.class, UsageVarargTest.class, UsageVerifyTest.class,
        org.easymock.tests2.UsageStrictMockTest.class, org.easymock.tests2.UsageTest.class,
        org.easymock.tests2.StubTest.class, org.easymock.tests2.UsageMatchersTest.class,
        org.easymock.tests2.NiceMockTest.class, org.easymock.tests2.ConstraintsToStringTest.class,
        org.easymock.tests2.CallbackTest.class, org.easymock.tests2.CallbackAndArgumentsTest.class,
        org.easymock.tests2.UsageConstraintsTest.class, org.easymock.tests2.AnswerTest.class,
        org.easymock.tests2.NameTest.class, org.easymock.tests2.CompareToTest.class })
public class AllTests {
}

1package org.easymock.tests2;
2
3import junit.framework.Test;
4import junit.framework.TestSuite;
5
6public class EasyMockTests2 {
7
8    public static Test suite() {
9        TestSuite suite = new TestSuite("Test for org.easymock.tests2");
10        //$JUnit-BEGIN$
11        suite.addTestSuite(NiceMockTest.class);
12        suite.addTestSuite(NameTest.class);
13        suite.addTestSuite(ConstraintsToStringTest.class);
14        suite.addTestSuite(AnswerTest.class);
15        suite.addTestSuite(CallbackAndArgumentsTest.class);
16        suite.addTestSuite(StubTest.class);
17        suite.addTestSuite(CompareToTest.class);
18        suite.addTestSuite(UsageStrictMockTest.class);
19        suite.addTestSuite(UsageConstraintsTest.class);
20        suite.addTestSuite(UsageTest.class);
21        suite.addTestSuite(UsageMatchersTest.class);
22        suite.addTestSuite(CallbackTest.class);
23        //$JUnit-END$
24        return suite;
25    }
26
27}
28

Source: EasyMockTests2.java

package org.easymock.tests2;

import junit.framework.Test;
import junit.framework.TestSuite;

public class EasyMockTests2 {

    public static Test suite() {
        TestSuite suite = new TestSuite("Test for org.easymock.tests2");
        //$JUnit-BEGIN$
        suite.addTestSuite(NiceMockTest.class);
        suite.addTestSuite(NameTest.class);
        suite.addTestSuite(ConstraintsToStringTest.class);
        suite.addTestSuite(AnswerTest.class);
        suite.addTestSuite(CallbackAndArgumentsTest.class);
        suite.addTestSuite(StubTest.class);
        suite.addTestSuite(CompareToTest.class);
        suite.addTestSuite(UsageStrictMockTest.class);
        suite.addTestSuite(UsageConstraintsTest.class);
        suite.addTestSuite(UsageTest.class);
        suite.addTestSuite(UsageMatchersTest.class);
        suite.addTestSuite(CallbackTest.class);
        //$JUnit-END$
        return suite;
    }

}

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.tests2;
6
7import static org.easymock.EasyMock.*;
8import static org.junit.Assert.*;
9
10import org.easymock.IAnswer;
11import org.easymock.tests.IMethods;
12import org.junit.Before;
13import org.junit.Test;
14
15public class CallbackTest {
16
17    private IMethods mock;
18
19    private static class Callback<T> implements IAnswer<T> {
20        private int callCount;
21
22        private T result;
23
24        public Callback(T result) {
25            this.result = result;
26        }
27
28        public void run() {
29        }
30
31        public int getCallCount() {
32            return callCount;
33        }
34
35        public T answer() throws Throwable {
36            callCount++;
37            return result;
38        }
39    }
40
41    @Before
42    public void setUp() {
43        mock = createStrictMock(IMethods.class);
44    }
45
46    @Test
47    public void callback() {
48        Callback<String> c1 = new Callback<String>("1");
49        Callback<Object> c2 = new Callback<Object>(null);
50        Callback<Object> c3 = new Callback<Object>(null);
51
52        expect(mock.oneArg("2")).andAnswer(c1).times(2);
53        mock.simpleMethodWithArgument("One");
54        expectLastCall().andAnswer(c2);
55        mock.simpleMethodWithArgument("Two");
56        expectLastCall().andAnswer(c3).times(2);
57
58        replay(mock);
59
60        mock.oneArg("2");
61        mock.oneArg("2");
62        try {
63            mock.oneArg("2");
64        } catch (AssertionError ignored) {
65        }
66        try {
67            mock.simpleMethodWithArgument("Two");
68        } catch (AssertionError ignored) {
69        }
70        mock.simpleMethodWithArgument("One");
71        try {
72            mock.simpleMethodWithArgument("One");
73        } catch (AssertionError ignored) {
74        }
75        mock.simpleMethodWithArgument("Two");
76        mock.simpleMethodWithArgument("Two");
77        try {
78            mock.simpleMethodWithArgument("Two");
79        } catch (AssertionError ignored) {
80        }
81        verify(mock);
82
83        assertEquals(2, c1.getCallCount());
84        assertEquals(1, c2.getCallCount());
85        assertEquals(2, c3.getCallCount());
86    }
87}
88

Source: CallbackTest.java

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

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

import org.easymock.IAnswer;
import org.easymock.tests.IMethods;
import org.junit.Before;
import org.junit.Test;

public class CallbackTest {

    private IMethods mock;

    private static class Callback<T> implements IAnswer<T> {
        private int callCount;

        private T result;

        public Callback(T result) {
            this.result = result;
        }

        public void run() {
        }

        public int getCallCount() {
            return callCount;
        }

        public T answer() throws Throwable {
            callCount++;
            return result;
        }
    }

    @Before
    public void setUp() {
        mock = createStrictMock(IMethods.class);
    }

    @Test
    public void callback() {
        Callback<String> c1 = new Callback<String>("1");
        Callback<Object> c2 = new Callback<Object>(null);
        Callback<Object> c3 = new Callback<Object>(null);

        expect(mock.oneArg("2")).andAnswer(c1).times(2);
        mock.simpleMethodWithArgument("One");
        expectLastCall().andAnswer(c2);
        mock.simpleMethodWithArgument("Two");
        expectLastCall().andAnswer(c3).times(2);

        replay(mock);

        mock.oneArg("2");
        mock.oneArg("2");
        try {
            mock.oneArg("2");
        } catch (AssertionError ignored) {
        }
        try {
            mock.simpleMethodWithArgument("Two");
        } catch (AssertionError ignored) {
        }
        mock.simpleMethodWithArgument("One");
        try {
            mock.simpleMethodWithArgument("One");
        } catch (AssertionError ignored) {
        }
        mock.simpleMethodWithArgument("Two");
        mock.simpleMethodWithArgument("Two");
        try {
            mock.simpleMethodWithArgument("Two");
        } catch (AssertionError ignored) {
        }
        verify(mock);

        assertEquals(2, c1.getCallCount());
        assertEquals(1, c2.getCallCount());
        assertEquals(2, c3.getCallCount());
    }
}