Backups/TwelveMonkeys
2
0
Fork 0
mirror of https://github.com/haraldk/TwelveMonkeys.git synced 2025-10-04 11:26:44 -04:00
Code Issues Projects Releases Wiki Activity

Major test-case cleanup.

Browse Source 
- Removed JMock dependency, tests rewritten to use Mockito for stub/mock
- All test should now be using JUnit annotation-style tests
- All modules should now depend on same JUnit version
- Rewrote a few tests to better utilize JUnit annotations
- Fixed a few broken tests
- Code style changes
This commit is contained in:
Harald Kuhr
2011-12-19 14:28:34 +01:00
parent 52a97cfb2f
commit 0c4fc454b9
26 changed files with 1539 additions and 1526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageReaderAbstractTestCase.java
View File

@@ -29,12 +29,11 @@
package com.twelvemonkeys.imageio.util;
import com.twelvemonkeys.imageio.stream.URLImageInputStreamSpi;
import org.jmock.Mock;
import org.jmock.cglib.MockObjectTestCase;
import org.jmock.core.Invocation;
import org.jmock.core.Stub;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import javax.imageio.*;
import javax.imageio.event.IIOReadProgressListener;
@@ -55,6 +54,9 @@ import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
/**
* ImageReaderAbstractTestCase
*
@@ -62,7 +64,7 @@ import java.util.List;
* @author last modified by $Author: haraldk$
* @version $Id: ImageReaderAbstractTestCase.java,v 1.0 Apr 1, 2008 10:36:46 PM haraldk Exp$
*/
public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends MockObjectTestCase {
public abstract class ImageReaderAbstractTestCase<T extends ImageReader> {
// TODO: Should we really test if he provider is installed?
// - Pro: Tests the META-INF/services config
// - Con: Not all providers should be installed at runtime...
@@ -948,8 +950,7 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
@Test
public void testAddIIOReadProgressListener() {
ImageReader reader = createReader();
Mock mockListener = new Mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListener.proxy());
reader.addIIOReadProgressListener(mock(IIOReadProgressListener.class));
}
@Test
@@ -964,13 +965,8 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
TestData data = getTestData().get(0);
reader.setInput(data.getInputStream());
Mock mockListener = new Mock(IIOReadProgressListener.class);
String started = "Started";
mockListener.expects(once()).method("imageStarted").withAnyArguments().id(started);
mockListener.stubs().method("imageProgress").withAnyArguments().after(started);
mockListener.expects(once()).method("imageComplete").withAnyArguments().after(started);
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListener.proxy());
IIOReadProgressListener listener = mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener(listener);
try {
reader.read(0);
@@ -980,7 +976,10 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
}
// At least imageStarted and imageComplete, plus any number of imageProgress
mockListener.verify();
InOrder ordered = inOrder(listener);
ordered.verify(listener).imageStarted(reader, 0);
ordered.verify(listener, atLeastOnce()).imageProgress(eq(reader), anyInt());
ordered.verify(listener).imageComplete(reader);
}
@Test
@@ -989,28 +988,13 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
TestData data = getTestData().get(0);
reader.setInput(data.getInputStream());
Mock mockListener = new Mock(IIOReadProgressListener.class);
String started = "Started";
mockListener.expects(once()).method("imageStarted").withAnyArguments().id(started);
mockListener.stubs().method("imageProgress").withAnyArguments().after(started);
mockListener.expects(once()).method("imageComplete").withAnyArguments().after(started);
IIOReadProgressListener listener = mock(IIOReadProgressListener.class);
IIOReadProgressListener listenerToo = mock(IIOReadProgressListener.class);
IIOReadProgressListener listenerThree = mock(IIOReadProgressListener.class);
Mock mockListenerToo = new Mock(IIOReadProgressListener.class);
String startedToo = "Started Two";
mockListenerToo.expects(once()).method("imageStarted").withAnyArguments().id(startedToo);
mockListenerToo.stubs().method("imageProgress").withAnyArguments().after(startedToo);
mockListenerToo.expects(once()).method("imageComplete").withAnyArguments().after(startedToo);
Mock mockListenerThree = new Mock(IIOReadProgressListener.class);
String startedThree = "Started Three";
mockListenerThree.expects(once()).method("imageStarted").withAnyArguments().id(startedThree);
mockListenerThree.stubs().method("imageProgress").withAnyArguments().after(startedThree);
mockListenerThree.expects(once()).method("imageComplete").withAnyArguments().after(startedThree);
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListener.proxy());
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListenerToo.proxy());
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListenerThree.proxy());
reader.addIIOReadProgressListener(listener);
reader.addIIOReadProgressListener(listenerToo);
reader.addIIOReadProgressListener(listenerThree);
try {
reader.read(0);
@@ -1020,9 +1004,19 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
}
// At least imageStarted and imageComplete, plus any number of imageProgress
mockListener.verify();
mockListenerToo.verify();
mockListenerThree.verify();
InOrder ordered = inOrder(listener, listenerToo, listenerThree);
ordered.verify(listener).imageStarted(reader, 0);
ordered.verify(listenerToo).imageStarted(reader, 0);
ordered.verify(listenerThree).imageStarted(reader, 0);
ordered.verify(listener, atLeastOnce()).imageProgress(eq(reader), anyInt());
ordered.verify(listenerToo, atLeastOnce()).imageProgress(eq(reader), anyInt());
ordered.verify(listenerThree, atLeastOnce()).imageProgress(eq(reader), anyInt());
ordered.verify(listener).imageComplete(reader);
ordered.verify(listenerToo).imageComplete(reader);
ordered.verify(listenerThree).imageComplete(reader);
}
@Test
@@ -1034,8 +1028,7 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
@Test
public void testRemoveIIOReadProgressListenerNone() {
ImageReader reader = createReader();
Mock mockListener = new Mock(IIOReadProgressListener.class);
reader.removeIIOReadProgressListener((IIOReadProgressListener) mockListener.proxy());
reader.removeIIOReadProgressListener(mock(IIOReadProgressListener.class));
}
@Test
@@ -1043,8 +1036,8 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
ImageReader reader = createReader();
TestData data = getTestData().get(0);
reader.setInput(data.getInputStream());
Mock mockListener = new Mock(IIOReadProgressListener.class);
IIOReadProgressListener listener = (IIOReadProgressListener) mockListener.proxy();
IIOReadProgressListener listener = mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener(listener);
reader.removeIIOReadProgressListener(listener);
@@ -1056,7 +1049,7 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
}
// Should not have called any methods...
mockListener.verify();
verifyZeroInteractions(listener);
}
@Test
@@ -1065,15 +1058,11 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
TestData data = getTestData().get(0);
reader.setInput(data.getInputStream());
Mock mockListener = new Mock(IIOReadProgressListener.class, "Listener1");
IIOReadProgressListener listener = (IIOReadProgressListener) mockListener.proxy();
IIOReadProgressListener listener = mock(IIOReadProgressListener.class, "Listener1");
reader.addIIOReadProgressListener(listener);
Mock mockListenerToo = new Mock(IIOReadProgressListener.class, "Listener2");
mockListenerToo.expects(once()).method("imageStarted").with(eq(reader), eq(0));
mockListenerToo.stubs().method("imageProgress").withAnyArguments();
mockListenerToo.expects(once()).method("imageComplete").with(eq(reader));
IIOReadProgressListener listenerToo = (IIOReadProgressListener) mockListenerToo.proxy();
IIOReadProgressListener listenerToo = mock(IIOReadProgressListener.class, "Listener2");
reader.addIIOReadProgressListener(listenerToo);
reader.removeIIOReadProgressListener(listener);
@@ -1085,9 +1074,13 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
fail("Could not read image");
}
// Should not have called any methods...
mockListener.verify();
mockListenerToo.verify();
// Should not have called any methods on listener1...
verifyZeroInteractions(listener);
InOrder ordered = inOrder(listenerToo);
ordered.verify(listenerToo).imageStarted(reader, 0);
ordered.verify(listenerToo, atLeastOnce()).imageProgress(eq(reader), anyInt());
ordered.verify(listenerToo).imageComplete(reader);
}
@Test
@@ -1096,8 +1089,8 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
TestData data = getTestData().get(0);
reader.setInput(data.getInputStream());
Mock mockListener = new Mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListener.proxy());
IIOReadProgressListener listener = mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener(listener);
reader.removeAllIIOReadProgressListeners();
@@ -1109,7 +1102,7 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
}
// Should not have called any methods...
mockListener.verify();
verifyZeroInteractions(listener);
}
@Test
@@ -1118,11 +1111,11 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
TestData data = getTestData().get(0);
reader.setInput(data.getInputStream());
Mock mockListener = new Mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListener.proxy());
IIOReadProgressListener listener = mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener(listener);
Mock mockListenerToo = new Mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener((IIOReadProgressListener) mockListenerToo.proxy());
IIOReadProgressListener listenerToo = mock(IIOReadProgressListener.class);
reader.addIIOReadProgressListener(listenerToo);
reader.removeAllIIOReadProgressListeners();
@@ -1134,8 +1127,8 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
}
// Should not have called any methods...
mockListener.verify();
mockListenerToo.verify();
verifyZeroInteractions(listener);
verifyZeroInteractions(listenerToo);
}
@Test
@@ -1144,41 +1137,24 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
TestData data = getTestData().get(0);
reader.setInput(data.getInputStream());
Mock mockListener = new Mock(IIOReadProgressListener.class, "Progress1");
mockListener.stubs().method("imageStarted").withAnyArguments();
mockListener.stubs().method("imageProgress").withAnyArguments();
mockListener.expects(once()).method("readAborted").with(eq(reader));
mockListener.stubs().method("imageComplete").withAnyArguments();
IIOReadProgressListener listener = (IIOReadProgressListener) mockListener.proxy();
IIOReadProgressListener listener = mock(IIOReadProgressListener.class, "Progress1");
reader.addIIOReadProgressListener(listener);
Mock mockListenerToo = new Mock(IIOReadProgressListener.class, "Progress2");
mockListenerToo.stubs().method("imageStarted").withAnyArguments();
mockListenerToo.stubs().method("imageProgress").withAnyArguments();
mockListenerToo.expects(once()).method("readAborted").with(eq(reader));
mockListenerToo.stubs().method("imageComplete").withAnyArguments();
IIOReadProgressListener listenerToo = (IIOReadProgressListener) mockListenerToo.proxy();
IIOReadProgressListener listenerToo = mock(IIOReadProgressListener.class, "Progress2");
reader.addIIOReadProgressListener(listenerToo);
// Create a listener that just makes the reader abort immediately...
Mock abortingListener = new Mock(IIOReadProgressListener.class, "Aborter");
abortingListener.stubs().method("readAborted").withAnyArguments();
abortingListener.stubs().method("imageComplete").withAnyArguments();
Stub abort = new Stub() {
public Object invoke(Invocation pInvocation) throws Throwable {
IIOReadProgressListener abortingListener = mock(IIOReadProgressListener.class, "Aborter");
Answer<Void> abort = new Answer<Void>() {
public Void answer(InvocationOnMock invocation) throws Throwable {
reader.abort();
return null;
}
public StringBuffer describeTo(StringBuffer pStringBuffer) {
pStringBuffer.append("aborting");
return pStringBuffer;
}
};
abortingListener.stubs().method("imageProgress").will(abort);
abortingListener.stubs().method("imageStarted").will(abort);
doAnswer(abort).when(abortingListener).imageStarted(any(ImageReader.class), anyInt());
doAnswer(abort).when(abortingListener).imageProgress(any(ImageReader.class), anyInt());
reader.addIIOReadProgressListener((IIOReadProgressListener) abortingListener.proxy());
reader.addIIOReadProgressListener(abortingListener);
try {
reader.read(0);
@@ -1187,8 +1163,8 @@ public abstract class ImageReaderAbstractTestCase<T extends ImageReader> extends
failBecause("Image could not be read", e);
}
mockListener.verify();
mockListenerToo.verify();
verify(listener).readAborted(reader);
verify(listenerToo).readAborted(reader);
}
@Test

146
imageio/imageio-core/src/test/java/com/twelvemonkeys/imageio/util/ImageWriterAbstractTestCase.java
View File

@@ -28,8 +28,8 @@
package com.twelvemonkeys.imageio.util;
import org.jmock.Mock;
import org.jmock.cglib.MockObjectTestCase;
import org.junit.Test;
import org.mockito.InOrder;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
@@ -39,6 +39,10 @@ import java.awt.image.RenderedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import static org.junit.Assert.*;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.*;
/**
* ImageReaderAbstractTestCase class description.
*
@@ -46,12 +50,13 @@ import java.io.IOException;
* @author last modified by $Author: haku $
* @version $Id: ImageReaderAbstractTestCase.java,v 1.0 18.nov.2004 17:38:33 haku Exp $
*/
public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
public abstract class ImageWriterAbstractTestCase {
protected abstract ImageWriter createImageWriter();
protected abstract RenderedImage getTestData();
@Test
public void testSetOutput() throws IOException {
// Should just pass with no exceptions
ImageWriter writer = createImageWriter();
@@ -59,6 +64,7 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
writer.setOutput(ImageIO.createImageOutputStream(new ByteArrayOutputStream()));
}
@Test
public void testSetOutputNull() {
// Should just pass with no exceptions
ImageWriter writer = createImageWriter();
@@ -66,25 +72,30 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
writer.setOutput(null);
}
@Test
public void testWrite() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
try {
writer.write(getTestData());
}
catch (IOException e) {
fail(e.getMessage());
}
assertTrue("No image data written", buffer.size() > 0);
}
@Test
public void testWrite2() {
// Note: There's a difference between new ImageOutputStreamImpl and
// ImageIO.createImageOutputStream... Make sure writers handle both
// cases
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try {
writer.setOutput(ImageIO.createImageOutputStream(buffer));
writer.write(getTestData());
@@ -96,10 +107,12 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
assertTrue("No image data written", buffer.size() > 0);
}
@Test
public void testWriteNull() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
try {
writer.write((RenderedImage) null);
}
@@ -108,11 +121,14 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
catch (IOException e) {
fail(e.getMessage());
}
assertTrue("Image data written", buffer.size() == 0);
}
@Test
public void testWriteNoOutput() {
ImageWriter writer = createImageWriter();
try {
writer.write(getTestData());
}
@@ -123,6 +139,7 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
}
}
@Test
public void testGetDefaultWriteParam() {
ImageWriter writer = createImageWriter();
ImageWriteParam param = writer.getDefaultWriteParam();
@@ -132,29 +149,26 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
// TODO: Test writing with params
// TODO: Source region and subsampling at least
@Test
public void testAddIIOWriteProgressListener() {
ImageWriter writer = createImageWriter();
Mock mockListener = new Mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
writer.addIIOWriteProgressListener(mock(IIOWriteProgressListener.class));
}
@Test
public void testAddIIOWriteProgressListenerNull() {
ImageWriter writer = createImageWriter();
writer.addIIOWriteProgressListener(null);
}
@Test
public void testAddIIOWriteProgressListenerCallbacks() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
Mock mockListener = new Mock(IIOWriteProgressListener.class);
String started = "Started";
mockListener.expects(once()).method("imageStarted").withAnyArguments().id(started);
mockListener.stubs().method("imageProgress").withAnyArguments().after(started);
mockListener.expects(once()).method("imageComplete").withAnyArguments().after(started);
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
IIOWriteProgressListener listener = mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener(listener);
try {
writer.write(getTestData());
@@ -164,36 +178,25 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
}
// At least imageStarted and imageComplete, plus any number of imageProgress
mockListener.verify();
InOrder ordered = inOrder(listener);
ordered.verify(listener).imageStarted(writer, 0);
ordered.verify(listener, atLeastOnce()).imageProgress(eq(writer), anyInt());
ordered.verify(listener).imageComplete(writer);
}
@Test
public void testMultipleAddIIOWriteProgressListenerCallbacks() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
Mock mockListener = new Mock(IIOWriteProgressListener.class);
String started = "Started";
mockListener.expects(once()).method("imageStarted").withAnyArguments().id(started);
mockListener.stubs().method("imageProgress").withAnyArguments().after(started);
mockListener.expects(once()).method("imageComplete").withAnyArguments().after(started);
IIOWriteProgressListener listener = mock(IIOWriteProgressListener.class);
IIOWriteProgressListener listenerToo = mock(IIOWriteProgressListener.class);
IIOWriteProgressListener listenerThree = mock(IIOWriteProgressListener.class);
Mock mockListenerToo = new Mock(IIOWriteProgressListener.class);
String startedToo = "Started Two";
mockListenerToo.expects(once()).method("imageStarted").withAnyArguments().id(startedToo);
mockListenerToo.stubs().method("imageProgress").withAnyArguments().after(startedToo);
mockListenerToo.expects(once()).method("imageComplete").withAnyArguments().after(startedToo);
Mock mockListenerThree = new Mock(IIOWriteProgressListener.class);
String startedThree = "Started Three";
mockListenerThree.expects(once()).method("imageStarted").withAnyArguments().id(startedThree);
mockListenerThree.stubs().method("imageProgress").withAnyArguments().after(startedThree);
mockListenerThree.expects(once()).method("imageComplete").withAnyArguments().after(startedThree);
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListenerToo.proxy());
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListenerThree.proxy());
writer.addIIOWriteProgressListener(listener);
writer.addIIOWriteProgressListener(listenerToo);
writer.addIIOWriteProgressListener(listenerThree);
try {
writer.write(getTestData());
@@ -203,30 +206,40 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
}
// At least imageStarted and imageComplete, plus any number of imageProgress
mockListener.verify();
mockListenerToo.verify();
mockListenerThree.verify();
InOrder ordered = inOrder(listener, listenerToo, listenerThree);
ordered.verify(listener).imageStarted(writer, 0);
ordered.verify(listenerToo).imageStarted(writer, 0);
ordered.verify(listenerThree).imageStarted(writer, 0);
ordered.verify(listener, atLeastOnce()).imageProgress(eq(writer), anyInt());
ordered.verify(listenerToo, atLeastOnce()).imageProgress(eq(writer), anyInt());
ordered.verify(listenerThree, atLeastOnce()).imageProgress(eq(writer), anyInt());
ordered.verify(listener).imageComplete(writer);
ordered.verify(listenerToo).imageComplete(writer);
ordered.verify(listenerThree).imageComplete(writer);
}
@Test
public void testRemoveIIOWriteProgressListenerNull() {
ImageWriter writer = createImageWriter();
writer.removeIIOWriteProgressListener(null);
}
@Test
public void testRemoveIIOWriteProgressListenerNone() {
ImageWriter writer = createImageWriter();
Mock mockListener = new Mock(IIOWriteProgressListener.class);
writer.removeIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
writer.removeIIOWriteProgressListener(mock(IIOWriteProgressListener.class));
}
@Test
public void testRemoveIIOWriteProgressListener() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
Mock mockListener = new Mock(IIOWriteProgressListener.class);
IIOWriteProgressListener listener = (IIOWriteProgressListener) mockListener.proxy();
IIOWriteProgressListener listener = mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener(listener);
writer.removeIIOWriteProgressListener(listener);
@@ -238,25 +251,22 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
}
// Should not have called any methods...
mockListener.verify();
verifyZeroInteractions(listener);
}
@Test
public void testRemoveIIOWriteProgressListenerMultiple() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
IIOWriteProgressListener listener = mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener(listener);
Mock mockListener = new Mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
IIOWriteProgressListener listenerToo = mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener(listenerToo);
Mock mockListenerToo = new Mock(IIOWriteProgressListener.class);
mockListenerToo.stubs().method("imageStarted").withAnyArguments();
mockListenerToo.stubs().method("imageProgress").withAnyArguments();
mockListenerToo.stubs().method("imageComplete").withAnyArguments();
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListenerToo.proxy());
writer.removeIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
writer.removeIIOWriteProgressListener(listener);
try {
writer.write(getTestData());
@@ -266,19 +276,25 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
}
// Should not have called any methods...
mockListener.verify();
mockListenerToo.verify();
verifyZeroInteractions(listener);
// At least imageStarted and imageComplete, plus any number of imageProgress
InOrder ordered = inOrder(listenerToo);
ordered.verify(listenerToo).imageStarted(writer, 0);
ordered.verify(listenerToo, atLeastOnce()).imageProgress(eq(writer), anyInt());
ordered.verify(listenerToo).imageComplete(writer);
}
@Test
public void testRemoveAllIIOWriteProgressListeners() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
Mock mockListener = new Mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
IIOWriteProgressListener listener = mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener(listener);
writer.removeAllIIOWriteProgressListeners();
@@ -290,20 +306,21 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
}
// Should not have called any methods...
mockListener.verify();
verifyZeroInteractions(listener);
}
@Test
public void testRemoveAllIIOWriteProgressListenersMultiple() throws IOException {
ImageWriter writer = createImageWriter();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
writer.setOutput(ImageIO.createImageOutputStream(buffer));
Mock mockListener = new Mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListener.proxy());
IIOWriteProgressListener listener = mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener(listener);
Mock mockListenerToo = new Mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener((IIOWriteProgressListener) mockListenerToo.proxy());
IIOWriteProgressListener listenerToo = mock(IIOWriteProgressListener.class);
writer.addIIOWriteProgressListener(listenerToo);
writer.removeAllIIOWriteProgressListeners();
@@ -315,8 +332,7 @@ public abstract class ImageWriterAbstractTestCase extends MockObjectTestCase {
}
// Should not have called any methods...
mockListener.verify();
mockListenerToo.verify();
verifyZeroInteractions(listener);
verifyZeroInteractions(listenerToo);
}
}