Author: bayard Date: Tue Sep 15 05:58:15 2009 New Revision: 815154 URL: http://svn.apache.org/viewvc?rev=815154&view=rev Log: Merging from -r468106:814127 of collections_jdk5_branch - namely where this code was generified; mostly in r738956.
Also see the following revisions: ------------------------------------------------------------------------ r643795 | skestle | 2008-04-02 01:49:57 -0700 (Wed, 02 Apr 2008) | 5 lines Generified EqualPredicate and created individual test class moved from TestPredicateUtils Added assertFalse() and assertTrue to BasicPredicateTestBase with (Predicate, Object) parameters Issues: COLLECTIONS-243, COLLECTIONS-253, COLLECTIONS-293 ------------------------------------------------------------------------ Modified: commons/proper/collections/trunk/src/test/org/apache/commons/collections/TestTransformerUtils.java Modified: commons/proper/collections/trunk/src/test/org/apache/commons/collections/TestTransformerUtils.java URL: http://svn.apache.org/viewvc/commons/proper/collections/trunk/src/test/org/apache/commons/collections/TestTransformerUtils.java?rev=815154&r1=815153&r2=815154&view=diff ============================================================================== --- commons/proper/collections/trunk/src/test/org/apache/commons/collections/TestTransformerUtils.java (original) +++ commons/proper/collections/trunk/src/test/org/apache/commons/collections/TestTransformerUtils.java Tue Sep 15 05:58:15 2009 @@ -29,7 +29,10 @@ import junit.textui.TestRunner; import org.apache.commons.collections.functors.ConstantTransformer; +import org.apache.commons.collections.functors.EqualPredicate; +import org.apache.commons.collections.functors.FalsePredicate; import org.apache.commons.collections.functors.NOPTransformer; +import org.apache.commons.collections.functors.TruePredicate; /** * Tests the org.apache.commons.collections.TransformerUtils class. @@ -56,7 +59,7 @@ /** * Main. * @param args - */ + */ public static void main(String[] args) { TestRunner.run(suite()); } @@ -97,7 +100,7 @@ } fail(); } - + // nullTransformer //------------------------------------------------------------------ @@ -152,10 +155,10 @@ //------------------------------------------------------------------ public void testMapTransformer() { - Map map = new HashMap(); - map.put(null, new Integer(0)); - map.put(cObject, new Integer(1)); - map.put(cString, new Integer(2)); + Map<Object, Integer> map = new HashMap<Object, Integer>(); + map.put(null, 0); + map.put(cObject, 1); + map.put(cString, 2); assertEquals(new Integer(0), TransformerUtils.mapTransformer(map).transform(null)); assertEquals(new Integer(1), TransformerUtils.mapTransformer(map).transform(cObject)); assertEquals(new Integer(2), TransformerUtils.mapTransformer(map).transform(cString)); @@ -172,7 +175,7 @@ assertEquals(cString, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cString)); assertEquals(cInteger, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cInteger)); try { - TransformerUtils.asTransformer((Closure) null); + TransformerUtils.asTransformer((Closure<Object>) null); } catch (IllegalArgumentException ex) { return; } @@ -183,12 +186,12 @@ //------------------------------------------------------------------ public void testPredicateTransformer() { - assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(null)); - assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(cObject)); - assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(cString)); - assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(cInteger)); + assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(null)); + assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(cObject)); + assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(cString)); + assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(TruePredicate.truePredicate()).transform(cInteger)); try { - TransformerUtils.asTransformer((Predicate) null); + TransformerUtils.asTransformer((Predicate<Object>) null); } catch (IllegalArgumentException ex) { return; } @@ -204,7 +207,7 @@ assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cString)); assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cInteger)); try { - TransformerUtils.asTransformer((Factory) null); + TransformerUtils.asTransformer((Factory<Object>) null); } catch (IllegalArgumentException ex) { return; } @@ -214,21 +217,22 @@ // chainedTransformer //------------------------------------------------------------------ + @SuppressWarnings("unchecked") public void testChainedTransformer() { - Transformer a = TransformerUtils.constantTransformer("A"); - Transformer b = TransformerUtils.constantTransformer("B"); - + Transformer<Object, Object> a = TransformerUtils.<Object, Object>constantTransformer("A"); + Transformer<Object, Object> b = TransformerUtils.constantTransformer((Object) "B"); + assertEquals("A", TransformerUtils.chainedTransformer(b, a).transform(null)); assertEquals("B", TransformerUtils.chainedTransformer(a, b).transform(null)); - assertEquals("A", TransformerUtils.chainedTransformer(new Transformer[] {b, a}).transform(null)); - Collection coll = new ArrayList(); + assertEquals("A", TransformerUtils.chainedTransformer(new Transformer[] { b, a }).transform(null)); + Collection<Transformer<Object, Object>> coll = new ArrayList<Transformer<Object, Object>>(); coll.add(b); coll.add(a); assertEquals("A", TransformerUtils.chainedTransformer(coll).transform(null)); assertSame(NOPTransformer.INSTANCE, TransformerUtils.chainedTransformer(new Transformer[0])); - assertSame(NOPTransformer.INSTANCE, TransformerUtils.chainedTransformer(Collections.EMPTY_LIST)); - + assertSame(NOPTransformer.INSTANCE, TransformerUtils.chainedTransformer(Collections.<Transformer<Object, Object>>emptyList())); + try { TransformerUtils.chainedTransformer(null, null); fail(); @@ -238,7 +242,7 @@ fail(); } catch (IllegalArgumentException ex) {} try { - TransformerUtils.chainedTransformer((Collection) null); + TransformerUtils.chainedTransformer((Collection<Transformer<Object, Object>>) null); fail(); } catch (IllegalArgumentException ex) {} try { @@ -246,54 +250,55 @@ fail(); } catch (IllegalArgumentException ex) {} try { - coll = new ArrayList(); + coll = new ArrayList<Transformer<Object, Object>>(); coll.add(null); coll.add(null); TransformerUtils.chainedTransformer(coll); fail(); } catch (IllegalArgumentException ex) {} } - + // switchTransformer //------------------------------------------------------------------ + @SuppressWarnings("unchecked") public void testSwitchTransformer() { - Transformer a = TransformerUtils.constantTransformer("A"); - Transformer b = TransformerUtils.constantTransformer("B"); - Transformer c = TransformerUtils.constantTransformer("C"); - - assertEquals("A", TransformerUtils.switchTransformer(PredicateUtils.truePredicate(), a, b).transform(null)); - assertEquals("B", TransformerUtils.switchTransformer(PredicateUtils.falsePredicate(), a, b).transform(null)); - - assertEquals(null, TransformerUtils.switchTransformer( - new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, - new Transformer[] {a, b}).transform("WELL")); + Transformer<String, String> a = TransformerUtils.constantTransformer("A"); + Transformer<String, String> b = TransformerUtils.constantTransformer("B"); + Transformer<String, String> c = TransformerUtils.constantTransformer("C"); + + assertEquals("A", TransformerUtils.switchTransformer(TruePredicate.truePredicate(), a, b).transform(null)); + assertEquals("B", TransformerUtils.switchTransformer(FalsePredicate.falsePredicate(), a, b).transform(null)); + + assertEquals(null, TransformerUtils.<Object, String>switchTransformer( + new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") }, + new Transformer[] { a, b }).transform("WELL")); assertEquals("A", TransformerUtils.switchTransformer( - new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, - new Transformer[] {a, b}).transform("HELLO")); + new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") }, + new Transformer[] { a, b }).transform("HELLO")); assertEquals("B", TransformerUtils.switchTransformer( - new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, - new Transformer[] {a, b}).transform("THERE")); - + new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") }, + new Transformer[] { a, b }).transform("THERE")); + assertEquals("C", TransformerUtils.switchTransformer( - new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, - new Transformer[] {a, b}, c).transform("WELL")); - - Map map = new HashMap(); - map.put(PredicateUtils.equalPredicate("HELLO"), a); - map.put(PredicateUtils.equalPredicate("THERE"), b); + new Predicate[] { EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE") }, + new Transformer[] { a, b }, c).transform("WELL")); + + Map<Predicate<String>, Transformer<String, String>> map = new HashMap<Predicate<String>, Transformer<String,String>>(); + map.put(EqualPredicate.equalPredicate("HELLO"), a); + map.put(EqualPredicate.equalPredicate("THERE"), b); assertEquals(null, TransformerUtils.switchTransformer(map).transform("WELL")); assertEquals("A", TransformerUtils.switchTransformer(map).transform("HELLO")); assertEquals("B", TransformerUtils.switchTransformer(map).transform("THERE")); map.put(null, c); assertEquals("C", TransformerUtils.switchTransformer(map).transform("WELL")); - assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new Predicate[0], new Transformer[0])); - assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new HashMap())); - map = new HashMap(); + assertEquals(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new Predicate[0], new Transformer[0])); + assertEquals(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new HashMap<Predicate<Object>, Transformer<Object, Object>>())); + map = new HashMap<Predicate<String>, Transformer<String, String>>(); map.put(null, null); - assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(map)); - + assertEquals(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(map)); + try { TransformerUtils.switchTransformer(null, null); fail(); @@ -303,7 +308,7 @@ fail(); } catch (IllegalArgumentException ex) {} try { - TransformerUtils.switchTransformer((Map) null); + TransformerUtils.switchTransformer((Map<Predicate<Object>, Transformer<Object, Object>>) null); fail(); } catch (IllegalArgumentException ex) {} try { @@ -312,21 +317,21 @@ } catch (IllegalArgumentException ex) {} try { TransformerUtils.switchTransformer( - new Predicate[] {PredicateUtils.truePredicate()}, - new Transformer[] {a,b}); + new Predicate[] { TruePredicate.truePredicate() }, + new Transformer[] { a, b }); fail(); } catch (IllegalArgumentException ex) {} } - + // switchMapTransformer //------------------------------------------------------------------ public void testSwitchMapTransformer() { - Transformer a = TransformerUtils.constantTransformer("A"); - Transformer b = TransformerUtils.constantTransformer("B"); - Transformer c = TransformerUtils.constantTransformer("C"); - - Map map = new HashMap(); + Transformer<String, String> a = TransformerUtils.constantTransformer("A"); + Transformer<String, String> b = TransformerUtils.constantTransformer("B"); + Transformer<String, String> c = TransformerUtils.constantTransformer("C"); + + Map<String, Transformer<String, String>> map = new HashMap<String, Transformer<String,String>>(); map.put("HELLO", a); map.put("THERE", b); assertEquals(null, TransformerUtils.switchMapTransformer(map).transform("WELL")); @@ -335,22 +340,22 @@ map.put(null, c); assertEquals("C", TransformerUtils.switchMapTransformer(map).transform("WELL")); - assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchMapTransformer(new HashMap())); - map = new HashMap(); + assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchMapTransformer(new HashMap<Object, Transformer<Object, Object>>())); + map = new HashMap<String, Transformer<String, String>>(); map.put(null, null); assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchMapTransformer(map)); - + try { TransformerUtils.switchMapTransformer(null); fail(); } catch (IllegalArgumentException ex) {} } - + // invokerTransformer //------------------------------------------------------------------ public void testInvokerTransformer() { - List list = new ArrayList(); + List<Object> list = new ArrayList<Object>(); assertEquals(new Integer(0), TransformerUtils.invokerTransformer("size").transform(list)); list.add(new Object()); assertEquals(new Integer(1), TransformerUtils.invokerTransformer("size").transform(list)); @@ -365,27 +370,27 @@ fail(); } catch (FunctorException ex) {} } - + // invokerTransformer2 //------------------------------------------------------------------ public void testInvokerTransformer2() { - List list = new ArrayList(); - assertEquals(Boolean.FALSE, TransformerUtils.invokerTransformer( - "contains", new Class[] {Object.class}, new Object[] {cString}).transform(list)); + List<Object> list = new ArrayList<Object>(); + assertEquals(Boolean.FALSE, TransformerUtils.invokerTransformer("contains", + new Class[] { Object.class }, new Object[] { cString }).transform(list)); list.add(cString); - assertEquals(Boolean.TRUE, TransformerUtils.invokerTransformer( - "contains", new Class[] {Object.class}, new Object[] {cString}).transform(list)); - assertEquals(null, TransformerUtils.invokerTransformer( - "contains", new Class[] {Object.class}, new Object[] {cString}).transform(null)); + assertEquals(Boolean.TRUE, TransformerUtils.invokerTransformer("contains", + new Class[] { Object.class }, new Object[] { cString }).transform(list)); + assertEquals(null, TransformerUtils.invokerTransformer("contains", + new Class[] { Object.class }, new Object[] { cString }).transform(null)); try { TransformerUtils.invokerTransformer(null, null, null); fail(); } catch (IllegalArgumentException ex) {} try { - TransformerUtils.invokerTransformer( - "noSuchMethod", new Class[] {Object.class}, new Object[] {cString}).transform(new Object()); + TransformerUtils.invokerTransformer("noSuchMethod", new Class[] { Object.class }, + new Object[] { cString }).transform(new Object()); fail(); } catch (FunctorException ex) {} try { @@ -393,7 +398,7 @@ fail(); } catch (IllegalArgumentException ex) {} try { - TransformerUtils.invokerTransformer("badArgs", new Class[] {Object.class}, null); + TransformerUtils.invokerTransformer("badArgs", new Class[] { Object.class }, null); fail(); } catch (IllegalArgumentException ex) {} try { @@ -401,10 +406,10 @@ fail(); } catch (IllegalArgumentException ex) {} } - + // stringValueTransformer //------------------------------------------------------------------ - + public void testStringValueTransformer() { assertNotNull( "StringValueTransformer should NEVER return a null value.", TransformerUtils.stringValueTransformer().transform(null)); @@ -413,30 +418,30 @@ assertEquals( "StringValueTransformer should return toString value", "6", TransformerUtils.stringValueTransformer().transform(new Integer(6))); } - + // instantiateFactory //------------------------------------------------------------------ - + public void testInstantiateTransformerNull() { try { - Transformer trans = TransformerUtils.instantiateTransformer(null, new Object[] {"str"}); + TransformerUtils.instantiateTransformer(null, new Object[] { "str" }); fail(); } catch (IllegalArgumentException ex) {} try { - Transformer trans = TransformerUtils.instantiateTransformer(new Class[] {}, new Object[] {"str"}); + TransformerUtils.instantiateTransformer(new Class[] {}, new Object[] { "str" }); fail(); } catch (IllegalArgumentException ex) {} - - Transformer trans = TransformerUtils.instantiateTransformer(new Class[] {Long.class}, new Object[] {null}); + + Transformer<Class<?>, Object> trans = TransformerUtils.instantiateTransformer(new Class[] { Long.class }, new Object[] { null }); try { trans.transform(String.class); fail(); } catch (FunctorException ex) {} - + trans = TransformerUtils.instantiateTransformer(); assertEquals("", trans.transform(String.class)); - - trans = TransformerUtils.instantiateTransformer(new Class[] {Long.TYPE}, new Object[] {new Long(1000L)}); + + trans = TransformerUtils.instantiateTransformer(new Class[] { Long.TYPE }, new Object[] { new Long(1000L) }); assertEquals(new Date(1000L), trans.transform(Date.class)); }