mirror of
https://github.com/haraldk/TwelveMonkeys.git
synced 2025-08-03 03:25:28 -04:00
Major test-case cleanup.
- 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
parent
52a97cfb2f
commit
0c4fc454b9
@ -20,20 +20,20 @@ import java.util.*;
|
||||
|
||||
/**
|
||||
* Abstract test class for {@link java.util.Map} methods and contracts.
|
||||
* <p>
|
||||
* <p/>
|
||||
* The forces at work here are similar to those in {@link CollectionAbstractTestCase}.
|
||||
* If your class implements the full Map interface, including optional
|
||||
* operations, simply extend this class, and implement the
|
||||
* {@link #makeEmptyMap()} method.
|
||||
* <p>
|
||||
* <p/>
|
||||
* On the other hand, if your map implementation is weird, you may have to
|
||||
* override one or more of the other protected methods. They're described
|
||||
* below.
|
||||
* <p>
|
||||
* <p/>
|
||||
* <b>Entry Population Methods</b>
|
||||
* <p>
|
||||
* <p/>
|
||||
* Override these methods if your map requires special entries:
|
||||
*
|
||||
* <p/>
|
||||
* <ul>
|
||||
* <li>{@link #getSampleKeys()}
|
||||
* <li>{@link #getSampleValues()}
|
||||
@ -41,11 +41,11 @@ import java.util.*;
|
||||
* <li>{@link #getOtherKeys()}
|
||||
* <li>{@link #getOtherValues()}
|
||||
* </ul>
|
||||
*
|
||||
* <p/>
|
||||
* <b>Supported Operation Methods</b>
|
||||
* <p>
|
||||
* <p/>
|
||||
* Override these methods if your map doesn't support certain operations:
|
||||
*
|
||||
* <p/>
|
||||
* <ul>
|
||||
* <li> {@link #isPutAddSupported()}
|
||||
* <li> {@link #isPutChangeSupported()}
|
||||
@ -56,9 +56,9 @@ import java.util.*;
|
||||
* <li> {@link #isAllowNullKey()}
|
||||
* <li> {@link #isAllowNullValue()}
|
||||
* </ul>
|
||||
*
|
||||
* <p/>
|
||||
* <b>Fixture Methods</b>
|
||||
* <p>
|
||||
* <p/>
|
||||
* For tests on modification operations (puts and removes), fixtures are used
|
||||
* to verify that that operation results in correct state for the map and its
|
||||
* collection views. Basically, the modification is performed against your
|
||||
@ -69,20 +69,20 @@ import java.util.*;
|
||||
* on both your map implementation and the confirmed map implementation, the
|
||||
* two maps are compared to see if their state is identical. The comparison
|
||||
* also compares the collection views to make sure they're still the same.<P>
|
||||
*
|
||||
* <p/>
|
||||
* The upshot of all that is that <I>any</I> test that modifies the map in
|
||||
* <I>any</I> way will verify that <I>all</I> of the map's state is still
|
||||
* correct, including the state of its collection views. So for instance
|
||||
* if a key is removed by the map's key set's iterator, then the entry set
|
||||
* is checked to make sure the key/value pair no longer appears.<P>
|
||||
*
|
||||
* <p/>
|
||||
* The {@link #map} field holds an instance of your collection implementation.
|
||||
* The {@link #entrySet}, {@link #keySet} and {@link #values} fields hold
|
||||
* that map's collection views. And the {@link #confirmed} field holds
|
||||
* an instance of the confirmed collection implementation. The
|
||||
* {@link #resetEmpty()} and {@link #resetFull()} methods set these fields to
|
||||
* empty or full maps, so that tests can proceed from a known state.<P>
|
||||
*
|
||||
* <p/>
|
||||
* After a modification operation to both {@link #map} and {@link #confirmed},
|
||||
* the {@link #verifyAll()} method is invoked to compare the results. The
|
||||
* {@link # verify0} method calls separate methods to verify the map and its three
|
||||
@ -92,9 +92,9 @@ import java.util.*;
|
||||
* instance, TestDoubleOrderedMap would want override its
|
||||
* {@link #verifyValues()} method to verify that the values are unique and in
|
||||
* ascending order.<P>
|
||||
*
|
||||
* <p/>
|
||||
* <b>Other Notes</b>
|
||||
* <p>
|
||||
* <p/>
|
||||
* If your {@link Map} fails one of these tests by design, you may still use
|
||||
* this base set of cases. Simply override the test case (method) your map
|
||||
* fails and/or the methods that define the assumptions used by the test
|
||||
@ -153,7 +153,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* support the {@code put} and {@code putAll} operations
|
||||
* adding new mappings.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns true.
|
||||
* Override if your collection class does not support put adding.
|
||||
*/
|
||||
@ -166,7 +166,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* support the {@code put} and {@code putAll} operations
|
||||
* changing existing mappings.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns true.
|
||||
* Override if your collection class does not support put changing.
|
||||
*/
|
||||
@ -178,7 +178,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* Returns true if the maps produced by
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* support the {@code setValue} operation on entrySet entries.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns isPutChangeSupported().
|
||||
* Override if your collection class does not support setValue but does
|
||||
* support put changing.
|
||||
@ -191,7 +191,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* Returns true if the maps produced by
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* support the {@code remove} and {@code clear} operations.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns true.
|
||||
* Override if your collection class does not support removal operations.
|
||||
*/
|
||||
@ -203,7 +203,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* Returns true if the maps produced by
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* can cause structural modification on a get(). The example is LRUMap.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns false.
|
||||
* Override if your map class structurally modifies on get.
|
||||
*/
|
||||
@ -226,7 +226,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* Returns true if the maps produced by
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* supports null keys.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns true.
|
||||
* Override if your collection class does not support null keys.
|
||||
*/
|
||||
@ -238,7 +238,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* Returns true if the maps produced by
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* supports null values.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns true.
|
||||
* Override if your collection class does not support null values.
|
||||
*/
|
||||
@ -250,7 +250,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* Returns true if the maps produced by
|
||||
* {@link #makeEmptyMap()} and {@link #makeFullMap()}
|
||||
* supports duplicate values.
|
||||
* <p>
|
||||
* <p/>
|
||||
* Default implementation returns true.
|
||||
* Override if your collection class does not support duplicate values.
|
||||
*/
|
||||
@ -276,7 +276,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
public Object[] getOtherKeys() {
|
||||
return getOtherNonNullStringElements();
|
||||
}
|
||||
@ -288,7 +287,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
/**
|
||||
* Returns a list of string elements suitable for return by
|
||||
* {@link #getOtherKeys()} or {@link #getOtherValues}.
|
||||
*
|
||||
* <p/>
|
||||
* <p>Override getOtherElements to returnthe results of this method if your
|
||||
* collection does not support heterogenous elements or the null element.
|
||||
* </p>
|
||||
@ -355,27 +354,25 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
for (int i = 0; i < keys.length; i++) {
|
||||
try {
|
||||
m.put(keys[i], values[i]);
|
||||
} catch (NullPointerException exception) {
|
||||
assertTrue("NullPointerException only allowed to be thrown " +
|
||||
"if either the key or value is null.",
|
||||
}
|
||||
catch (NullPointerException exception) {
|
||||
assertTrue("NullPointerException only allowed to be thrown if either the key or value is null.",
|
||||
keys[i] == null || values[i] == null);
|
||||
|
||||
assertTrue("NullPointerException on null key, but " +
|
||||
"isAllowNullKey is not overridden to return false.",
|
||||
assertTrue("NullPointerException on null key, but isAllowNullKey is not overridden to return false.",
|
||||
keys[i] == null || !isAllowNullKey());
|
||||
|
||||
assertTrue("NullPointerException on null value, but " +
|
||||
"isAllowNullValue is not overridden to return false.",
|
||||
assertTrue("NullPointerException on null value, but isAllowNullValue is not overridden to return false.",
|
||||
values[i] == null || !isAllowNullValue());
|
||||
|
||||
assertTrue("Unknown reason for NullPointer.", false);
|
||||
}
|
||||
}
|
||||
assertEquals("size must reflect number of mappings added.",
|
||||
keys.length, m.size());
|
||||
assertEquals("size must reflect number of mappings added.", keys.length, m.size());
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Return a new, empty {@link Map} to be used for testing.
|
||||
*
|
||||
@ -431,7 +428,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
public String getCompatibilityVersion() {
|
||||
return super.getCompatibilityVersion();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Test to ensure the test setup is working properly. This method checks
|
||||
* to ensure that the getSampleKeys and getSampleValues methods are
|
||||
@ -447,40 +446,27 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
Object[] values = getSampleValues();
|
||||
Object[] newValues = getNewSampleValues();
|
||||
|
||||
assertTrue("failure in test: Must have keys returned from " +
|
||||
"getSampleKeys.", keys != null);
|
||||
|
||||
assertTrue("failure in test: Must have values returned from " +
|
||||
"getSampleValues.", values != null);
|
||||
assertTrue("failure in test: Must have keys returned from getSampleKeys.", keys != null);
|
||||
assertTrue("failure in test: Must have values returned from getSampleValues.", values != null);
|
||||
|
||||
// verify keys and values have equivalent lengths (in case getSampleX are
|
||||
// overridden)
|
||||
assertEquals("failure in test: not the same number of sample " +
|
||||
"keys and values.", keys.length, values.length);
|
||||
|
||||
|
||||
assertEquals("failure in test: not the same number of values and new values.",
|
||||
values.length, newValues.length);
|
||||
assertEquals("failure in test: not the same number of sample keys and values.", keys.length, values.length);
|
||||
assertEquals("failure in test: not the same number of values and new values.", values.length, newValues.length);
|
||||
|
||||
// verify there aren't duplicate keys, and check values
|
||||
for (int i = 0; i < keys.length - 1; i++) {
|
||||
for (int j = i + 1; j < keys.length; j++) {
|
||||
assertTrue("failure in test: duplicate null keys.",
|
||||
(keys[i] != null || keys[j] != null));
|
||||
assertTrue("failure in test: duplicate null keys.", (keys[i] != null || keys[j] != null));
|
||||
assertTrue("failure in test: duplicate non-null key.",
|
||||
(keys[i] == null || keys[j] == null ||
|
||||
(!keys[i].equals(keys[j]) &&
|
||||
!keys[j].equals(keys[i]))));
|
||||
(keys[i] == null || keys[j] == null || (!keys[i].equals(keys[j]) && !keys[j].equals(keys[i]))));
|
||||
}
|
||||
assertTrue("failure in test: found null key, but isNullKeySupported " +
|
||||
"is false.", keys[i] != null || isAllowNullKey());
|
||||
assertTrue("failure in test: found null value, but isNullValueSupported " +
|
||||
"is false.", values[i] != null || isAllowNullValue());
|
||||
assertTrue("failure in test: found null new value, but isNullValueSupported " +
|
||||
"is false.", newValues[i] != null || isAllowNullValue());
|
||||
|
||||
assertTrue("failure in test: found null key, but isNullKeySupported is false.", keys[i] != null || isAllowNullKey());
|
||||
assertTrue("failure in test: found null value, but isNullValueSupported is false.", values[i] != null || isAllowNullValue());
|
||||
assertTrue("failure in test: found null new value, but isNullValueSupported is false.", newValues[i] != null || isAllowNullValue());
|
||||
assertTrue("failure in test: values should not be the same as new value",
|
||||
values[i] != newValues[i] &&
|
||||
(values[i] == null || !values[i].equals(newValues[i])));
|
||||
values[i] != newValues[i] && (values[i] == null || !values[i].equals(newValues[i])));
|
||||
}
|
||||
}
|
||||
|
||||
@ -495,26 +481,18 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
*/
|
||||
public void testMakeMap() {
|
||||
Map em = makeEmptyMap();
|
||||
assertTrue("failure in test: makeEmptyMap must return a non-null map.",
|
||||
em != null);
|
||||
assertTrue("failure in test: makeEmptyMap must return a non-null map.", em != null);
|
||||
|
||||
Map em2 = makeEmptyMap();
|
||||
assertTrue("failure in test: makeEmptyMap must return a non-null map.",
|
||||
em != null);
|
||||
|
||||
assertTrue("failure in test: makeEmptyMap must return a new map " +
|
||||
"with each invocation.", em != em2);
|
||||
assertTrue("failure in test: makeEmptyMap must return a non-null map.", em2 != null);
|
||||
assertTrue("failure in test: makeEmptyMap must return a new map with each invocation.", em != em2);
|
||||
|
||||
Map fm = makeFullMap();
|
||||
assertTrue("failure in test: makeFullMap must return a non-null map.",
|
||||
fm != null);
|
||||
assertTrue("failure in test: makeFullMap must return a non-null map.", fm != null);
|
||||
|
||||
Map fm2 = makeFullMap();
|
||||
assertTrue("failure in test: makeFullMap must return a non-null map.",
|
||||
fm != null);
|
||||
|
||||
assertTrue("failure in test: makeFullMap must return a new map " +
|
||||
"with each invocation.", fm != fm2);
|
||||
assertTrue("failure in test: makeFullMap must return a non-null map.", fm2 != null);
|
||||
assertTrue("failure in test: makeFullMap must return a new map with each invocation.", fm != fm2);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -522,13 +500,11 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
*/
|
||||
public void testMapIsEmpty() {
|
||||
resetEmpty();
|
||||
assertEquals("Map.isEmpty() should return true with an empty map",
|
||||
true, map.isEmpty());
|
||||
assertEquals("Map.isEmpty() should return true with an empty map", true, map.isEmpty());
|
||||
verifyAll();
|
||||
|
||||
resetFull();
|
||||
assertEquals("Map.isEmpty() should return false with a non-empty map",
|
||||
false, map.isEmpty());
|
||||
assertEquals("Map.isEmpty() should return false with a non-empty map", false, map.isEmpty());
|
||||
verifyAll();
|
||||
}
|
||||
|
||||
@ -537,13 +513,11 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
*/
|
||||
public void testMapSize() {
|
||||
resetEmpty();
|
||||
assertEquals("Map.size() should be 0 with an empty map",
|
||||
0, map.size());
|
||||
assertEquals("Map.size() should be 0 with an empty map", 0, map.size());
|
||||
verifyAll();
|
||||
|
||||
resetFull();
|
||||
assertEquals("Map.size() should equal the number of entries " +
|
||||
"in the map", getSampleKeys().length, map.size());
|
||||
assertEquals("Map.size() should equal the number of entries in the map", getSampleKeys().length, map.size());
|
||||
verifyAll();
|
||||
}
|
||||
|
||||
@ -561,7 +535,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
resetFull();
|
||||
map.clear();
|
||||
fail("Expected UnsupportedOperationException on clear");
|
||||
} catch (UnsupportedOperationException ex) {}
|
||||
}
|
||||
catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
@ -576,7 +552,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
verifyAll();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Tests Map.containsKey(Object) by verifying it returns false for all
|
||||
* sample keys on a map created using an empty map and returns true for
|
||||
@ -586,16 +561,14 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
Object[] keys = getSampleKeys();
|
||||
|
||||
resetEmpty();
|
||||
for(int i = 0; i < keys.length; i++) {
|
||||
assertTrue("Map must not contain key when map is empty",
|
||||
!map.containsKey(keys[i]));
|
||||
for (Object key : keys) {
|
||||
assertTrue("Map must not contain key when map is empty", !map.containsKey(key));
|
||||
}
|
||||
verifyAll();
|
||||
|
||||
resetFull();
|
||||
for(int i = 0; i < keys.length; i++) {
|
||||
assertTrue("Map must contain key for a mapping in the map. " +
|
||||
"Missing: " + keys[i], map.containsKey(keys[i]));
|
||||
for (Object key : keys) {
|
||||
assertTrue("Map must contain key for a mapping in the map. Missing: " + key, map.containsKey(key));
|
||||
}
|
||||
verifyAll();
|
||||
}
|
||||
@ -609,21 +582,18 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
Object[] values = getSampleValues();
|
||||
|
||||
resetEmpty();
|
||||
for(int i = 0; i < values.length; i++) {
|
||||
assertTrue("Empty map must not contain value",
|
||||
!map.containsValue(values[i]));
|
||||
for (Object value : values) {
|
||||
assertTrue("Empty map must not contain value", !map.containsValue(value));
|
||||
}
|
||||
verifyAll();
|
||||
|
||||
resetFull();
|
||||
for(int i = 0; i < values.length; i++) {
|
||||
assertTrue("Map must contain value for a mapping in the map.",
|
||||
map.containsValue(values[i]));
|
||||
for (Object value : values) {
|
||||
assertTrue("Map must contain value for a mapping in the map.", map.containsValue(value));
|
||||
}
|
||||
verifyAll();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Tests Map.equals(Object)
|
||||
*/
|
||||
@ -646,12 +616,10 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
|
||||
resetFull();
|
||||
assertTrue("equals(null) returned true.", !map.equals(null));
|
||||
assertTrue("equals(new Object()) returned true.",
|
||||
!map.equals(new Object()));
|
||||
assertTrue("equals(new Object()) returned true.", !map.equals(new Object()));
|
||||
verifyAll();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Tests Map.get(Object)
|
||||
*/
|
||||
@ -661,16 +629,15 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
Object[] keys = getSampleKeys();
|
||||
Object[] values = getSampleValues();
|
||||
|
||||
for (int i = 0; i < keys.length; i++) {
|
||||
assertTrue("Empty map.get() should return null.",
|
||||
map.get(keys[i]) == null);
|
||||
for (Object key : keys) {
|
||||
assertTrue("Empty map.get() should return null.", map.get(key) == null);
|
||||
}
|
||||
|
||||
verifyAll();
|
||||
|
||||
resetFull();
|
||||
for (int i = 0; i < keys.length; i++) {
|
||||
assertEquals("Full map.get() should return value from mapping.",
|
||||
values[i], map.get(keys[i]));
|
||||
assertEquals("Full map.get() should return value from mapping.", values[i], map.get(keys[i]));
|
||||
}
|
||||
}
|
||||
|
||||
@ -679,12 +646,10 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
*/
|
||||
public void testMapHashCode() {
|
||||
resetEmpty();
|
||||
assertTrue("Empty maps have different hashCodes.",
|
||||
map.hashCode() == confirmed.hashCode());
|
||||
assertTrue("Empty maps have different hashCodes.", map.hashCode() == confirmed.hashCode());
|
||||
|
||||
resetFull();
|
||||
assertTrue("Equal maps have different hashCodes.",
|
||||
map.hashCode() == confirmed.hashCode());
|
||||
assertTrue("Equal maps have different hashCodes.", map.hashCode() == confirmed.hashCode());
|
||||
}
|
||||
|
||||
/**
|
||||
@ -698,17 +663,14 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
*/
|
||||
public void testMapToString() {
|
||||
resetEmpty();
|
||||
assertTrue("Empty map toString() should not return null",
|
||||
map.toString() != null);
|
||||
assertTrue("Empty map toString() should not return null", map.toString() != null);
|
||||
verifyAll();
|
||||
|
||||
resetFull();
|
||||
assertTrue("Empty map toString() should not return null",
|
||||
map.toString() != null);
|
||||
assertTrue("Empty map toString() should not return null", map.toString() != null);
|
||||
verifyAll();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Compare the current serialized form of the Map
|
||||
* against the canonical version in CVS.
|
||||
@ -792,22 +754,28 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
!map.containsValue(values[i]));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
try {
|
||||
// two possible exception here, either valid
|
||||
map.put(keys[0], newValues[0]);
|
||||
fail("Expected IllegalArgumentException or UnsupportedOperationException on put (change)");
|
||||
} catch (IllegalArgumentException ex) {
|
||||
} catch (UnsupportedOperationException ex) {}
|
||||
}
|
||||
|
||||
} else if (isPutChangeSupported()) {
|
||||
catch (IllegalArgumentException ex) {
|
||||
}
|
||||
catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (isPutChangeSupported()) {
|
||||
resetEmpty();
|
||||
try {
|
||||
map.put(keys[0], values[0]);
|
||||
fail("Expected UnsupportedOperationException or IllegalArgumentException on put (add) when fixed size");
|
||||
} catch (IllegalArgumentException ex) {
|
||||
} catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
catch (IllegalArgumentException ex) {
|
||||
}
|
||||
catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
|
||||
resetFull();
|
||||
@ -831,11 +799,14 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
!map.containsValue(values[i]));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
try {
|
||||
map.put(keys[0], values[0]);
|
||||
fail("Expected UnsupportedOperationException on put (add)");
|
||||
} catch (UnsupportedOperationException ex) {}
|
||||
}
|
||||
catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -849,12 +820,16 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
if (isPutAddSupported()) {
|
||||
if (isAllowNullKey()) {
|
||||
map.put(null, values[0]);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
try {
|
||||
map.put(null, values[0]);
|
||||
fail("put(null, value) should throw NPE/IAE");
|
||||
} catch (NullPointerException ex) {
|
||||
} catch (IllegalArgumentException ex) {}
|
||||
}
|
||||
catch (NullPointerException ex) {
|
||||
}
|
||||
catch (IllegalArgumentException ex) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -869,12 +844,16 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
if (isPutAddSupported()) {
|
||||
if (isAllowNullValue()) {
|
||||
map.put(keys[0], null);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
try {
|
||||
map.put(keys[0], null);
|
||||
fail("put(key, null) should throw NPE/IAE");
|
||||
} catch (NullPointerException ex) {
|
||||
} catch (IllegalArgumentException ex) {}
|
||||
}
|
||||
catch (NullPointerException ex) {
|
||||
}
|
||||
catch (IllegalArgumentException ex) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -890,7 +869,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
try {
|
||||
map.putAll(temp);
|
||||
fail("Expected UnsupportedOperationException on putAll");
|
||||
} catch (UnsupportedOperationException ex) {}
|
||||
}
|
||||
catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
@ -926,7 +907,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
resetFull();
|
||||
map.remove(map.keySet().iterator().next());
|
||||
fail("Expected UnsupportedOperationException on remove");
|
||||
} catch (UnsupportedOperationException ex) {}
|
||||
}
|
||||
catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
@ -966,12 +949,15 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Tests that the {@link Map#values} collection is backed by
|
||||
* the underlying map for clear().
|
||||
*/
|
||||
public void testValuesClearChangesMap() {
|
||||
if (!isRemoveSupported()) return;
|
||||
if (!isRemoveSupported()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// clear values, reflected in map
|
||||
resetFull();
|
||||
@ -997,7 +983,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* the underlying map for clear().
|
||||
*/
|
||||
public void testKeySetClearChangesMap() {
|
||||
if (!isRemoveSupported()) return;
|
||||
if (!isRemoveSupported()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// clear values, reflected in map
|
||||
resetFull();
|
||||
@ -1023,7 +1011,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
* the underlying map for clear().
|
||||
*/
|
||||
public void testEntrySetClearChangesMap() {
|
||||
if (!isRemoveSupported()) return;
|
||||
if (!isRemoveSupported()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// clear values, reflected in map
|
||||
resetFull();
|
||||
@ -1051,6 +1041,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
Map.Entry entry = (Map.Entry) entrySet.iterator().next();
|
||||
assertEquals(true, entrySet.contains(entry));
|
||||
}
|
||||
|
||||
public void testEntrySetContains2() {
|
||||
resetFull();
|
||||
Set entrySet = map.entrySet();
|
||||
@ -1058,6 +1049,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
Map.Entry test = cloneMapEntry(entry);
|
||||
assertEquals(true, entrySet.contains(test));
|
||||
}
|
||||
|
||||
public void testEntrySetContains3() {
|
||||
resetFull();
|
||||
Set entrySet = map.entrySet();
|
||||
@ -1069,7 +1061,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
}
|
||||
|
||||
public void testEntrySetRemove1() {
|
||||
if (!isRemoveSupported()) return;
|
||||
if (!isRemoveSupported()) {
|
||||
return;
|
||||
}
|
||||
resetFull();
|
||||
int size = map.size();
|
||||
Set entrySet = map.entrySet();
|
||||
@ -1080,8 +1074,11 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
assertEquals(false, map.containsKey(key));
|
||||
assertEquals(size - 1, map.size());
|
||||
}
|
||||
|
||||
public void testEntrySetRemove2() {
|
||||
if (!isRemoveSupported()) return;
|
||||
if (!isRemoveSupported()) {
|
||||
return;
|
||||
}
|
||||
resetFull();
|
||||
int size = map.size();
|
||||
Set entrySet = map.entrySet();
|
||||
@ -1093,8 +1090,11 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
assertEquals(false, map.containsKey(key));
|
||||
assertEquals(size - 1, map.size());
|
||||
}
|
||||
|
||||
public void testEntrySetRemove3() {
|
||||
if (!isRemoveSupported()) return;
|
||||
if (!isRemoveSupported()) {
|
||||
return;
|
||||
}
|
||||
resetFull();
|
||||
int size = map.size();
|
||||
Set entrySet = map.entrySet();
|
||||
@ -1110,6 +1110,7 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Tests that the {@link Map#values} collection is backed by
|
||||
* the underlying map by removing from the values collection
|
||||
@ -1135,7 +1136,8 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
while (values.contains(sampleValues[i]) && j < 10000) {
|
||||
try {
|
||||
values.remove(sampleValues[i]);
|
||||
} catch (UnsupportedOperationException e) {
|
||||
}
|
||||
catch (UnsupportedOperationException e) {
|
||||
// if values.remove is unsupported, just skip this test
|
||||
return;
|
||||
}
|
||||
@ -1161,7 +1163,8 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
for (int i = 0; i < sampleKeys.length; i++) {
|
||||
try {
|
||||
keys.remove(sampleKeys[i]);
|
||||
} catch (UnsupportedOperationException e) {
|
||||
}
|
||||
catch (UnsupportedOperationException e) {
|
||||
// if key.remove is unsupported, just skip this test
|
||||
return;
|
||||
}
|
||||
@ -1176,7 +1179,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
// same for EntrySet/KeySet/values's
|
||||
// Iterator.remove, removeAll, retainAll
|
||||
|
||||
|
||||
/**
|
||||
* Utility methods to create an array of Map.Entry objects
|
||||
* out of the given key and value arrays.<P>
|
||||
@ -1195,7 +1197,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Bulk test {@link Map#entrySet()}. This method runs through all of
|
||||
* the tests in {@link SetAbstractTestCase}.
|
||||
@ -1238,13 +1239,16 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
// Collection views don't support add operations.
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean isRemoveSupported() {
|
||||
// Entry set should only support remove if map does
|
||||
return MapAbstractTestCase.this.isRemoveSupported();
|
||||
}
|
||||
|
||||
public boolean isGetStructuralModify() {
|
||||
return MapAbstractTestCase.this.isGetStructuralModify();
|
||||
}
|
||||
|
||||
public boolean isTestSerialization() {
|
||||
return false;
|
||||
}
|
||||
@ -1299,7 +1303,8 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
if (isSetValueSupported() == false) {
|
||||
try {
|
||||
entry1.setValue(newValue1);
|
||||
} catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
catch (UnsupportedOperationException ex) {
|
||||
}
|
||||
return;
|
||||
}
|
||||
@ -1338,7 +1343,8 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
entry = temp;
|
||||
break;
|
||||
}
|
||||
} else if (temp.getKey().equals(key)) {
|
||||
}
|
||||
else if (temp.getKey().equals(key)) {
|
||||
entry = temp;
|
||||
break;
|
||||
}
|
||||
@ -1348,7 +1354,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
}
|
||||
|
||||
public void testMapEntrySetRemoveNonMapEntry() {
|
||||
if (isRemoveSupported() == false) return;
|
||||
if (isRemoveSupported() == false) {
|
||||
return;
|
||||
}
|
||||
resetFull();
|
||||
assertEquals(false, getSet().remove(null));
|
||||
assertEquals(false, getSet().remove(new Object()));
|
||||
@ -1360,7 +1368,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Bulk test {@link Map#keySet()}. This method runs through all of
|
||||
* the tests in {@link SetAbstractTestCase}.
|
||||
@ -1395,12 +1402,15 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
public boolean isNullSupported() {
|
||||
return MapAbstractTestCase.this.isAllowNullKey();
|
||||
}
|
||||
|
||||
public boolean isAddSupported() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean isRemoveSupported() {
|
||||
return MapAbstractTestCase.this.isRemoveSupported();
|
||||
}
|
||||
|
||||
public boolean isTestSerialization() {
|
||||
return false;
|
||||
}
|
||||
@ -1423,7 +1433,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Bulk test {@link Map#values()}. This method runs through all of
|
||||
* the tests in {@link CollectionAbstractTestCase}.
|
||||
@ -1459,12 +1468,15 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
public boolean isNullSupported() {
|
||||
return MapAbstractTestCase.this.isAllowNullKey();
|
||||
}
|
||||
|
||||
public boolean isAddSupported() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean isRemoveSupported() {
|
||||
return MapAbstractTestCase.this.isRemoveSupported();
|
||||
}
|
||||
|
||||
public boolean isTestSerialization() {
|
||||
return false;
|
||||
}
|
||||
@ -1507,7 +1519,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
// the value equal to the value returned from the values iterator.
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Resets the {@link #map}, {@link #entrySet}, {@link #keySet},
|
||||
* {@link #values} and {@link #confirmed} fields to empty.
|
||||
@ -1533,7 +1544,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Resets the collection view fields.
|
||||
*/
|
||||
@ -1543,7 +1553,6 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
this.entrySet = map.entrySet();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Verifies that {@link #map} is still equal to {@link #confirmed}.
|
||||
* This method checks that the map is equal to the HashMap,
|
||||
@ -1564,12 +1573,9 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
public void verifyMap() {
|
||||
int size = confirmed.size();
|
||||
boolean empty = confirmed.isEmpty();
|
||||
assertEquals("Map should be same size as HashMap",
|
||||
size, map.size());
|
||||
assertEquals("Map should be empty if HashMap is",
|
||||
empty, map.isEmpty());
|
||||
assertEquals("hashCodes should be the same",
|
||||
confirmed.hashCode(), map.hashCode());
|
||||
assertEquals("Map should be same size as HashMap", size, map.size());
|
||||
assertEquals("Map should be empty if HashMap is", empty, map.isEmpty());
|
||||
assertEquals("hashCodes should be the same", confirmed.hashCode(), map.hashCode());
|
||||
// this fails for LRUMap because confirmed.equals() somehow modifies
|
||||
// map, causing concurrent modification exceptions.
|
||||
//assertEquals("Map should still equal HashMap", confirmed, map);
|
||||
@ -1584,39 +1590,29 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
public void verifyEntrySet() {
|
||||
int size = confirmed.size();
|
||||
boolean empty = confirmed.isEmpty();
|
||||
assertEquals("entrySet should be same size as HashMap's" +
|
||||
"\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
assertEquals("entrySet should be same size as HashMap's\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
size, entrySet.size());
|
||||
assertEquals("entrySet should be empty if HashMap is" +
|
||||
"\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
assertEquals("entrySet should be empty if HashMap is\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
empty, entrySet.isEmpty());
|
||||
assertTrue("entrySet should contain all HashMap's elements" +
|
||||
"\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
assertTrue("entrySet should contain all HashMap's elements\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
entrySet.containsAll(confirmed.entrySet()));
|
||||
assertEquals("entrySet hashCodes should be the same" +
|
||||
"\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
assertEquals("entrySet hashCodes should be the same\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
|
||||
confirmed.entrySet().hashCode(), entrySet.hashCode());
|
||||
assertEquals("Map's entry set should still equal HashMap's",
|
||||
confirmed.entrySet(), entrySet);
|
||||
assertEquals("Map's entry set should still equal HashMap's", confirmed.entrySet(), entrySet);
|
||||
}
|
||||
|
||||
public void verifyKeySet() {
|
||||
int size = confirmed.size();
|
||||
boolean empty = confirmed.isEmpty();
|
||||
assertEquals("keySet should be same size as HashMap's" +
|
||||
"\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
assertEquals("keySet should be same size as HashMap's\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
size, keySet.size());
|
||||
assertEquals("keySet should be empty if HashMap is" +
|
||||
"\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
assertEquals("keySet should be empty if HashMap is\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
empty, keySet.isEmpty());
|
||||
assertTrue("keySet should contain all HashMap's elements" +
|
||||
"\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
assertTrue("keySet should contain all HashMap's elements\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
keySet.containsAll(confirmed.keySet()));
|
||||
assertEquals("keySet hashCodes should be the same" +
|
||||
"\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
assertEquals("keySet hashCodes should be the same\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
|
||||
confirmed.keySet().hashCode(), keySet.hashCode());
|
||||
assertEquals("Map's key set should still equal HashMap's",
|
||||
confirmed.keySet(), keySet);
|
||||
assertEquals("Map's key set should still equal HashMap's", confirmed.keySet(), keySet);
|
||||
}
|
||||
|
||||
public void verifyValues() {
|
||||
@ -1625,27 +1621,20 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
|
||||
int size = confirmed.size();
|
||||
boolean empty = confirmed.isEmpty();
|
||||
assertEquals("values should be same size as HashMap's" +
|
||||
"\nTest: " + test + "\nReal: " + known,
|
||||
size, values.size());
|
||||
assertEquals("values should be empty if HashMap is" +
|
||||
"\nTest: " + test + "\nReal: " + known,
|
||||
empty, values.isEmpty());
|
||||
assertTrue("values should contain all HashMap's elements" +
|
||||
"\nTest: " + test + "\nReal: " + known,
|
||||
test.containsAll(known));
|
||||
assertTrue("values should contain all HashMap's elements" +
|
||||
"\nTest: " + test + "\nReal: " + known,
|
||||
known.containsAll(test));
|
||||
// originally coded to use a HashBag, but now separate jar so...
|
||||
for (Iterator it = known.iterator(); it.hasNext();) {
|
||||
boolean removed = test.remove(it.next());
|
||||
|
||||
assertEquals("values should be same size as HashMap's\nTest: " + test + "\nReal: " + known, size, values.size());
|
||||
assertEquals("values should be empty if HashMap is\nTest: " + test + "\nReal: " + known, empty, values.isEmpty());
|
||||
assertTrue("values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known, test.containsAll(known));
|
||||
assertTrue("values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known, known.containsAll(test));
|
||||
|
||||
for (Object aKnown : known) {
|
||||
boolean removed = test.remove(aKnown);
|
||||
assertTrue("Map's values should still equal HashMap's", removed);
|
||||
}
|
||||
|
||||
assertTrue("Map's values should still equal HashMap's", test.isEmpty());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Erases any leftover instance variables by setting them to null.
|
||||
*/
|
||||
@ -1656,5 +1645,4 @@ public abstract class MapAbstractTestCase extends ObjectAbstractTestCase {
|
||||
values = null;
|
||||
confirmed = null;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -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.
|
||||
*
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -81,6 +81,7 @@ public class WMFImageReader extends ImageReaderBase {
|
||||
processReadAborted();
|
||||
return image;
|
||||
}
|
||||
processImageProgress(100f);
|
||||
|
||||
processImageComplete();
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
@ -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());
|
||||
|
||||
@ -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() {
|
||||
|
||||
@ -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 {
|
||||
@Rule
|
||||
public MethodRule rule = new MethodRule() {
|
||||
public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
|
||||
if (JMagickImageReaderSpiSupport.AVAILABLE) {
|
||||
super.runTest();
|
||||
return base;
|
||||
}
|
||||
else {
|
||||
System.err.println("WARNING: JMagick not installed. Skipping test " + getName());
|
||||
|
||||
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());
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@ -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.
|
||||
@ -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)
|
||||
)));
|
||||
}
|
||||
|
||||
@ -16,6 +16,8 @@ import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.io.IOException;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
/**
|
||||
* PSDImageReaderTestCase
|
||||
*
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -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>
|
||||
|
||||
|
||||
@ -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() {
|
||||
|
||||
@ -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 ReturnNewEnumeration(final Collection<T> collection) {
|
||||
this.collection = collection;
|
||||
}
|
||||
|
||||
private static class EnumerationStub extends CustomStub {
|
||||
private List<?> mValues;
|
||||
|
||||
public EnumerationStub(final List<?> pValues) {
|
||||
super("Returns a new enumeration");
|
||||
mValues = pValues;
|
||||
}
|
||||
|
||||
public Object invoke(Invocation invocation) throws Throwable {
|
||||
return Collections.enumeration(mValues);
|
||||
public Enumeration<T> answer(InvocationOnMock invocation) throws Throwable {
|
||||
return Collections.enumeration(collection);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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 ReturnNewEnumeration(final Collection<T> collection) {
|
||||
this.collection = collection;
|
||||
}
|
||||
|
||||
private static class EnumerationStub extends CustomStub {
|
||||
private List<?> mValues;
|
||||
|
||||
public EnumerationStub(final List<?> pValues) {
|
||||
super("Returns a new enumeration");
|
||||
mValues = pValues;
|
||||
}
|
||||
|
||||
public Object invoke(Invocation invocation) throws Throwable {
|
||||
return Collections.enumeration(mValues);
|
||||
public Enumeration<T> answer(InvocationOnMock invocation) throws Throwable {
|
||||
return Collections.enumeration(collection);
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user