How to use method of org.jmock.internal.SingleThreadedPolicy class

1package org.jmock.internal;
2
3import java.util.ConcurrentModificationException;
4
5import org.jmock.api.Invocation;
6import org.jmock.api.InvocationDispatcher;
7import org.jmock.api.Invokable;
8import org.jmock.api.ThreadingPolicy;
9import org.jmock.lib.concurrent.Synchroniser;
10import org.jmock.lib.concurrent.UnsynchronisedInvocationDispatcher;
11
12public class SingleThreadedPolicy implements ThreadingPolicy {
13    private final Thread testThread;
14    
15    public SingleThreadedPolicy() {
16        this.testThread = Thread.currentThread();
17    }
18
19    public Invokable synchroniseAccessTo(final Invokable mockObject) {
20        return new Invokable() {
21            public Object invoke(Invocation invocation) throws Throwable {
22                checkRunningOnTestThread();
23                return mockObject.invoke(invocation);
24            }
25        };
26    }
27    
28    private void checkRunningOnTestThread() {
29        if (Thread.currentThread() != testThread) {
30            reportError("the Mockery is not thread-safe: use a " + 
31                        Synchroniser.class.getSimpleName() + " to ensure thread safety");
32        }
33    }
34    
35    private void reportError(String error) {
36        System.err.println(error);
37        throw new ConcurrentModificationException(error);
38    }
39
40    public InvocationDispatcher dispatcher() {
41        return new UnsynchronisedInvocationDispatcher();
42    }
43}
44

Source: SingleThreadedPolicy.java

package org.jmock.internal;

import java.util.ConcurrentModificationException;

import org.jmock.api.Invocation;
import org.jmock.api.InvocationDispatcher;
import org.jmock.api.Invokable;
import org.jmock.api.ThreadingPolicy;
import org.jmock.lib.concurrent.Synchroniser;
import org.jmock.lib.concurrent.UnsynchronisedInvocationDispatcher;

public class SingleThreadedPolicy implements ThreadingPolicy {
    private final Thread testThread;
    
    public SingleThreadedPolicy() {
        this.testThread = Thread.currentThread();
    }

    public Invokable synchroniseAccessTo(final Invokable mockObject) {
        return new Invokable() {
            public Object invoke(Invocation invocation) throws Throwable {
                checkRunningOnTestThread();
                return mockObject.invoke(invocation);
            }
        };
    }
    
    private void checkRunningOnTestThread() {
        if (Thread.currentThread() != testThread) {
            reportError("the Mockery is not thread-safe: use a " + 
                        Synchroniser.class.getSimpleName() + " to ensure thread safety");
        }
    }
    
    private void reportError(String error) {
        System.err.println(error);
        throw new ConcurrentModificationException(error);
    }

    public InvocationDispatcher dispatcher() {
        return new UnsynchronisedInvocationDispatcher();
    }
}