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

1package org.jmock.test.acceptance;
2
3import static org.hamcrest.Matchers.equalTo;
4import static org.junit.Assert.assertThat;
5
6import java.lang.Thread.UncaughtExceptionHandler;
7import java.util.ArrayList;
8import java.util.Collections;
9import java.util.List;
10import java.util.concurrent.Executors;
11import java.util.concurrent.ThreadFactory;
12
13import junit.framework.TestCase;
14
15import org.jmock.Expectations;
16import org.jmock.Mockery;
17import org.jmock.lib.concurrent.Blitzer;
18
19public class WarnAboutMultipleThreadsAcceptanceTests extends TestCase {
20    List<Throwable> exceptionsOnBackgroundThreads = Collections.synchronizedList(new ArrayList<Throwable>());
21    
22    Blitzer blitzer = new Blitzer(1, Executors.newFixedThreadPool(1, new ThreadFactory() {
23        public Thread newThread(Runnable r) {
24            Thread t = new Thread(r);
25            t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
26                public void uncaughtException(Thread t, Throwable e) {
27                    exceptionsOnBackgroundThreads.add(e);
28                }
29            });
30            return t;
31        }
32    }));
33    
34    public void testKillsThreadsThatTryToCallMockeryThatIsNotThreadSafe() throws InterruptedException {
35        Mockery mockery = new Mockery();
36        
37        final MockedType mock = mockery.mock(MockedType.class, "mock");
38        
39        mockery.checking(new Expectations() {{
40            allowing (mock).doSomething();
41        }});
42        
43        blitzer.blitz(new Runnable() {
44            public void run() {
45                mock.doSomething();
46            }            
47        });
48        
49        assertThat(exceptionsOnBackgroundThreads.size(), equalTo(blitzer.totalActionCount()));
50    }
51    
52    @Override
53    public void tearDown() {
54        blitzer.shutdown();
55    }
56}
57

Source: WarnAboutMultipleThreadsAcceptanceTests.java

package org.jmock.test.acceptance;

import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;

import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

import junit.framework.TestCase;

import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.lib.concurrent.Blitzer;

public class WarnAboutMultipleThreadsAcceptanceTests extends TestCase {
    List<Throwable> exceptionsOnBackgroundThreads = Collections.synchronizedList(new ArrayList<Throwable>());
    
    Blitzer blitzer = new Blitzer(1, Executors.newFixedThreadPool(1, new ThreadFactory() {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
                public void uncaughtException(Thread t, Throwable e) {
                    exceptionsOnBackgroundThreads.add(e);
                }
            });
            return t;
        }
    }));
    
    public void testKillsThreadsThatTryToCallMockeryThatIsNotThreadSafe() throws InterruptedException {
        Mockery mockery = new Mockery();
        
        final MockedType mock = mockery.mock(MockedType.class, "mock");
        
        mockery.checking(new Expectations() {{
            allowing (mock).doSomething();
        }});
        
        blitzer.blitz(new Runnable() {
            public void run() {
                mock.doSomething();
            }            
        });
        
        assertThat(exceptionsOnBackgroundThreads.size(), equalTo(blitzer.totalActionCount()));
    }
    
    @Override
    public void tearDown() {
        blitzer.shutdown();
    }
}