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

1package org.jmock.test.acceptance;
2
3import org.jmock.Expectations;
4import org.jmock.auto.Mock;
5import org.jmock.imposters.ByteBuddyClassImposteriser;
6import org.jmock.integration.junit4.JUnitRuleMockery;
7import org.jmock.testjar.InterfaceFromOtherClassLoader;
8import org.junit.Rule;
9import org.junit.Test;
10import org.junit.jupiter.api.Disabled;
11
12/**
13 * This tests the solution to a longstanding jMock issue. Mock return values for
14 * generic interfaces loaded by other class loaders had the type constraint of
15 * the source interface not the runtime type. The ByteBuddyClassImposteriser
16 * oxposed this issue as it cast mocked method return values to their target
17 * type. This caused ClassCastExceptions. Returning null in the cases where
18 * we're building expectations is the simple solution. Once will(returnValue())
19 * has bee called then the actual mock reply is known and can be returned at
20 * expectation assertion time.
21 * 
22 * @author oliverbye
23 *
24 */
25public class MockingGenericsFromOtherClassLoadersAcceptanceTests {
26
27    @Rule
28    public final JUnitRuleMockery context = new JUnitRuleMockery() {
29        {
30            setImposteriser(ByteBuddyClassImposteriser.INSTANCE);
31        }
32    };
33
34    /**
35     * This test case requires a generic mock.
36     */
37    @Mock
38    public InterfaceFromOtherClassLoader<ABean> mock;
39
40    @SuppressWarnings("unused")
41    @Test
42    public void testWhenDefinedAndInvokedThroughClass() throws Exception {
43
44        context.checking(new Expectations() {
45            {
46                // Assigning the mock is not normal
47                // We do this to prove that the result is assignable to the generic interfaces
48                // runtime type (ABean)
49                ABean bean = oneOf(mock).stir(ABEAN);
50                will(returnValue(ABEAN));
51            }
52        });
53
54        ABean result1 = mock.stir(ABEAN);
55    }
56
57    @SuppressWarnings("unused")
58    @Test
59    public void testWhenDefinedThroughClassAndInvokedThroughMethod() throws Exception {
60
61        context.checking(new Expectations() {
62            {
63                ABean bean = oneOf(mock).stir(ABEAN);
64                will(returnValue(ABEAN));
65            }
66        });
67
68        // Note: this is invoked through a "bridge" method and so the method
69        // invoked when expectations are checked appears to be different from
70        // that invoked when expectations are captured.
71        ABean result1 = ((InterfaceFromOtherClassLoader<ABean>) mock).stir(ABEAN);
72    }
73
74    @Disabled
75    public void DONTtestAndBoxedNativeParameterIgnoingIsADocumentationWhenDefinedThroughClassAndInvokedThroughMethod()
76            throws Exception {
77
78        context.checking(new Expectations() {
79            {
80                oneOf(mock).stir(with(any(Integer.class)));
81                will(returnValue(ABEAN));
82            }
83        });
84
85        // Note: this is invoked through a "bridge" method and so the method
86        // invoked when expectations are checked appears to be different from
87        // that invoked when expectations are captured.
88        ((InterfaceFromOtherClassLoader<ABean>) mock).stir(ABEAN);
89    }
90
91    @SuppressWarnings("unused")
92    @Test
93    public void testWhenDefinedAndInvokedThroughInterface() throws Exception {
94
95        context.checking(new Expectations() {
96            {
97                ABean bean = oneOf(mock).stir(ABEAN);
98                will(returnValue(ABEAN));
99            }
100        });
101
102        ABean result1 = mock.stir(ABEAN);
103    }
104
105    public static abstract class ABean {
106    }
107
108    public ABean ABEAN = new ABean() {
109    };
110}
111

Source: MockingGenericsFromOtherClassLoadersAcceptanceTests.java

package org.jmock.test.acceptance;

import org.jmock.Expectations;
import org.jmock.auto.Mock;
import org.jmock.imposters.ByteBuddyClassImposteriser;
import org.jmock.integration.junit4.JUnitRuleMockery;
import org.jmock.testjar.InterfaceFromOtherClassLoader;
import org.junit.Rule;
import org.junit.Test;
import org.junit.jupiter.api.Disabled;

/**
 * This tests the solution to a longstanding jMock issue. Mock return values for
 * generic interfaces loaded by other class loaders had the type constraint of
 * the source interface not the runtime type. The ByteBuddyClassImposteriser
 * oxposed this issue as it cast mocked method return values to their target
 * type. This caused ClassCastExceptions. Returning null in the cases where
 * we're building expectations is the simple solution. Once will(returnValue())
 * has bee called then the actual mock reply is known and can be returned at
 * expectation assertion time.
 * 
 * @author oliverbye
 *
 */
public class MockingGenericsFromOtherClassLoadersAcceptanceTests {

    @Rule
    public final JUnitRuleMockery context = new JUnitRuleMockery() {
        {
            setImposteriser(ByteBuddyClassImposteriser.INSTANCE);
        }
    };

    /**
     * This test case requires a generic mock.
     */
    @Mock
    public InterfaceFromOtherClassLoader<ABean> mock;

    @SuppressWarnings("unused")
    @Test
    public void testWhenDefinedAndInvokedThroughClass() throws Exception {

        context.checking(new Expectations() {
            {
                // Assigning the mock is not normal
                // We do this to prove that the result is assignable to the generic interfaces
                // runtime type (ABean)
                ABean bean = oneOf(mock).stir(ABEAN);
                will(returnValue(ABEAN));
            }
        });

        ABean result1 = mock.stir(ABEAN);
    }

    @SuppressWarnings("unused")
    @Test
    public void testWhenDefinedThroughClassAndInvokedThroughMethod() throws Exception {

        context.checking(new Expectations() {
            {
                ABean bean = oneOf(mock).stir(ABEAN);
                will(returnValue(ABEAN));
            }
        });

        // Note: this is invoked through a "bridge" method and so the method
        // invoked when expectations are checked appears to be different from
        // that invoked when expectations are captured.
        ABean result1 = ((InterfaceFromOtherClassLoader<ABean>) mock).stir(ABEAN);
    }

    @Disabled
    public void DONTtestAndBoxedNativeParameterIgnoingIsADocumentationWhenDefinedThroughClassAndInvokedThroughMethod()
            throws Exception {

        context.checking(new Expectations() {
            {
                oneOf(mock).stir(with(any(Integer.class)));
                will(returnValue(ABEAN));
            }
        });

        // Note: this is invoked through a "bridge" method and so the method
        // invoked when expectations are checked appears to be different from
        // that invoked when expectations are captured.
        ((InterfaceFromOtherClassLoader<ABean>) mock).stir(ABEAN);
    }

    @SuppressWarnings("unused")
    @Test
    public void testWhenDefinedAndInvokedThroughInterface() throws Exception {

        context.checking(new Expectations() {
            {
                ABean bean = oneOf(mock).stir(ABEAN);
                will(returnValue(ABEAN));
            }
        });

        ABean result1 = mock.stir(ABEAN);
    }

    public static abstract class ABean {
    }

    public ABean ABEAN = new ABean() {
    };
}