You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by mb...@apache.org on 2009/01/29 19:48:47 UTC

svn commit: r738956 [19/34] - in /commons/proper/collections/branches/collections_jdk5_branch/src: java/org/apache/commons/collections/ java/org/apache/commons/collections/bag/ java/org/apache/commons/collections/bidimap/ java/org/apache/commons/collec...

Modified: commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestMapUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestMapUtils.java?rev=738956&r1=738955&r2=738956&view=diff
==============================================================================
--- commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestMapUtils.java (original)
+++ commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestMapUtils.java Thu Jan 29 18:48:37 2009
@@ -51,13 +51,12 @@
         super(name);
     }
 
-
     public static Test suite() {
         return BulkTest.makeSuite(TestMapUtils.class);
     }
 
-    public Predicate getPredicate() {
-        return new Predicate() {
+    public Predicate<Object> getPredicate() {
+        return new Predicate<Object>() {
             public boolean evaluate(Object o) {
                 return o instanceof String;
             }
@@ -65,10 +64,9 @@
     }
 
     public void testPredicatedMap() {
-        Predicate p = getPredicate();
-        Map map = MapUtils.predicatedMap(new HashMap(), p, p);
-        assertTrue("returned object should be a PredicatedMap",
-            map instanceof PredicatedMap);
+        Predicate<Object> p = getPredicate();
+        Map<Object, Object> map = MapUtils.predicatedMap(new HashMap<Object, Object>(), p, p);
+        assertTrue("returned object should be a PredicatedMap", map instanceof PredicatedMap);
         try {
             map = MapUtils.predicatedMap(null, p, p);
             fail("Expecting IllegalArgumentException for null map.");
@@ -78,32 +76,32 @@
     }
 
     public void testLazyMapFactory() {
-        Factory factory = FactoryUtils.constantFactory(new Integer(5));
-        Map map = MapUtils.lazyMap(new HashMap(), factory);
+        Factory<Integer> factory = FactoryUtils.constantFactory(new Integer(5));
+        Map<Object, Object> map = MapUtils.lazyMap(new HashMap<Object, Object>(), factory);
         assertTrue(map instanceof LazyMap);
         try {
-            map = MapUtils.lazyMap(new HashMap(), (Factory) null);
+            map = MapUtils.lazyMap(new HashMap<Object, Object>(), (Factory<Object>) null);
             fail("Expecting IllegalArgumentException for null factory");
         } catch (IllegalArgumentException e) {
             // expected
         }
         try {
-            map = MapUtils.lazyMap(null, factory);
+            map = MapUtils.lazyMap((Map<Object, Object>) null, factory);
             fail("Expecting IllegalArgumentException for null map");
         } catch (IllegalArgumentException e) {
             // expected
         }
-        Transformer transformer = TransformerUtils.asTransformer(factory);
-        map = MapUtils.lazyMap(new HashMap(), transformer);
+        Transformer<Object, Integer> transformer = TransformerUtils.asTransformer(factory);
+        map = MapUtils.lazyMap(new HashMap<Object, Object>(), transformer);
         assertTrue(map instanceof LazyMap);
          try {
-            map = MapUtils.lazyMap(new HashMap(), (Transformer) null);
+            map = MapUtils.lazyMap(new HashMap<Object, Object>(), (Transformer<Object, Object>) null);
             fail("Expecting IllegalArgumentException for null transformer");
         } catch (IllegalArgumentException e) {
             // expected
         }
         try {
-            map = MapUtils.lazyMap(null, transformer);
+            map = MapUtils.lazyMap((Map<Object, Object>) null, transformer);
             fail("Expecting IllegalArgumentException for null map");
         } catch (IllegalArgumentException e) {
             // expected
@@ -111,7 +109,7 @@
     }
 
     public void testLazyMapTransformer() {
-        Map map = MapUtils.lazyMap(new HashMap(), new Transformer() {
+        Map<Object, Object> map = MapUtils.lazyMap(new HashMap<Object, Object>(), new Transformer<Object, Object>() {
             public Object transform(Object mapKey) {
                 if (mapKey instanceof String) {
                     return new Integer((String) mapKey);
@@ -131,20 +129,20 @@
     }
 
     public void testInvertMap() {
-        final Map in = new HashMap( 5 , 1 );
-        in.put( "1" , "A" );
-        in.put( "2" , "B" );
-        in.put( "3" , "C" );
-        in.put( "4" , "D" );
-        in.put( "5" , "E" );
+        final Map<String, String> in = new HashMap<String, String>(5, 1);
+        in.put("1", "A");
+        in.put("2", "B");
+        in.put("3", "C");
+        in.put("4", "D");
+        in.put("5", "E");
 
-        final Set inKeySet = new HashSet( in.keySet() );
-        final Set inValSet = new HashSet( in.values() );
+        final Set<String> inKeySet = new HashSet<String>(in.keySet());
+        final Set<String> inValSet = new HashSet<String>(in.values());
 
-        final Map out =  MapUtils.invertMap(in);
+        final Map<String, String> out =  MapUtils.invertMap(in);
 
-        final Set outKeySet = new HashSet( out.keySet() );
-        final Set outValSet = new HashSet( out.values() );
+        final Set<String> outKeySet = new HashSet<String>(out.keySet());
+        final Set<String> outValSet = new HashSet<String>(out.values());
 
         assertTrue( inKeySet.equals( outValSet ));
         assertTrue( inValSet.equals( outKeySet ));
@@ -166,11 +164,11 @@
             fail();
         } catch (NullPointerException ex) {}
 
-        Map test = MapUtils.putAll(new HashMap(), new String[0]);
+        Map<String, String> test = MapUtils.putAll(new HashMap<String, String>(), new String[0]);
         assertEquals(0, test.size());
 
         // sub array
-        test = MapUtils.putAll(new HashMap(), new String[][] {
+        test = MapUtils.putAll(new HashMap<String, String>(), new String[][] {
             {"RED", "#FF0000"},
             {"GREEN", "#00FF00"},
             {"BLUE", "#0000FF"}
@@ -184,7 +182,7 @@
         assertEquals(3, test.size());
 
         try {
-            MapUtils.putAll(new HashMap(), new String[][] {
+            MapUtils.putAll(new HashMap<String, String>(), new String[][] {
                 {"RED", "#FF0000"},
                 null,
                 {"BLUE", "#0000FF"}
@@ -193,7 +191,7 @@
         } catch (IllegalArgumentException ex) {}
 
         try {
-            MapUtils.putAll(new HashMap(), new String[][] {
+            MapUtils.putAll(new HashMap<String, String>(), new String[][] {
                 {"RED", "#FF0000"},
                 {"GREEN"},
                 {"BLUE", "#0000FF"}
@@ -202,7 +200,7 @@
         } catch (IllegalArgumentException ex) {}
 
         try {
-            MapUtils.putAll(new HashMap(), new String[][] {
+            MapUtils.putAll(new HashMap<String, String>(), new String[][] {
                 {"RED", "#FF0000"},
                 {},
                 {"BLUE", "#0000FF"}
@@ -211,7 +209,7 @@
         } catch (IllegalArgumentException ex) {}
 
         // flat array
-        test = MapUtils.putAll(new HashMap(), new String[] {
+        test = MapUtils.putAll(new HashMap<String, String>(), new String[] {
             "RED", "#FF0000",
             "GREEN", "#00FF00",
             "BLUE", "#0000FF"
@@ -224,7 +222,7 @@
         assertEquals("#0000FF", test.get("BLUE"));
         assertEquals(3, test.size());
 
-        test = MapUtils.putAll(new HashMap(), new String[] {
+        test = MapUtils.putAll(new HashMap<String, String>(), new String[] {
             "RED", "#FF0000",
             "GREEN", "#00FF00",
             "BLUE", "#0000FF",
@@ -239,10 +237,10 @@
         assertEquals(3, test.size());
 
         // map entry
-        test = MapUtils.putAll(new HashMap(), new Object[] {
-            new DefaultMapEntry("RED", "#FF0000"),
-            new DefaultMapEntry("GREEN", "#00FF00"),
-            new DefaultMapEntry("BLUE", "#0000FF")
+        test = MapUtils.putAll(new HashMap<String, String>(), new Object[] {
+            new DefaultMapEntry<String, String>("RED", "#FF0000"),
+            new DefaultMapEntry<String, String>("GREEN", "#00FF00"),
+            new DefaultMapEntry<String, String>("BLUE", "#0000FF")
         });
         assertEquals(true, test.containsKey("RED"));
         assertEquals("#FF0000", test.get("RED"));
@@ -253,10 +251,10 @@
         assertEquals(3, test.size());
 
         // key value
-        test = MapUtils.putAll(new HashMap(), new Object[] {
-            new DefaultKeyValue("RED", "#FF0000"),
-            new DefaultKeyValue("GREEN", "#00FF00"),
-            new DefaultKeyValue("BLUE", "#0000FF")
+        test = MapUtils.putAll(new HashMap<String, String>(), new Object[] {
+            new DefaultKeyValue<String, String>("RED", "#FF0000"),
+            new DefaultKeyValue<String, String>("GREEN", "#00FF00"),
+            new DefaultKeyValue<String, String>("BLUE", "#0000FF")
         });
         assertEquals(true, test.containsKey("RED"));
         assertEquals("#FF0000", test.get("RED"));
@@ -268,17 +266,17 @@
     }
 
     public void testConvertResourceBundle() {
-        final Map in = new HashMap( 5 , 1 );
-        in.put( "1" , "A" );
-        in.put( "2" , "B" );
-        in.put( "3" , "C" );
-        in.put( "4" , "D" );
-        in.put( "5" , "E" );
+        final Map<String, String> in = new HashMap<String, String>( 5 , 1 );
+        in.put("1", "A");
+        in.put("2", "B");
+        in.put("3", "C");
+        in.put("4", "D");
+        in.put("5", "E");
 
         ResourceBundle b = new ListResourceBundle() {
             public Object[][] getContents() {
                 final Object[][] contents = new Object[ in.size() ][2];
-                final Iterator i = in.keySet().iterator();
+                final Iterator<String> i = in.keySet().iterator();
                 int n = 0;
                 while ( i.hasNext() ) {
                     final Object key = i.next();
@@ -291,20 +289,19 @@
             }
         };
 
-        final Map out = MapUtils.toMap(b);
+        final Map<String, Object> out = MapUtils.toMap(b);
 
         assertTrue( in.equals(out));
     }
 
     public void testDebugAndVerbosePrintCasting() {
-        final Map inner = new HashMap(2, 1);
-        inner.put( new Integer(2) , "B" );
-        inner.put( new Integer(3) , "C" );
-
-        final Map outer = new HashMap(2, 1);
-        outer.put( new Integer(0) , inner );
-        outer.put( new Integer(1) , "A");
-
+        final Map<Integer, String> inner = new HashMap<Integer, String>(2, 1);
+        inner.put(2, "B");
+        inner.put(3, "C");
+
+        final Map<Integer, Object> outer = new HashMap<Integer, Object>(2, 1);
+        outer.put(0, inner);
+        outer.put(1, "A");
 
         final ByteArrayOutputStream out = new ByteArrayOutputStream();
         final PrintStream outPrint = new PrintStream(out);
@@ -341,10 +338,10 @@
 
         final String INDENT = "    ";
 
-        final Map map = new TreeMap();  // treeMap guarantees order across JDKs for test
-        map.put( new Integer(2) , "B" );
-        map.put( new Integer(3) , "C" );
-        map.put( new Integer(4) , null );
+        final Map<Integer, String> map = new TreeMap<Integer, String>();  // treeMap guarantees order across JDKs for test
+        map.put(2, "B");
+        map.put(3, "C");
+        map.put(4, null);
 
         outPrint.println("{");
         outPrint.println(INDENT + "2 = B");
@@ -364,10 +361,10 @@
 
         final String INDENT = "    ";
 
-        final Map map = new TreeMap();  // treeMap guarantees order across JDKs for test
-        map.put( new Integer(2) , "B" );
-        map.put( new Integer(3) , "C" );
-        map.put( new Integer(4) , null );
+        final Map<Integer, String> map = new TreeMap<Integer, String>();  // treeMap guarantees order across JDKs for test
+        map.put(2, "B");
+        map.put(3, "C");
+        map.put(4, null);
 
         outPrint.println("{");
         outPrint.println(INDENT + "2 = B " + String.class.getName());
@@ -407,7 +404,7 @@
 
     public void testVerbosePrintNullStream() {
         try {
-            MapUtils.verbosePrint(null, "Map", new HashMap());
+            MapUtils.verbosePrint(null, "Map", new HashMap<Object, Object>());
             fail("Should generate NullPointerException");
         } catch (NullPointerException expected) {
         }
@@ -415,7 +412,7 @@
 
     public void testDebugPrintNullStream() {
         try {
-            MapUtils.debugPrint(null, "Map", new HashMap());
+            MapUtils.debugPrint(null, "Map", new HashMap<Object, Object>());
             fail("Should generate NullPointerException");
         } catch (NullPointerException expected) {
         }
@@ -427,8 +424,8 @@
 
         final String INDENT = "    ";
 
-        final Map map = new HashMap();
-        map.put( null , "A" );
+        final Map<Object, String> map = new HashMap<Object, String>();
+        map.put(null, "A");
 
         outPrint.println("{");
         outPrint.println(INDENT + "null = A " + String.class.getName());
@@ -446,8 +443,8 @@
 
         final String INDENT = "    ";
 
-        final Map map = new HashMap();
-        map.put( null , "A" );
+        final Map<Object, String> map = new HashMap<Object, String>();
+        map.put(null, "A");
 
         outPrint.println("{");
         outPrint.println(INDENT + "null = A");
@@ -465,8 +462,8 @@
 
         final String INDENT = "    ";
 
-        final Map map = new HashMap();
-        map.put( null , map );
+        final Map<Object, Map<?, ?>> map = new HashMap<Object, Map<?, ?>>();
+        map.put(null, map);
 
         outPrint.println("{");
         outPrint.println(INDENT + "null = (this Map) " + HashMap.class.getName());
@@ -484,8 +481,8 @@
 
         final String INDENT = "    ";
 
-        final Map map = new HashMap();
-        map.put( null , map );
+        final Map<Object, Map<?, ?>> map = new HashMap<Object, Map<?, ?>>();
+        map.put(null, map);
 
         outPrint.println("{");
         outPrint.println(INDENT + "null = (this Map)");
@@ -503,10 +500,10 @@
 
         final String INDENT = "    ";
 
-        final Map map = new HashMap();
-        final Map map2= new HashMap();
-        map.put( null , map2 );
-        map2.put( "2", "B" );
+        final Map<Object, Object> map = new HashMap<Object, Object>();
+        final Map<Object, Object> map2= new HashMap<Object, Object>();
+        map.put(null, map2);
+        map2.put("2", "B");
 
         outPrint.println("{");
         outPrint.println(INDENT + "null = ");
@@ -527,10 +524,10 @@
 
         final String INDENT = "    ";
 
-        final Map map = new HashMap();
-        final Map map2= new HashMap();
-        map.put( null , map2 );
-        map2.put( "2", "B" );
+        final Map<Object, Object> map = new HashMap<Object, Object>();
+        final Map<Object, Object> map2= new HashMap<Object, Object>();
+        map.put(null, map2);
+        map2.put("2", "B");
 
         outPrint.println("{");
         outPrint.println(INDENT + "null = ");
@@ -567,14 +564,14 @@
 
         out.reset();
 
-        final Map inner = new TreeMap();  // treeMap guarantees order across JDKs for test
-        inner.put( new Integer(2) , "B" );
-        inner.put( new Integer(3) , "C" );
-
-        final Map outer = new TreeMap();
-        outer.put( new Integer(1) , inner );
-        outer.put( new Integer(0) , "A");
-        outer.put( new Integer(7) , outer);
+        final Map<Integer, String> inner = new TreeMap<Integer, String>();  // treeMap guarantees order across JDKs for test
+        inner.put(2, "B");
+        inner.put(3, "C");
+
+        final Map<Integer, Object> outer = new TreeMap<Integer, Object>();
+        outer.put(1, inner);
+        outer.put(0, "A");
+        outer.put(7, outer);
 
         MapUtils.verbosePrint(outPrint, "Print Map", outer);
         assertEquals(EXPECTED_OUT, out.toString());
@@ -602,14 +599,14 @@
 
         out.reset();
 
-        final Map inner = new TreeMap();  // treeMap guarantees order across JDKs for test
-        inner.put( new Integer(2) , "B" );
-        inner.put( new Integer(3) , "C" );
-
-        final Map outer = new TreeMap();
-        outer.put( new Integer(1) , inner );
-        outer.put( new Integer(0) , "A");
-        outer.put( new Integer(7) , outer);
+        final Map<Integer, String> inner = new TreeMap<Integer, String>();  // treeMap guarantees order across JDKs for test
+        inner.put(2, "B");
+        inner.put(3, "C");
+
+        final Map<Integer, Object> outer = new TreeMap<Integer, Object>();
+        outer.put(1, inner);
+        outer.put(0, "A");
+        outer.put(7, outer);
 
         MapUtils.debugPrint(outPrint, "Print Map", outer);
         assertEquals(EXPECTED_OUT, out.toString());
@@ -622,21 +619,20 @@
         final String LABEL = "Print Map";
         final String INDENT = "    ";
 
-
-        final Map grandfather = new TreeMap();// treeMap guarantees order across JDKs for test
-        final Map father = new TreeMap();
-        final Map son    = new TreeMap();
-
-        grandfather.put( new Integer(0), "A" );
-        grandfather.put( new Integer(1), father );
-
-        father.put( new Integer(2), "B" );
-        father.put( new Integer(3), grandfather);
-        father.put( new Integer(4), son);
-
-        son.put( new Integer(5), "C");
-        son.put( new Integer(6), grandfather);
-        son.put( new Integer(7), father);
+        final Map<Integer, Object> grandfather = new TreeMap<Integer, Object>();// treeMap guarantees order across JDKs for test
+        final Map<Integer, Object> father = new TreeMap<Integer, Object>();
+        final Map<Integer, Object> son    = new TreeMap<Integer, Object>();
+
+        grandfather.put(0, "A");
+        grandfather.put(1, father);
+
+        father.put(2, "B");
+        father.put(3, grandfather);
+        father.put(4, son);
+
+        son.put(5, "C");
+        son.put(6, grandfather);
+        son.put(7, father);
 
         outPrint.println(LABEL + " = ");
         outPrint.println("{");
@@ -669,21 +665,20 @@
         final String LABEL = "Print Map";
         final String INDENT = "    ";
 
-
-        final Map grandfather = new TreeMap();// treeMap guarantees order across JDKs for test
-        final Map father = new TreeMap();
-        final Map son    = new TreeMap();
-
-        grandfather.put( new Integer(0), "A" );
-        grandfather.put( new Integer(1), father );
-
-        father.put( new Integer(2), "B" );
-        father.put( new Integer(3), grandfather);
-        father.put( new Integer(4), son);
-
-        son.put( new Integer(5), "C");
-        son.put( new Integer(6), grandfather);
-        son.put( new Integer(7), father);
+        final Map<Integer, Object> grandfather = new TreeMap<Integer, Object>();// treeMap guarantees order across JDKs for test
+        final Map<Integer, Object> father = new TreeMap<Integer, Object>();
+        final Map<Integer, Object> son    = new TreeMap<Integer, Object>();
+
+        grandfather.put(0, "A");
+        grandfather.put(1, father);
+
+        father.put(2, "B");
+        father.put(3, grandfather);
+        father.put(4, son);
+
+        son.put(5, "C");
+        son.put(6, grandfather);
+        son.put(7, father);
 
         outPrint.println(LABEL + " = ");
         outPrint.println("{");
@@ -711,34 +706,34 @@
 
     //-----------------------------------------------------------------------
     public void testIsEmptyWithEmptyMap() {
-        Map map = new HashMap();
+        Map<Object, Object> map = new HashMap<Object, Object>();
         assertEquals(true, MapUtils.isEmpty(map));
     }
 
     public void testIsEmptyWithNonEmptyMap() {
-        Map map = new HashMap();
+        Map<String, String> map = new HashMap<String, String>();
         map.put("item", "value");
         assertEquals(false, MapUtils.isEmpty(map));
     }
 
     public void testIsEmptyWithNull() {
-        Map map = null;
+        Map<Object, Object> map = null;
         assertEquals(true, MapUtils.isEmpty(map));
     }
 
     public void testIsNotEmptyWithEmptyMap() {
-        Map map = new HashMap();
+        Map<Object, Object> map = new HashMap<Object, Object>();
         assertEquals(false, MapUtils.isNotEmpty(map));
     }
 
     public void testIsNotEmptyWithNonEmptyMap() {
-        Map map = new HashMap();
+        Map<String, String> map = new HashMap<String, String>();
         map.put("item", "value");
         assertEquals(true, MapUtils.isNotEmpty(map));
     }
 
     public void testIsNotEmptyWithNull() {
-        Map map = null;
+        Map<Object, Object> map = null;
         assertEquals(false, MapUtils.isNotEmpty(map));
     }
 

Modified: commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestPredicateUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestPredicateUtils.java?rev=738956&r1=738955&r2=738956&view=diff
==============================================================================
--- commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestPredicateUtils.java (original)
+++ commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestPredicateUtils.java Thu Jan 29 18:48:37 2009
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -30,14 +30,16 @@
 import java.util.List;
 import java.util.Map;
 
+import org.apache.commons.collections.functors.AllPredicate;
 import org.apache.commons.collections.functors.BasicPredicateTestBase;
 import org.apache.commons.collections.functors.EqualPredicate;
+import org.apache.commons.collections.functors.FalsePredicate;
 import org.apache.commons.collections.functors.TruePredicate;
 import org.junit.Test;
 
 /**
  * Tests the org.apache.commons.collections.PredicateUtils class.
- * 
+ *
  * @since Commons Collections 3.0
  * @version $Revision$ $Date$
  *
@@ -74,7 +76,7 @@
         }
         fail();
     }
-    
+
     // notNullPredicate
     //------------------------------------------------------------------
 
@@ -94,8 +96,8 @@
         assertSame(nullPredicate(), PredicateUtils.identityPredicate(null));
         assertNotNull(PredicateUtils.identityPredicate(new Integer(6)));
         assertEquals(false, PredicateUtils.identityPredicate(new Integer(6)).evaluate(null));
-        assertEquals(false, PredicateUtils.identityPredicate(new Integer(6)).evaluate(cObject));
-        assertEquals(false, PredicateUtils.identityPredicate(new Integer(6)).evaluate(cString));
+        assertEquals(false, PredicateUtils.<Object>identityPredicate(new Integer(6)).evaluate(cObject));
+        assertEquals(false, PredicateUtils.<Object>identityPredicate(new Integer(6)).evaluate(cString));
         assertEquals(false, PredicateUtils.identityPredicate(new Integer(6)).evaluate(cInteger));
         assertEquals(true, PredicateUtils.identityPredicate(cInteger).evaluate(cInteger));
     }
@@ -104,37 +106,37 @@
     //------------------------------------------------------------------
 
     @Test public void testTruePredicate() {
-        assertNotNull(PredicateUtils.truePredicate());
-        assertSame(PredicateUtils.truePredicate(), PredicateUtils.truePredicate());
-        assertEquals(true, PredicateUtils.truePredicate().evaluate(null));
-        assertEquals(true, PredicateUtils.truePredicate().evaluate(cObject));
-        assertEquals(true, PredicateUtils.truePredicate().evaluate(cString));
-        assertEquals(true, PredicateUtils.truePredicate().evaluate(cInteger));
+        assertNotNull(TruePredicate.truePredicate());
+        assertSame(TruePredicate.truePredicate(), TruePredicate.truePredicate());
+        assertEquals(true, TruePredicate.truePredicate().evaluate(null));
+        assertEquals(true, TruePredicate.truePredicate().evaluate(cObject));
+        assertEquals(true, TruePredicate.truePredicate().evaluate(cString));
+        assertEquals(true, TruePredicate.truePredicate().evaluate(cInteger));
     }
 
     // falsePredicate
     //------------------------------------------------------------------
 
     @Test public void testFalsePredicate() {
-        assertNotNull(PredicateUtils.falsePredicate());
-        assertSame(PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate());
-        assertEquals(false, PredicateUtils.falsePredicate().evaluate(null));
-        assertEquals(false, PredicateUtils.falsePredicate().evaluate(cObject));
-        assertEquals(false, PredicateUtils.falsePredicate().evaluate(cString));
-        assertEquals(false, PredicateUtils.falsePredicate().evaluate(cInteger));
+        assertNotNull(FalsePredicate.falsePredicate());
+        assertSame(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate());
+        assertEquals(false, FalsePredicate.falsePredicate().evaluate(null));
+        assertEquals(false, FalsePredicate.falsePredicate().evaluate(cObject));
+        assertEquals(false, FalsePredicate.falsePredicate().evaluate(cString));
+        assertEquals(false, FalsePredicate.falsePredicate().evaluate(cInteger));
     }
 
     // notPredicate
     //------------------------------------------------------------------
 
     @Test public void testNotPredicate() {
-        assertNotNull(PredicateUtils.notPredicate(PredicateUtils.truePredicate()));
-        assertEquals(false, PredicateUtils.notPredicate(PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.notPredicate(PredicateUtils.truePredicate()).evaluate(cObject));
-        assertEquals(false, PredicateUtils.notPredicate(PredicateUtils.truePredicate()).evaluate(cString));
-        assertEquals(false, PredicateUtils.notPredicate(PredicateUtils.truePredicate()).evaluate(cInteger));
+        assertNotNull(PredicateUtils.notPredicate(TruePredicate.truePredicate()));
+        assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(cObject));
+        assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(cString));
+        assertEquals(false, PredicateUtils.notPredicate(TruePredicate.truePredicate()).evaluate(cInteger));
     }
-    
+
     @Test public void testNotPredicateEx() {
         try {
             PredicateUtils.notPredicate(null);
@@ -143,15 +145,15 @@
         }
         fail();
     }
-    
+
     // andPredicate
     //------------------------------------------------------------------
 
     @Test public void testAndPredicate() {
-        assertEquals(true, PredicateUtils.andPredicate(PredicateUtils.truePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.andPredicate(PredicateUtils.truePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.andPredicate(PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.andPredicate(PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.andPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.andPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.andPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.andPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
     }
 
     @Test public void testAndPredicateEx() {
@@ -162,113 +164,116 @@
         }
         fail();
     }
-    
+
     // allPredicate
     //------------------------------------------------------------------
 
+    @SuppressWarnings("unchecked")
     @Test public void testAllPredicate() {
-        assertTrue(PredicateUtils.allPredicate(
-            new Predicate[] {}), null);
-        assertEquals(true, PredicateUtils.allPredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.truePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
-        assertEquals(false, PredicateUtils.allPredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
-        assertEquals(false, PredicateUtils.allPredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
-        assertEquals(false, PredicateUtils.allPredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()}).evaluate(null));
-        Collection coll = new ArrayList();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
-        assertEquals(true, PredicateUtils.allPredicate(coll).evaluate(null));
-        coll.clear();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
-        assertEquals(false, PredicateUtils.allPredicate(coll).evaluate(null));
-        coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
-        assertEquals(false, PredicateUtils.allPredicate(coll).evaluate(null));
-        coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        assertEquals(false, PredicateUtils.allPredicate(coll).evaluate(null));
-        coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        assertFalse(PredicateUtils.allPredicate(coll), null);
+        assertTrue(AllPredicate.allPredicate(new Predicate[] {}), null);
+        assertEquals(true, AllPredicate.allPredicate(new Predicate[] {
+                TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate()}).evaluate(null));
+        assertEquals(false, AllPredicate.allPredicate(new Predicate[] {
+                TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
+        assertEquals(false, AllPredicate.allPredicate(new Predicate[] {
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
+        assertEquals(false, AllPredicate.allPredicate(new Predicate[] {
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
+        Collection<Predicate<Object>> coll = new ArrayList<Predicate<Object>>();
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        assertEquals(true, AllPredicate.allPredicate(coll).evaluate(null));
+        coll.clear();
+        coll.add(TruePredicate.truePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
+        assertEquals(false, AllPredicate.allPredicate(coll).evaluate(null));
+        coll.clear();
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
+        assertEquals(false, AllPredicate.allPredicate(coll).evaluate(null));
+        coll.clear();
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        assertEquals(false, AllPredicate.allPredicate(coll).evaluate(null));
+        coll.clear();
+        coll.add(FalsePredicate.falsePredicate());
+        assertFalse(AllPredicate.allPredicate(coll), null);
         coll.clear();
-        coll.add(PredicateUtils.truePredicate());
-        assertTrue(PredicateUtils.allPredicate(coll), null);
+        coll.add(TruePredicate.truePredicate());
+        assertTrue(AllPredicate.allPredicate(coll), null);
         coll.clear();
-        assertTrue(PredicateUtils.allPredicate(coll), null);
+        assertTrue(AllPredicate.allPredicate(coll), null);
     }
 
+    @SuppressWarnings("unchecked")
     @Test public void testAllPredicateEx1() {
         try {
-            PredicateUtils.allPredicate((Predicate[]) null);
+            AllPredicate.allPredicate((Predicate[]) null);
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testAllPredicateEx2() {
         try {
-            PredicateUtils.allPredicate(new Predicate[] {null});
+            AllPredicate.<Object>allPredicate(new Predicate[] { null });
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testAllPredicateEx3() {
         try {
-            PredicateUtils.allPredicate(new Predicate[] {null, null});
+            AllPredicate.allPredicate(new Predicate[] { null, null });
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
     @Test public void testAllPredicateEx4() {
         try {
-            PredicateUtils.allPredicate((Collection) null);
+            AllPredicate.allPredicate((Collection<Predicate<Object>>) null);
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
     @Test public void testAllPredicateEx5() {
-        PredicateUtils.allPredicate(Collections.EMPTY_LIST);
+        AllPredicate.allPredicate(Collections.<Predicate<Object>>emptyList());
     }
-    
+
     @Test public void testAllPredicateEx6() {
         try {
-            Collection coll = new ArrayList();
+            Collection<Predicate<Object>> coll = new ArrayList<Predicate<Object>>();
             coll.add(null);
             coll.add(null);
-            PredicateUtils.allPredicate(coll);
+            AllPredicate.allPredicate(coll);
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
     // orPredicate
     //------------------------------------------------------------------
 
     @Test public void testOrPredicate() {
-        assertEquals(true, PredicateUtils.orPredicate(PredicateUtils.truePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(true, PredicateUtils.orPredicate(PredicateUtils.truePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
-        assertEquals(true, PredicateUtils.orPredicate(PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.orPredicate(PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.orPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.orPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.orPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.orPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
     }
-    
+
     @Test public void testOrPredicateEx() {
         try {
             PredicateUtils.orPredicate(null, null);
@@ -277,51 +282,53 @@
         }
         fail();
     }
-    
+
     // anyPredicate
     //------------------------------------------------------------------
 
+    @SuppressWarnings("unchecked")
     @Test public void testAnyPredicate() {
-        assertFalse(PredicateUtils.anyPredicate(
-            new Predicate[] {}), null);
+        assertFalse(PredicateUtils.anyPredicate(new Predicate[] {}), null);
+
         assertEquals(true, PredicateUtils.anyPredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.truePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate()}).evaluate(null));
         assertEquals(true, PredicateUtils.anyPredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
         assertEquals(true, PredicateUtils.anyPredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
         assertEquals(false, PredicateUtils.anyPredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()}).evaluate(null));
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
         Collection coll = new ArrayList();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(true, PredicateUtils.anyPredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(true, PredicateUtils.anyPredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(true, PredicateUtils.anyPredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
         assertEquals(false, PredicateUtils.anyPredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
         assertFalse(PredicateUtils.anyPredicate(coll), null);
         coll.clear();
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertTrue(PredicateUtils.anyPredicate(coll), null);
         coll.clear();
         assertFalse(PredicateUtils.anyPredicate(coll), null);
     }
 
+    @SuppressWarnings("unchecked")
     @Test public void testAnyPredicateEx1() {
         try {
             PredicateUtils.anyPredicate((Predicate[]) null);
@@ -330,7 +337,8 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testAnyPredicateEx2() {
         try {
             PredicateUtils.anyPredicate(new Predicate[] {null});
@@ -339,7 +347,8 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testAnyPredicateEx3() {
         try {
             PredicateUtils.anyPredicate(new Predicate[] {null, null});
@@ -348,23 +357,23 @@
         }
         fail();
     }
-    
+
     @Test public void testAnyPredicateEx4() {
         try {
-            PredicateUtils.anyPredicate((Collection) null);
+            PredicateUtils.anyPredicate((Collection<Predicate<Object>>) null);
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
     @Test public void testAnyPredicateEx5() {
-        PredicateUtils.anyPredicate(Collections.EMPTY_LIST);
+        PredicateUtils.anyPredicate(Collections.<Predicate<Object>>emptyList());
     }
-    
+
     @Test public void testAnyPredicateEx6() {
         try {
-            Collection coll = new ArrayList();
+            Collection<Predicate<Object>> coll = new ArrayList<Predicate<Object>>();
             coll.add(null);
             coll.add(null);
             PredicateUtils.anyPredicate(coll);
@@ -373,15 +382,15 @@
         }
         fail();
     }
-    
+
     // eitherPredicate
     //------------------------------------------------------------------
 
     @Test public void testEitherPredicate() {
-        assertEquals(false, PredicateUtils.eitherPredicate(PredicateUtils.truePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(true, PredicateUtils.eitherPredicate(PredicateUtils.truePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
-        assertEquals(true, PredicateUtils.eitherPredicate(PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.eitherPredicate(PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.eitherPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.eitherPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.eitherPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.eitherPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
     }
 
     @Test public void testEitherPredicateEx() {
@@ -392,54 +401,56 @@
         }
         fail();
     }
-    
+
     // onePredicate
     //------------------------------------------------------------------
 
+    @SuppressWarnings("unchecked")
     @Test public void testOnePredicate() {
-        assertFalse(PredicateUtils.onePredicate(new Predicate[] {}), null);
+        assertFalse(PredicateUtils.onePredicate((Predicate<Object>[]) new Predicate[] {}), null);
         assertEquals(false, PredicateUtils.onePredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.truePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+            TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate()}).evaluate(null));
         assertEquals(false, PredicateUtils.onePredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
         assertEquals(true, PredicateUtils.onePredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()}).evaluate(null));
+                TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
         assertEquals(true, PredicateUtils.onePredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.truePredicate(), PredicateUtils.falsePredicate()}).evaluate(null));
+                FalsePredicate.falsePredicate(), TruePredicate.truePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
         assertEquals(true, PredicateUtils.onePredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate()}).evaluate(null));
         assertEquals(false, PredicateUtils.onePredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()}).evaluate(null));
-        Collection coll = new ArrayList();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()}).evaluate(null));
+        Collection<Predicate<Object>> coll = new ArrayList<Predicate<Object>>();
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(false, PredicateUtils.onePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(false, PredicateUtils.onePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(true, PredicateUtils.onePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
         assertEquals(false, PredicateUtils.onePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
         assertFalse(PredicateUtils.onePredicate(coll), null);
         coll.clear();
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertTrue(PredicateUtils.onePredicate(coll), null);
         coll.clear();
         assertFalse(PredicateUtils.onePredicate(coll), null);
     }
 
+    @SuppressWarnings("unchecked")
     @Test public void testOnePredicateEx1() {
         try {
             PredicateUtils.onePredicate((Predicate[]) null);
@@ -448,7 +459,8 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testOnePredicateEx2() {
         try {
             PredicateUtils.onePredicate(new Predicate[] {null});
@@ -457,7 +469,8 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testOnePredicateEx3() {
         try {
             PredicateUtils.onePredicate(new Predicate[] {null, null});
@@ -466,7 +479,8 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testOnePredicateEx4() {
         try {
             PredicateUtils.onePredicate((Collection) null);
@@ -475,14 +489,15 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testOnePredicateEx5() {
         PredicateUtils.onePredicate(Collections.EMPTY_LIST);
     }
-    
+
     @Test public void testOnePredicateEx6() {
         try {
-            Collection coll = new ArrayList();
+            Collection<Predicate<Object>> coll = new ArrayList<Predicate<Object>>();
             coll.add(null);
             coll.add(null);
             PredicateUtils.onePredicate(coll);
@@ -491,15 +506,15 @@
         }
         fail();
     }
-    
+
     // neitherPredicate
     //------------------------------------------------------------------
 
     @Test public void testNeitherPredicate() {
-        assertEquals(false, PredicateUtils.neitherPredicate(PredicateUtils.truePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.neitherPredicate(PredicateUtils.truePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
-        assertEquals(false, PredicateUtils.neitherPredicate(PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(true, PredicateUtils.neitherPredicate(PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.neitherPredicate(TruePredicate.truePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.neitherPredicate(TruePredicate.truePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
+        assertEquals(false, PredicateUtils.neitherPredicate(FalsePredicate.falsePredicate(), TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.neitherPredicate(FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate()).evaluate(null));
     }
 
     @Test public void testNeitherPredicateEx() {
@@ -510,50 +525,52 @@
         }
         fail();
     }
-    
+
     // nonePredicate
     //------------------------------------------------------------------
 
+    @SuppressWarnings("unchecked")
     @Test public void testNonePredicate() {
         assertTrue(PredicateUtils.nonePredicate(new Predicate[] {}), null);
         assertEquals(false, PredicateUtils.nonePredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.truePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                TruePredicate.truePredicate(), TruePredicate.truePredicate(), TruePredicate.truePredicate() }).evaluate(null));
         assertEquals(false, PredicateUtils.nonePredicate(new Predicate[] {
-            PredicateUtils.truePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                TruePredicate.truePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate() }).evaluate(null));
         assertEquals(false, PredicateUtils.nonePredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.truePredicate()}).evaluate(null));
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), TruePredicate.truePredicate() }).evaluate(null));
         assertEquals(true, PredicateUtils.nonePredicate(new Predicate[] {
-            PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate(), PredicateUtils.falsePredicate()}).evaluate(null));
-        Collection coll = new ArrayList();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.truePredicate());
+                FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate(), FalsePredicate.falsePredicate() }).evaluate(null));
+        Collection<Predicate<Object>> coll = new ArrayList<Predicate<Object>>();
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(false, PredicateUtils.nonePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.truePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(TruePredicate.truePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(false, PredicateUtils.nonePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertEquals(false, PredicateUtils.nonePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
-        coll.add(PredicateUtils.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
         assertEquals(true, PredicateUtils.nonePredicate(coll).evaluate(null));
         coll.clear();
-        coll.add(PredicateUtils.falsePredicate());
+        coll.add(FalsePredicate.falsePredicate());
         assertTrue(PredicateUtils.nonePredicate(coll), null);
         coll.clear();
-        coll.add(PredicateUtils.truePredicate());
+        coll.add(TruePredicate.truePredicate());
         assertFalse(PredicateUtils.nonePredicate(coll), null);
         coll.clear();
         assertTrue(PredicateUtils.nonePredicate(coll), null);
     }
 
+    @SuppressWarnings("unchecked")
     @Test public void testNonePredicateEx1() {
         try {
             PredicateUtils.nonePredicate((Predicate[]) null);
@@ -562,7 +579,8 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testNonePredicateEx2() {
         try {
             PredicateUtils.nonePredicate(new Predicate[] {null});
@@ -571,7 +589,8 @@
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     @Test public void testNonePredicateEx3() {
         try {
             PredicateUtils.nonePredicate(new Predicate[] {null, null});
@@ -580,23 +599,23 @@
         }
         fail();
     }
-    
+
     @Test public void testNonePredicateEx4() {
         try {
-            PredicateUtils.nonePredicate((Collection) null);
+            PredicateUtils.nonePredicate((Collection<Predicate<Object>>) null);
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
     @Test public void testNonePredicateEx5() {
-        PredicateUtils.nonePredicate(Collections.EMPTY_LIST);
+        PredicateUtils.nonePredicate(Collections.<Predicate<Object>>emptyList());
     }
-    
+
     @Test public void testNonePredicateEx6() {
         try {
-            Collection coll = new ArrayList();
+            Collection<Predicate<Object>> coll = new ArrayList<Predicate<Object>>();
             coll.add(null);
             coll.add(null);
             PredicateUtils.nonePredicate(coll);
@@ -605,7 +624,7 @@
         }
         fail();
     }
-    
+
     // instanceofPredicate
     //------------------------------------------------------------------
 
@@ -621,7 +640,7 @@
     //------------------------------------------------------------------
 
     @Test public void testUniquePredicate() {
-        Predicate p = PredicateUtils.uniquePredicate();
+        Predicate<Object> p = PredicateUtils.uniquePredicate();
         assertEquals(true, p.evaluate(new Object()));
         assertEquals(true, p.evaluate(new Object()));
         assertEquals(true, p.evaluate(new Object()));
@@ -629,13 +648,13 @@
         assertEquals(false, p.evaluate(cString));
         assertEquals(false, p.evaluate(cString));
     }
-    
+
     // asPredicate(Transformer)
     //------------------------------------------------------------------
 
     @Test public void testAsPredicateTransformer() {
-        assertEquals(false, PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(Boolean.FALSE));
-        assertEquals(true, PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(Boolean.TRUE));
+        assertEquals(false, PredicateUtils.asPredicate(TransformerUtils.<Boolean>nopTransformer()).evaluate(false));
+        assertEquals(true, PredicateUtils.asPredicate(TransformerUtils.<Boolean>nopTransformer()).evaluate(true));
     }
 
     @Test public void testAsPredicateTransformerEx1() {
@@ -646,21 +665,21 @@
         }
         fail();
     }
-    
+
     @Test public void testAsPredicateTransformerEx2() {
         try {
-            PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(null);
+            PredicateUtils.asPredicate(TransformerUtils.<Boolean>nopTransformer()).evaluate(null);
         } catch (FunctorException ex) {
             return;
         }
         fail();
     }
-    
+
     // invokerPredicate
     //------------------------------------------------------------------
 
     @Test public void testInvokerPredicate() {
-        List list = new ArrayList();
+        List<Object> list = new ArrayList<Object>();
         assertEquals(true, PredicateUtils.invokerPredicate("isEmpty").evaluate(list));
         list.add(new Object());
         assertEquals(false, PredicateUtils.invokerPredicate("isEmpty").evaluate(list));
@@ -674,7 +693,7 @@
         }
         fail();
     }
-    
+
     @Test public void testInvokerPredicateEx2() {
         try {
             PredicateUtils.invokerPredicate("isEmpty").evaluate(null);
@@ -683,7 +702,7 @@
         }
         fail();
     }
-    
+
     @Test public void testInvokerPredicateEx3() {
         try {
             PredicateUtils.invokerPredicate("noSuchMethod").evaluate(new Object());
@@ -692,12 +711,12 @@
         }
         fail();
     }
-    
+
     // invokerPredicate2
     //------------------------------------------------------------------
 
     @Test public void testInvokerPredicate2() {
-        List list = new ArrayList();
+        List<String> list = new ArrayList<String>();
         assertEquals(false, PredicateUtils.invokerPredicate(
             "contains", new Class[] {Object.class}, new Object[] {cString}).evaluate(list));
         list.add(cString);
@@ -713,7 +732,7 @@
         }
         fail();
     }
-    
+
     @Test public void testInvokerPredicate2Ex2() {
         try {
             PredicateUtils.invokerPredicate("contains", new Class[] {Object.class}, new Object[] {cString}).evaluate(null);
@@ -722,7 +741,7 @@
         }
         fail();
     }
-    
+
     @Test public void testInvokerPredicate2Ex3() {
         try {
             PredicateUtils.invokerPredicate(
@@ -732,14 +751,14 @@
         }
         fail();
     }
-    
+
     // nullIsException
     //------------------------------------------------------------------
 
     @Test public void testNullIsExceptionPredicate() {
-        assertEquals(true, PredicateUtils.nullIsExceptionPredicate(PredicateUtils.truePredicate()).evaluate(new Object()));
+        assertEquals(true, PredicateUtils.nullIsExceptionPredicate(TruePredicate.truePredicate()).evaluate(new Object()));
         try {
-            PredicateUtils.nullIsExceptionPredicate(PredicateUtils.truePredicate()).evaluate(null);
+            PredicateUtils.nullIsExceptionPredicate(TruePredicate.truePredicate()).evaluate(null);
         } catch (FunctorException ex) {
             return;
         }
@@ -754,14 +773,14 @@
         }
         fail();
     }
-    
+
     // nullIsTrue
     //------------------------------------------------------------------
 
     @Test public void testNullIsTruePredicate() {
-        assertEquals(true, PredicateUtils.nullIsTruePredicate(PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(true, PredicateUtils.nullIsTruePredicate(PredicateUtils.truePredicate()).evaluate(new Object()));
-        assertEquals(false, PredicateUtils.nullIsTruePredicate(PredicateUtils.falsePredicate()).evaluate(new Object()));
+        assertEquals(true, PredicateUtils.nullIsTruePredicate(TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.nullIsTruePredicate(TruePredicate.truePredicate()).evaluate(new Object()));
+        assertEquals(false, PredicateUtils.nullIsTruePredicate(FalsePredicate.falsePredicate()).evaluate(new Object()));
     }
 
     @Test public void testNullIsTruePredicateEx1() {
@@ -772,14 +791,14 @@
         }
         fail();
     }
-    
+
     // nullIsFalse
     //------------------------------------------------------------------
 
     @Test public void testNullIsFalsePredicate() {
-        assertEquals(false, PredicateUtils.nullIsFalsePredicate(PredicateUtils.truePredicate()).evaluate(null));
-        assertEquals(true, PredicateUtils.nullIsFalsePredicate(PredicateUtils.truePredicate()).evaluate(new Object()));
-        assertEquals(false, PredicateUtils.nullIsFalsePredicate(PredicateUtils.falsePredicate()).evaluate(new Object()));
+        assertEquals(false, PredicateUtils.nullIsFalsePredicate(TruePredicate.truePredicate()).evaluate(null));
+        assertEquals(true, PredicateUtils.nullIsFalsePredicate(TruePredicate.truePredicate()).evaluate(new Object()));
+        assertEquals(false, PredicateUtils.nullIsFalsePredicate(FalsePredicate.falsePredicate()).evaluate(new Object()));
     }
 
     @Test public void testNullIsFalsePredicateEx1() {
@@ -790,19 +809,19 @@
         }
         fail();
     }
-    
+
     // transformed
     //------------------------------------------------------------------
 
     @Test public void testTransformedPredicate() {
         assertEquals(true, PredicateUtils.transformedPredicate(
                 TransformerUtils.nopTransformer(),
-                PredicateUtils.truePredicate()).evaluate(new Object()));
-                
-        Map map = new HashMap();
+                TruePredicate.truePredicate()).evaluate(new Object()));
+
+        Map<Object, Object> map = new HashMap<Object, Object>();
         map.put(Boolean.TRUE, "Hello");
-        Transformer t = TransformerUtils.mapTransformer(map);
-        Predicate p = EqualPredicate.equalPredicate("Hello");
+        Transformer<Object, Object> t = TransformerUtils.mapTransformer(map);
+        Predicate<Object> p = EqualPredicate.<Object>equalPredicate("Hello");
         assertEquals(false, PredicateUtils.transformedPredicate(t, p).evaluate(null));
         assertEquals(true, PredicateUtils.transformedPredicate(t, p).evaluate(Boolean.TRUE));
         try {

Modified: commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestSetUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestSetUtils.java?rev=738956&r1=738955&r2=738956&view=diff
==============================================================================
--- commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestSetUtils.java (original)
+++ commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestSetUtils.java Thu Jan 29 18:48:37 2009
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -27,9 +27,9 @@
 
 /**
  * Tests for SetUtils.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Stephen Colebourne
  * @author Neil O'Toole
  * @author Matthew Hawthorne
@@ -46,18 +46,17 @@
 
     public void testNothing() {
     }
-    
+
     public void testpredicatedSet() {
-        Predicate predicate = new Predicate() {
+        Predicate<Object> predicate = new Predicate<Object>() {
             public boolean evaluate(Object o) {
                 return o instanceof String;
             }
         };
-        Set set = SetUtils.predicatedSet(new HashSet(), predicate);
-        assertTrue("returned object should be a PredicatedSet",
-            set instanceof PredicatedSet);
+        Set<Object> set = SetUtils.predicatedSet(new HashSet<Object>(), predicate);
+        assertTrue("returned object should be a PredicatedSet", set instanceof PredicatedSet);
         try {
-            set = SetUtils.predicatedSet(new HashSet(), null);
+            set = SetUtils.predicatedSet(new HashSet<Object>(), null);
             fail("Expecting IllegalArgumentException for null predicate.");
         } catch (IllegalArgumentException ex) {
             // expected
@@ -71,11 +70,11 @@
     }
 
     public void testEquals() {
-        Collection data = Arrays.asList( new String[] { "a", "b", "c" });
-        
-        Set a = new HashSet( data );
-        Set b = new HashSet( data );
-        
+        Collection<String> data = Arrays.asList( new String[] { "a", "b", "c" });
+
+        Set<String> a = new HashSet<String>(data);
+        Set<String> b = new HashSet<String>(data);
+
         assertEquals(true, a.equals(b));
         assertEquals(true, SetUtils.isEqualSet(a, b));
         a.clear();
@@ -84,13 +83,13 @@
         assertEquals(false, SetUtils.isEqualSet(null, b));
         assertEquals(true, SetUtils.isEqualSet(null, null));
     }
-    
+
     public void testHashCode() {
-        Collection data = Arrays.asList( new String[] { "a", "b", "c" });
-            
-        Set a = new HashSet( data );
-        Set b = new HashSet( data );
-        
+        Collection<String> data = Arrays.asList( new String[] { "a", "b", "c" });
+
+        Set<String> a = new HashSet<String>(data);
+        Set<String> b = new HashSet<String>(data);
+
         assertEquals(true, a.hashCode() == b.hashCode());
         assertEquals(true, a.hashCode() == SetUtils.hashCodeForSet(a));
         assertEquals(true, b.hashCode() == SetUtils.hashCodeForSet(b));
@@ -98,6 +97,6 @@
         a.clear();
         assertEquals(false, SetUtils.hashCodeForSet(a) == SetUtils.hashCodeForSet(b));
         assertEquals(0, SetUtils.hashCodeForSet(null));
-    }   
+    }
 
 }

Modified: commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTransformerUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTransformerUtils.java?rev=738956&r1=738955&r2=738956&view=diff
==============================================================================
--- commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTransformerUtils.java (original)
+++ commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTransformerUtils.java Thu Jan 29 18:48:37 2009
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -30,11 +30,13 @@
 
 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.
- * 
+ *
  * @since Commons Collections 3.0
  * @version $Revision$ $Date$
  *
@@ -57,7 +59,7 @@
     /**
      * Main.
      * @param args
-     */    
+     */
     public static void main(String[] args) {
         TestRunner.run(suite());
     }
@@ -98,7 +100,7 @@
         }
         fail();
     }
-    
+
     // nullTransformer
     //------------------------------------------------------------------
 
@@ -153,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));
@@ -173,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;
         }
@@ -184,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;
         }
@@ -205,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;
         }
@@ -215,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();
@@ -239,7 +242,7 @@
             fail();
         } catch (IllegalArgumentException ex) {}
         try {
-            TransformerUtils.chainedTransformer((Collection) null);
+            TransformerUtils.chainedTransformer((Collection<Transformer<Object, Object>>) null);
             fail();
         } catch (IllegalArgumentException ex) {}
         try {
@@ -247,40 +250,41 @@
             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[] {EqualPredicate.equalPredicate("HELLO"), EqualPredicate.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[] {EqualPredicate.equalPredicate("HELLO"), EqualPredicate.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[] {EqualPredicate.equalPredicate("HELLO"), EqualPredicate.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[] {EqualPredicate.equalPredicate("HELLO"), EqualPredicate.equalPredicate("THERE")}, 
-            new Transformer[] {a, b}, c).transform("WELL"));
-            
-        Map map = new HashMap();
+            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"));
@@ -289,12 +293,12 @@
         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();
@@ -304,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 {
@@ -313,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"));
@@ -336,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));
@@ -366,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 {
@@ -394,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 {
@@ -402,10 +406,10 @@
             fail();
         } catch (IllegalArgumentException ex) {}
     }
-    
+
     // stringValueTransformer
     //------------------------------------------------------------------
-    
+
     public void testStringValueTransformer() {
         assertNotNull( "StringValueTransformer should NEVER return a null value.",
            TransformerUtils.stringValueTransformer().transform(null));
@@ -414,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));
     }
 

Modified: commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTreeMap.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTreeMap.java?rev=738956&r1=738955&r2=738956&view=diff
==============================================================================
--- commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTreeMap.java (original)
+++ commons/proper/collections/branches/collections_jdk5_branch/src/test/org/apache/commons/collections/TestTreeMap.java Thu Jan 29 18:48:37 2009
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -22,13 +22,13 @@
 
 /**
  * Tests TreeMap.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Jason van Zyl
  */
-public abstract class TestTreeMap extends AbstractTestMap {
-    
+public abstract class TestTreeMap<K, V> extends AbstractTestMap<K, V> {
+
     public TestTreeMap(String testName) {
         super(testName);
     }
@@ -42,21 +42,25 @@
         return false;
     }
 
-    protected TreeMap map = null;
-
-    public void setUp() {
-        map = (TreeMap) makeEmptyMap();
-    }
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public abstract TreeMap<K, V> makeObject();
 
     public void testNewMap() {
+        TreeMap<K, V> map = makeObject();
         assertTrue("New map is empty", map.isEmpty());
         assertEquals("New map has size zero", map.size(), 0);
     }
 
+    @SuppressWarnings("unchecked")
     public void testSearch() {
-        map.put("first", "First Item");
-        map.put("second", "Second Item");
+        TreeMap<K, V> map = makeObject();
+        map.put((K) "first", (V) "First Item");
+        map.put((K) "second", (V) "Second Item");
         assertEquals("Top item is 'Second Item'", map.get("first"), "First Item");
         assertEquals("Next Item is 'First Item'", map.get("second"), "Second Item");
     }
+
 }