Backups/TwelveMonkeys
2
0
Fork 0
mirror of https://github.com/haraldk/TwelveMonkeys.git synced 2025-08-02 11:05:29 -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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

524
common/common-lang/src/test/java/com/twelvemonkeys/util/MapAbstractTestCase.java
View File

File diff suppressed because it is too large Load Diff

6
common/common-lang/src/test/java/com/twelvemonkeys/util/ObjectAbstractTestCase.java
View File

@ -15,7 +15,7 @@
*/
package com.twelvemonkeys.util;
import org.jmock.cglib.MockObjectTestCase;
import junit.framework.TestCase;
import java.io.*;
@ -35,9 +35,9 @@ import java.io.*;
* @author Stephen Colebourne
* @author Anonymous
*/
public abstract class ObjectAbstractTestCase extends MockObjectTestCase {
public abstract class ObjectAbstractTestCase extends TestCase {
//-----------------------------------------------------------------------
/**
* Implement this method to return the object to test.
*

7
common/pom.xml
View File

@ -52,12 +52,5 @@
<version>4.7</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>jmock</groupId>
<artifactId>jmock-cglib</artifactId>
<version>1.0.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

1
imageio/imageio-batik/src/main/java/com/twelvemonkeys/imageio/plugins/wmf/WMFImageReader.java
View File

@ -81,6 +81,7 @@ public class WMFImageReader extends ImageReaderBase {
processReadAborted();
return image;
}
processImageProgress(100f);
processImageComplete();

4
imageio/imageio-batik/src/test/java/com/twelvemonkeys/imageio/plugins/svg/SVGImageReaderTestCase.java
View File

@ -43,7 +43,7 @@ import java.util.List;
* @version $Id: SVGImageReaderTestCase.java,v 1.0 Apr 1, 2008 10:39:17 PM haraldk Exp$
*/
public class SVGImageReaderTestCase extends ImageReaderAbstractTestCase<SVGImageReader> {
private SVGImageReaderSpi mSVGImageReaderSpi = new SVGImageReaderSpi();
private SVGImageReaderSpi provider = new SVGImageReaderSpi();
protected List<TestData> getTestData() {
return Arrays.asList(
@ -52,7 +52,7 @@ public class SVGImageReaderTestCase extends ImageReaderAbstractTestCase<SVGImage
}
protected ImageReaderSpi createProvider() {
return mSVGImageReaderSpi;
return provider;
}
@Override

4
imageio/imageio-batik/src/test/java/com/twelvemonkeys/imageio/plugins/wmf/WMFImageReaderTestCase.java
View File

@ -43,7 +43,7 @@ import java.util.List;
* @version $Id: SVGImageReaderTestCase.java,v 1.0 Apr 1, 2008 10:39:17 PM haraldk Exp$
*/
public class WMFImageReaderTestCase extends ImageReaderAbstractTestCase<WMFImageReader> {
private WMFImageReaderSpi mSVGImageReaderSpi = new WMFImageReaderSpi();
private WMFImageReaderSpi provider = new WMFImageReaderSpi();
protected List<TestData> getTestData() {
return Arrays.asList(
@ -53,7 +53,7 @@ public class WMFImageReaderTestCase extends ImageReaderAbstractTestCase<WMFImage
}
protected ImageReaderSpi createProvider() {
return mSVGImageReaderSpi;
return provider;
}
@Override

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);
}
}

7
imageio/imageio-ico/src/test/java/com/twelvemonkeys/imageio/plugins/ico/CURImageReaderTestCase.java
View File

@ -1,6 +1,7 @@
package com.twelvemonkeys.imageio.plugins.ico;
import com.twelvemonkeys.imageio.util.ImageReaderAbstractTestCase;
import org.junit.Test;
import javax.imageio.ImageReadParam;
import javax.imageio.spi.ImageReaderSpi;
@ -10,6 +11,8 @@ import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.*;
/**
* CURImageReaderTestCase
*
@ -74,19 +77,23 @@ public class CURImageReaderTestCase extends ImageReaderAbstractTestCase<CURImage
assertEquals(pExpected, reader.getHotSpot(0));
}
@Test
public void testHandHotspot() throws IOException {
assertHotSpot(getTestData().get(0), null, new Point(15, 15));
}
@Test
public void testZoomHotspot() throws IOException {
assertHotSpot(getTestData().get(1), null, new Point(13, 11));
}
@Test
public void testHandHotspotWithParam() throws IOException {
ImageReadParam param = new ImageReadParam();
assertHotSpot(getTestData().get(0), param, new Point(15, 15));
}
@Test
public void testHandHotspotExplicitDestination() throws IOException {
CURImageReader reader = createReader();
reader.setInput(getTestData().get(0).getInputStream());

4
imageio/imageio-jmagick/src/test/java/com/twelvemonkeys/imageio/plugins/jmagick/BMPImageReaderTestCase.java
View File

@ -34,7 +34,7 @@ import java.util.Arrays;
import java.util.List;
public class BMPImageReaderTestCase extends JMagickImageReaderAbstractTestCase<BMPImageReader> {
private BMPImageReaderSpi mProvider = new BMPImageReaderSpi();
private BMPImageReaderSpi provider = new BMPImageReaderSpi();
protected List<TestData> getTestData() {
return Arrays.asList(
@ -63,7 +63,7 @@ public class BMPImageReaderTestCase extends JMagickImageReaderAbstractTestCase<B
}
protected BMPImageReader createReader() {
return new BMPImageReader(mProvider);
return new BMPImageReader(provider);
}
protected ImageReaderSpi createProvider() {

28
imageio/imageio-jmagick/src/test/java/com/twelvemonkeys/imageio/plugins/jmagick/JMagickImageReaderAbstractTestCase.java
View File

@ -29,6 +29,10 @@
package com.twelvemonkeys.imageio.plugins.jmagick;
import com.twelvemonkeys.imageio.util.ImageReaderAbstractTestCase;
import org.junit.Rule;
import org.junit.rules.MethodRule;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.Statement;
import javax.imageio.ImageReader;
@ -40,14 +44,20 @@ import javax.imageio.ImageReader;
* @version $Id: JMagickImageReaderAbstractTestCase.java,v 1.0 Apr 1, 2008 2:59:05 PM haraldk Exp$
*/
public abstract class JMagickImageReaderAbstractTestCase<T extends ImageReader> extends ImageReaderAbstractTestCase<T> {
@Override
protected void runTest() throws Throwable {
if (JMagickImageReaderSpiSupport.AVAILABLE) {
super.runTest();
@Rule
public MethodRule rule = new MethodRule() {
public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
if (JMagickImageReaderSpiSupport.AVAILABLE) {
return base;
}
return new Statement() {
@Override
public void evaluate() throws Throwable {
// TODO: Make this increase "skipped" count, rather than run/success
System.err.println("WARNING: JMagick not installed. Skipping test " + method.getName());
}
};
}
else {
System.err.println("WARNING: JMagick not installed. Skipping test " + getName());
}
}
};
}

2
imageio/imageio-jmagick/todo.txt
View File

@ -1,5 +1,5 @@
- These readers/writers could probably benefit alot from using JNI with nio
bytechannel buffers... RFE to JMagick guys?
- Create stream providers and allow creatig a ImageInputStream from a
- Create stream providers and allow creating an ImageInputStream from a
MagickImage? Does that even make sense? Or maybe create File based streams
that exposes the file name for JMagick to write directly.

8
imageio/imageio-pict/src/test/java/com/twelvemonkeys/imageio/plugins/pict/PICTImageReaderTestCase.java
View File

@ -1,6 +1,7 @@
package com.twelvemonkeys.imageio.plugins.pict;
import com.twelvemonkeys.imageio.util.ImageReaderAbstractTestCase;
import org.junit.Test;
import javax.imageio.spi.ImageReaderSpi;
import java.awt.*;
@ -8,6 +9,8 @@ import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.*;
/**
* ICOImageReaderTestCase
*
@ -59,11 +62,12 @@ public class PICTImageReaderTestCase extends ImageReaderAbstractTestCase<PICTIma
return Arrays.asList("image/pict", "image/x-pict");
}
@Test
public void testProviderNotMatchJPEG() throws IOException {
// This JPEG contains PICT magic bytes at locations a PICT would normally have them.
// We should not claim to be able read it.
assertFalse(sProvider.canDecodeInput(new TestData(
getClassLoaderResource("/jpeg/R-7439-1151526181.jpeg"),
assertFalse(sProvider.canDecodeInput(
new TestData(getClassLoaderResource("/jpeg/R-7439-1151526181.jpeg"),
new Dimension(386, 396)
)));
}

2
imageio/imageio-psd/src/test/java/com/twelvemonkeys/imageio/plugins/psd/PSDImageReaderTestCase.java
View File

@ -16,6 +16,8 @@ import java.util.List;
import java.util.ArrayList;
import java.io.IOException;
import static org.junit.Assert.*;
/**
* PSDImageReaderTestCase
*

8
imageio/imageio-reference/src/test/java/com/twelvemonkeys/imageio/reference/JPEGImageReaderTestCase.java
View File

@ -4,13 +4,14 @@ import com.sun.imageio.plugins.jpeg.JPEGImageReader;
import com.sun.imageio.plugins.jpeg.JPEGImageReaderSpi;
import com.twelvemonkeys.imageio.util.ImageReaderAbstractTestCase;
import com.twelvemonkeys.lang.SystemUtil;
import org.junit.Test;
import javax.imageio.IIOException;
import javax.imageio.spi.ImageReaderSpi;
import java.util.Arrays;
import java.util.List;
import java.awt.*;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
/**
* JPEGImageReaderTestCase
@ -67,6 +68,7 @@ public class JPEGImageReaderTestCase extends ImageReaderAbstractTestCase<JPEGIma
return Arrays.asList(provider.getMIMETypes());
}
@Test
@Override
public void testSetDestination() throws IOException {
// Known bug in Sun JPEGImageReader before Java 6
@ -78,6 +80,7 @@ public class JPEGImageReaderTestCase extends ImageReaderAbstractTestCase<JPEGIma
}
}
@Test
@Override
public void testSetDestinationType() throws IOException {
// Known bug in Sun JPEGImageReader before Java 6
@ -89,6 +92,7 @@ public class JPEGImageReaderTestCase extends ImageReaderAbstractTestCase<JPEGIma
}
}
@Test
@Override
public void testReadAsRenderedImageIndexOutOfBounds() throws IIOException {
try {

2
imageio/imageio-reference/src/test/java/com/twelvemonkeys/imageio/reference/PNGImageReaderTestCase.java
View File

@ -3,6 +3,7 @@ package com.twelvemonkeys.imageio.reference;
import com.sun.imageio.plugins.png.PNGImageReader;
import com.sun.imageio.plugins.png.PNGImageReaderSpi;
import com.twelvemonkeys.imageio.util.ImageReaderAbstractTestCase;
import org.junit.Test;
import javax.imageio.IIOException;
import javax.imageio.spi.ImageReaderSpi;
@ -64,6 +65,7 @@ public class PNGImageReaderTestCase extends ImageReaderAbstractTestCase<PNGImage
return Arrays.asList(provider.getMIMETypes());
}
@Test
@Override
public void testSetDestinationTypeIllegal() throws IOException {
try {

10
imageio/imageio-thumbsdb/src/test/java/com/twelvemonkeys/imageio/plugins/thumbsdb/ThumbsDBImageReaderTestCase.java
View File

@ -33,6 +33,7 @@ import com.twelvemonkeys.imageio.util.ImageReaderAbstractTestCase;
import com.twelvemonkeys.io.ole2.CompoundDocument;
import com.twelvemonkeys.io.ole2.Entry;
import com.twelvemonkeys.lang.SystemUtil;
import org.junit.Test;
import javax.imageio.spi.ImageReaderSpi;
import javax.imageio.stream.ImageInputStream;
@ -53,7 +54,7 @@ import java.util.List;
public class ThumbsDBImageReaderTestCase extends ImageReaderAbstractTestCase<ThumbsDBImageReader> {
private static final boolean IS_JAVA_6 = SystemUtil.isClassAvailable("java.util.Deque");
private ThumbsDBImageReaderSpi mProvider = new ThumbsDBImageReaderSpi();
private ThumbsDBImageReaderSpi provider = new ThumbsDBImageReaderSpi();
protected List<TestData> getTestData() {
return Arrays.asList(
@ -82,12 +83,12 @@ public class ThumbsDBImageReaderTestCase extends ImageReaderAbstractTestCase<Thu
}
protected ImageReaderSpi createProvider() {
return mProvider;
return provider;
}
@Override
protected ThumbsDBImageReader createReader() {
return new ThumbsDBImageReader(mProvider);
return new ThumbsDBImageReader(provider);
}
protected Class<ThumbsDBImageReader> getReaderClass() {
@ -106,6 +107,7 @@ public class ThumbsDBImageReaderTestCase extends ImageReaderAbstractTestCase<Thu
return Arrays.asList("image/x-thumbs-db");
}
@Test
public void testArrayIndexOutOfBoundsBufferedReadBug() throws IOException {
ImageInputStream input = new BufferedImageInputStream(new MemoryCacheImageInputStream(getClass().getResourceAsStream("/thumbsdb/Thumbs-camera.db")));
input.setByteOrder(ByteOrder.LITTLE_ENDIAN);
@ -115,6 +117,7 @@ public class ThumbsDBImageReaderTestCase extends ImageReaderAbstractTestCase<Thu
child.getInputStream();
}
@Test
@Override
public void testSetDestination() throws IOException {
// Known bug in Sun JPEGImageReader before Java 6
@ -126,6 +129,7 @@ public class ThumbsDBImageReaderTestCase extends ImageReaderAbstractTestCase<Thu
}
}
@Test
@Override
public void testSetDestinationType() throws IOException {
// Known bug in Sun JPEGImageReader before Java 6

14
sandbox/pom.xml
View File

@ -32,11 +32,6 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>jmock</groupId>
<artifactId>jmock-cglib</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<dependencyManagement>
@ -102,14 +97,7 @@
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.3.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>jmock</groupId>
<artifactId>jmock-cglib</artifactId>
<version>1.0.1</version>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>

8
sandbox/sandbox-common/pom.xml
View File

@ -12,7 +12,7 @@
<packaging>jar</packaging>
<name>TwelveMonkeys :: Sandbox :: Common</name>
<description>
The TwelveMonkeys Sandbox Common. Experimental stuff.
The TwelveMonkeys Common Sandbox. Experimental stuff.
</description>
<dependencies>
@ -28,6 +28,12 @@
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.twelvemonkeys.imageio</groupId>
<artifactId>imageio-core</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.twelvemonkeys.common</groupId>
<artifactId>common-io</artifactId>

2
sandbox/sandbox-swing/pom.xml
View File

@ -12,7 +12,7 @@
<packaging>jar</packaging>
<name>TwelveMonkeys :: Sandbox :: Swing</name>
<description>
The TwelveMonkeys Sandbox Swing. Experimental stuff.
The TwelveMonkeys Swing Sandbox. Experimental stuff.
</description>
<properties>

9
servlet/pom.xml
View File

@ -81,17 +81,10 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>jmock</groupId>
<artifactId>jmock-cglib</artifactId>
<version>1.0.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
<version>1.8.0</version>
<version>1.8.5</version>
</dependency>
</dependencies>

49
servlet/src/test/java/com/twelvemonkeys/servlet/FilterAbstractTestCase.java
View File

@ -115,17 +115,13 @@ public abstract class FilterAbstractTestCase extends ObjectAbstractTestCase {
}
static class MockFilterConfig implements FilterConfig {
private final Map mParams;
private final Map<String, String> params;
MockFilterConfig() {
this(new HashMap());
}
MockFilterConfig(Map pParams) {
MockFilterConfig(Map<String, String> pParams) {
if (pParams == null) {
throw new IllegalArgumentException("params == null");
}
mParams = pParams;
params = pParams;
}
public String getFilterName() {
@ -133,11 +129,11 @@ public abstract class FilterAbstractTestCase extends ObjectAbstractTestCase {
}
public String getInitParameter(String pName) {
return (String) mParams.get(pName);
return params.get(pName);
}
public Enumeration getInitParameterNames() {
return Collections.enumeration(mParams.keySet());
return Collections.enumeration(params.keySet());
}
public ServletContext getServletContext() {
@ -145,20 +141,20 @@ public abstract class FilterAbstractTestCase extends ObjectAbstractTestCase {
}
private static class MockServletContext implements ServletContext {
private final Map mAttributes;
private final Map mParams;
private final Map<String, Object> attributes;
private final Map<String, String> params;
MockServletContext() {
mAttributes = new HashMap();
mParams = new HashMap();
attributes = new HashMap<String, Object>();
params = new HashMap<String, String>();
}
public Object getAttribute(String s) {
return mAttributes.get(s);
return attributes.get(s);
}
public Enumeration getAttributeNames() {
return Collections.enumeration(mAttributes.keySet());
return Collections.enumeration(attributes.keySet());
}
public ServletContext getContext(String s) {
@ -166,11 +162,11 @@ public abstract class FilterAbstractTestCase extends ObjectAbstractTestCase {
}
public String getInitParameter(String s) {
return (String) mParams.get(s);
return (String) params.get(s);
}
public Enumeration getInitParameterNames() {
return Collections.enumeration(mParams.keySet());
return Collections.enumeration(params.keySet());
}
public int getMajorVersion() {
@ -230,40 +226,37 @@ public abstract class FilterAbstractTestCase extends ObjectAbstractTestCase {
}
public void log(Exception exception, String s) {
// TODO: Implement
}
public void log(String s) {
// TODO: Implement
}
public void log(String s, Throwable throwable) {
// TODO: Implement
}
public void removeAttribute(String s) {
mAttributes.remove(s);
attributes.remove(s);
}
public void setAttribute(String s, Object obj) {
mAttributes.put(s, obj);
attributes.put(s, obj);
}
}
}
static class MockServletRequest implements ServletRequest {
final private Map mAttributes;
final private Map<String, Object> attributes;
public MockServletRequest() {
mAttributes = new HashMap();
attributes = new HashMap<String, Object>();
}
public Object getAttribute(String pKey) {
return mAttributes.get(pKey);
return attributes.get(pKey);
}
public Enumeration getAttributeNames() {
return Collections.enumeration(mAttributes.keySet());
return Collections.enumeration(attributes.keySet());
}
public String getCharacterEncoding() {
@ -331,11 +324,11 @@ public abstract class FilterAbstractTestCase extends ObjectAbstractTestCase {
}
public void setAttribute(String pKey, Object pValue) {
mAttributes.put(pKey, pValue);
attributes.put(pKey, pValue);
}
public void removeAttribute(String pKey) {
mAttributes.remove(pKey);
attributes.remove(pKey);
}
public Locale getLocale() {

56
servlet/src/test/java/com/twelvemonkeys/servlet/ServletHeadersMapAdapterTestCase.java
View File

@ -1,20 +1,21 @@
package com.twelvemonkeys.servlet;
import com.twelvemonkeys.util.MapAbstractTestCase;
import org.jmock.Mock;
import org.jmock.core.Invocation;
import org.jmock.core.Stub;
import org.jmock.core.stub.CustomStub;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import static org.mockito.Mockito.when;
/**
* ServletConfigMapAdapterTestCase
* <p/>
*
* @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
* @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-servlet/src/test/java/com/twelvemonkeys/servlet/ServletHeadersMapAdapterTestCase.java#1 $
* @version $Id: ServletHeadersMapAdapterTestCase.java#1 $
*/
public class ServletHeadersMapAdapterTestCase extends MapAbstractTestCase {
private static final List<String> HEADER_VALUE_ETAG = Arrays.asList("\"1234567890abcdef\"");
@ -43,24 +44,21 @@ public class ServletHeadersMapAdapterTestCase extends MapAbstractTestCase {
}
public Map makeEmptyMap() {
Mock mockRequest = mock(HttpServletRequest.class);
mockRequest.stubs().method("getHeaderNames").will(returnValue(Collections.enumeration(Collections.emptyList())));
mockRequest.stubs().method("getHeaders").will(returnValue(null));
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
when(request.getHeaderNames()).thenAnswer(returnEnumeration(Collections.emptyList()));
return new ServletHeadersMapAdapter((HttpServletRequest) mockRequest.proxy());
return new ServletHeadersMapAdapter(request);
}
@Override
public Map makeFullMap() {
Mock mockRequest = mock(HttpServletRequest.class);
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
when(request.getHeaderNames()).thenAnswer(returnEnumeration(Arrays.asList(getSampleKeys())));
when(request.getHeaders("Date")).thenAnswer(returnEnumeration(HEADER_VALUE_DATE));
when(request.getHeaders("ETag")).thenAnswer(returnEnumeration(HEADER_VALUE_ETAG));
when(request.getHeaders("X-Foo")).thenAnswer(returnEnumeration(HEADER_VALUE_FOO));
mockRequest.stubs().method("getHeaderNames").will(returnEnumeration("ETag", "Date", "X-Foo"));
mockRequest.stubs().method("getHeaders").with(eq("Date")).will(returnEnumeration(HEADER_VALUE_DATE));
mockRequest.stubs().method("getHeaders").with(eq("ETag")).will(returnEnumeration(HEADER_VALUE_ETAG));
mockRequest.stubs().method("getHeaders").with(eq("X-Foo")).will(returnEnumeration(HEADER_VALUE_FOO));
mockRequest.stubs().method("getHeaders").with(not(or(eq("Date"), or(eq("ETag"), eq("X-Foo"))))).will(returnValue(null));
return new ServletHeadersMapAdapter((HttpServletRequest) mockRequest.proxy());
return new ServletHeadersMapAdapter(request);
}
@Override
@ -73,31 +71,25 @@ public class ServletHeadersMapAdapterTestCase extends MapAbstractTestCase {
return new Object[] {HEADER_VALUE_DATE, HEADER_VALUE_ETAG, HEADER_VALUE_FOO};
}
@Override
public Object[] getNewSampleValues() {
// Needs to be same length but different values
return new Object[3];
}
protected Stub returnEnumeration(final Object... pValues) {
return new EnumerationStub(Arrays.asList(pValues));
protected static <T> ReturnNewEnumeration<T> returnEnumeration(final Collection<T> collection) {
return new ReturnNewEnumeration<T>(collection);
}
protected Stub returnEnumeration(final List<?> pValues) {
return new EnumerationStub(pValues);
}
private static class ReturnNewEnumeration<T> implements Answer<Enumeration<T>> {
private final Collection<T> collection;
private static class EnumerationStub extends CustomStub {
private List<?> mValues;
public EnumerationStub(final List<?> pValues) {
super("Returns a new enumeration");
mValues = pValues;
private ReturnNewEnumeration(final Collection<T> collection) {
this.collection = collection;
}
public Object invoke(Invocation invocation) throws Throwable {
return Collections.enumeration(mValues);
public Enumeration<T> answer(InvocationOnMock invocation) throws Throwable {
return Collections.enumeration(collection);
}
}
}
}

50
servlet/src/test/java/com/twelvemonkeys/servlet/ServletParametersMapAdapterTestCase.java
View File

@ -1,14 +1,15 @@
package com.twelvemonkeys.servlet;
import com.twelvemonkeys.util.MapAbstractTestCase;
import org.jmock.Mock;
import org.jmock.core.Invocation;
import org.jmock.core.Stub;
import org.jmock.core.stub.CustomStub;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import static org.mockito.Mockito.when;
/**
* ServletConfigMapAdapterTestCase
* <p/>
@ -43,24 +44,22 @@ public class ServletParametersMapAdapterTestCase extends MapAbstractTestCase {
}
public Map makeEmptyMap() {
Mock mockRequest = mock(HttpServletRequest.class);
mockRequest.stubs().method("getParameterNames").will(returnValue(Collections.enumeration(Collections.emptyList())));
mockRequest.stubs().method("getParameterValues").will(returnValue(null));
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
when(request.getParameterNames()).thenAnswer(returnEnumeration(Collections.emptyList()));
return new ServletParametersMapAdapter((HttpServletRequest) mockRequest.proxy());
return new ServletParametersMapAdapter(request);
}
@Override
public Map makeFullMap() {
Mock mockRequest = mock(HttpServletRequest.class);
HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
mockRequest.stubs().method("getParameterNames").will(returnEnumeration("tag", "date", "foo"));
mockRequest.stubs().method("getParameterValues").with(eq("date")).will(returnValue(PARAM_VALUE_DATE.toArray(new String[PARAM_VALUE_DATE.size()])));
mockRequest.stubs().method("getParameterValues").with(eq("tag")).will(returnValue(PARAM_VALUE_ETAG.toArray(new String[PARAM_VALUE_ETAG.size()])));
mockRequest.stubs().method("getParameterValues").with(eq("foo")).will(returnValue(PARAM_VALUE_FOO.toArray(new String[PARAM_VALUE_FOO.size()])));
mockRequest.stubs().method("getParameterValues").with(not(or(eq("date"), or(eq("tag"), eq("foo"))))).will(returnValue(null));
when(request.getParameterNames()).thenAnswer(returnEnumeration(Arrays.asList("tag", "date", "foo")));
when(request.getParameterValues("date")).thenReturn(PARAM_VALUE_DATE.toArray(new String[PARAM_VALUE_DATE.size()]));
when(request.getParameterValues("tag")).thenReturn(PARAM_VALUE_ETAG.toArray(new String[PARAM_VALUE_ETAG.size()]));
when(request.getParameterValues("foo")).thenReturn(PARAM_VALUE_FOO.toArray(new String[PARAM_VALUE_FOO.size()]));
return new ServletParametersMapAdapter((HttpServletRequest) mockRequest.proxy());
return new ServletParametersMapAdapter(request);
}
@Override
@ -79,24 +78,19 @@ public class ServletParametersMapAdapterTestCase extends MapAbstractTestCase {
return new Object[3];
}
protected Stub returnEnumeration(final Object... pValues) {
return new EnumerationStub(Arrays.asList(pValues));
protected static <T> ReturnNewEnumeration<T> returnEnumeration(final Collection<T> collection) {
return new ReturnNewEnumeration<T>(collection);
}
protected Stub returnEnumeration(final List<?> pValues) {
return new EnumerationStub(pValues);
}
private static class ReturnNewEnumeration<T> implements Answer<Enumeration<T>> {
private final Collection<T> collection;
private static class EnumerationStub extends CustomStub {
private List<?> mValues;
public EnumerationStub(final List<?> pValues) {
super("Returns a new enumeration");
mValues = pValues;
private ReturnNewEnumeration(final Collection<T> collection) {
this.collection = collection;
}
public Object invoke(Invocation invocation) throws Throwable {
return Collections.enumeration(mValues);
public Enumeration<T> answer(InvocationOnMock invocation) throws Throwable {
return Collections.enumeration(collection);
}
}
}

1218
servlet/src/test/java/com/twelvemonkeys/servlet/cache/HTTPCacheTestCase.java vendored
View File

File diff suppressed because it is too large Load Diff

740
servlet/src/test/java/com/twelvemonkeys/servlet/image/ImageServletResponseImplTestCase.java
View File

File diff suppressed because it is too large Load Diff