How to use method of org.jmock.test.acceptance.DefineExpectationWithinExpectationsAcceptanceTests class

1package org.jmock.test.acceptance;
2
3import junit.framework.TestCase;
4
5import org.jmock.Expectations;
6import org.jmock.Mockery;
7
8// See issue JMOCK-184
9public class DefineExpectationWithinExpectationsAcceptanceTests extends TestCase {
10    public interface MockedTypeA {
11        void a(MockedTypeB b);
12    }
13    
14    public interface MockedTypeB {
15        void b();
16    }
17    
18    
19    Mockery context = new Mockery();
20    
21    MockedTypeA a = context.mock(MockedTypeA.class, "a");
22    
23    public void testCanDefineExpectationsWithinExpectations() {
24        context.checking(new Expectations() {{
25            oneOf (a).a(aNewMockWithExpectations());
26        }});
27    }
28    
29    private MockedTypeB aNewMockWithExpectations() {
30        final MockedTypeB mock = context.mock(MockedTypeB.class);
31        
32        context.checking(new Expectations() {{
33            ignoring (mock);
34        }});
35            
36        return mock;
37    }
38    
39    public void testCanStillIgnoreEntireMockObjectsBeforeAnotherExpectation() {
40        final MockedTypeA a2 = context.mock(MockedTypeA.class, "a2");
41        
42        context.checking(new Expectations() {{
43            ignoring(a2);
44            oneOf (a).a(aNewMockWithExpectations());
45        }});
46    }
47}
48

Source: DefineExpectationWithinExpectationsAcceptanceTests.java

package org.jmock.test.acceptance;

import junit.framework.TestCase;

import org.jmock.Expectations;
import org.jmock.Mockery;

// See issue JMOCK-184
public class DefineExpectationWithinExpectationsAcceptanceTests extends TestCase {
    public interface MockedTypeA {
        void a(MockedTypeB b);
    }
    
    public interface MockedTypeB {
        void b();
    }
    
    
    Mockery context = new Mockery();
    
    MockedTypeA a = context.mock(MockedTypeA.class, "a");
    
    public void testCanDefineExpectationsWithinExpectations() {
        context.checking(new Expectations() {{
            oneOf (a).a(aNewMockWithExpectations());
        }});
    }
    
    private MockedTypeB aNewMockWithExpectations() {
        final MockedTypeB mock = context.mock(MockedTypeB.class);
        
        context.checking(new Expectations() {{
            ignoring (mock);
        }});
            
        return mock;
    }
    
    public void testCanStillIgnoreEntireMockObjectsBeforeAnotherExpectation() {
        final MockedTypeA a2 = context.mock(MockedTypeA.class, "a2");
        
        context.checking(new Expectations() {{
            ignoring(a2);
            oneOf (a).a(aNewMockWithExpectations());
        }});
    }
}