http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/TestPredicateUtils.java ---------------------------------------------------------------------- diff --git a/src/test/org/apache/commons/collections/TestPredicateUtils.java b/src/test/org/apache/commons/collections/TestPredicateUtils.java index e8b1e16..e7b7b9e 100644 --- a/src/test/org/apache/commons/collections/TestPredicateUtils.java +++ b/src/test/org/apache/commons/collections/TestPredicateUtils.java @@ -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.HashMap; 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + // notNullPredicate //------------------------------------------------------------------ @@ -94,8 +96,8 @@ public class TestPredicateUtils extends BasicPredicateTestBase { 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { //------------------------------------------------------------------ @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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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)); + 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(PredicateUtils.truePredicate()); - coll.add(PredicateUtils.falsePredicate()); - coll.add(PredicateUtils.truePredicate()); - assertEquals(false, PredicateUtils.allPredicate(coll).evaluate(null)); + coll.add(TruePredicate.truePredicate()); + coll.add(FalsePredicate.falsePredicate()); + coll.add(TruePredicate.truePredicate()); + assertEquals(false, AllPredicate.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.add(FalsePredicate.falsePredicate()); + coll.add(FalsePredicate.falsePredicate()); + coll.add(TruePredicate.truePredicate()); + assertEquals(false, AllPredicate.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.add(FalsePredicate.falsePredicate()); + coll.add(FalsePredicate.falsePredicate()); + coll.add(FalsePredicate.falsePredicate()); + assertEquals(false, AllPredicate.allPredicate(coll).evaluate(null)); coll.clear(); - coll.add(PredicateUtils.falsePredicate()); - assertFalse(PredicateUtils.allPredicate(coll), null); + 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + + @SuppressWarnings("unchecked") @Test public void testAnyPredicateEx2() { try { PredicateUtils.anyPredicate(new Predicate[] {null}); @@ -339,7 +347,8 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + + @SuppressWarnings("unchecked") @Test public void testAnyPredicateEx3() { try { PredicateUtils.anyPredicate(new Predicate[] {null, null}); @@ -348,23 +357,23 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + + @SuppressWarnings("unchecked") @Test public void testOnePredicateEx2() { try { PredicateUtils.onePredicate(new Predicate[] {null}); @@ -457,7 +469,8 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + + @SuppressWarnings("unchecked") @Test public void testOnePredicateEx3() { try { PredicateUtils.onePredicate(new Predicate[] {null, null}); @@ -466,7 +479,8 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + + @SuppressWarnings("unchecked") @Test public void testOnePredicateEx4() { try { PredicateUtils.onePredicate((Collection) null); @@ -475,14 +489,15 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + + @SuppressWarnings("unchecked") @Test public void testNonePredicateEx2() { try { PredicateUtils.nonePredicate(new Predicate[] {null}); @@ -571,7 +589,8 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + + @SuppressWarnings("unchecked") @Test public void testNonePredicateEx3() { try { PredicateUtils.nonePredicate(new Predicate[] {null, null}); @@ -580,23 +599,23 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + // instanceofPredicate //------------------------------------------------------------------ @@ -621,7 +640,7 @@ public class TestPredicateUtils extends BasicPredicateTestBase { //------------------------------------------------------------------ @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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + @Test public void testInvokerPredicateEx2() { try { PredicateUtils.invokerPredicate("isEmpty").evaluate(null); @@ -683,7 +702,7 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + @Test public void testInvokerPredicateEx3() { try { PredicateUtils.invokerPredicate("noSuchMethod").evaluate(new Object()); @@ -692,12 +711,12 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + @Test public void testInvokerPredicate2Ex2() { try { PredicateUtils.invokerPredicate("contains", new Class[] {Object.class}, new Object[] {cString}).evaluate(null); @@ -722,7 +741,7 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } fail(); } - + @Test public void testInvokerPredicate2Ex3() { try { PredicateUtils.invokerPredicate( @@ -732,14 +751,14 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 @@ public class TestPredicateUtils extends BasicPredicateTestBase { } 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 {
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/TestSetUtils.java ---------------------------------------------------------------------- diff --git a/src/test/org/apache/commons/collections/TestSetUtils.java b/src/test/org/apache/commons/collections/TestSetUtils.java index 42d5f13..2b2fdaa 100644 --- a/src/test/org/apache/commons/collections/TestSetUtils.java +++ b/src/test/org/apache/commons/collections/TestSetUtils.java @@ -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 @@ import org.apache.commons.collections.set.PredicatedSet; /** * Tests for SetUtils. - * + * * @version $Revision$ $Date$ - * + * * @author Stephen Colebourne * @author Neil O'Toole * @author Matthew Hawthorne @@ -46,18 +46,17 @@ public class TestSetUtils extends BulkTest { 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 class TestSetUtils extends BulkTest { } 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 @@ public class TestSetUtils extends BulkTest { 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 @@ public class TestSetUtils extends BulkTest { a.clear(); assertEquals(false, SetUtils.hashCodeForSet(a) == SetUtils.hashCodeForSet(b)); assertEquals(0, SetUtils.hashCodeForSet(null)); - } + } } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/TestTransformerUtils.java ---------------------------------------------------------------------- diff --git a/src/test/org/apache/commons/collections/TestTransformerUtils.java b/src/test/org/apache/commons/collections/TestTransformerUtils.java index 75f12ed..0bc2e37 100644 --- a/src/test/org/apache/commons/collections/TestTransformerUtils.java +++ b/src/test/org/apache/commons/collections/TestTransformerUtils.java @@ -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 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. - * + * * @since Commons Collections 3.0 * @version $Revision$ $Date$ * @@ -57,7 +59,7 @@ public class TestTransformerUtils extends junit.framework.TestCase { /** * Main. * @param args - */ + */ public static void main(String[] args) { TestRunner.run(suite()); } @@ -98,7 +100,7 @@ public class TestTransformerUtils extends junit.framework.TestCase { } fail(); } - + // nullTransformer //------------------------------------------------------------------ @@ -153,10 +155,10 @@ public class TestTransformerUtils extends junit.framework.TestCase { //------------------------------------------------------------------ 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 class TestTransformerUtils extends junit.framework.TestCase { //------------------------------------------------------------------ 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { // 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { } 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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 @@ public class TestTransformerUtils extends junit.framework.TestCase { fail(); } catch (IllegalArgumentException ex) {} } - + // stringValueTransformer //------------------------------------------------------------------ - + public void testStringValueTransformer() { assertNotNull( "StringValueTransformer should NEVER return a null value.", TransformerUtils.stringValueTransformer().transform(null)); @@ -414,30 +418,30 @@ public class TestTransformerUtils extends junit.framework.TestCase { 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)); } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/TestTreeMap.java ---------------------------------------------------------------------- diff --git a/src/test/org/apache/commons/collections/TestTreeMap.java b/src/test/org/apache/commons/collections/TestTreeMap.java index 100921b..4e512a4 100644 --- a/src/test/org/apache/commons/collections/TestTreeMap.java +++ b/src/test/org/apache/commons/collections/TestTreeMap.java @@ -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 @@ import org.apache.commons.collections.map.AbstractTestMap; /** * 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 @@ public abstract class TestTreeMap extends AbstractTestMap { 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"); } + } http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/TestTypedCollection.java ---------------------------------------------------------------------- diff --git a/src/test/org/apache/commons/collections/TestTypedCollection.java b/src/test/org/apache/commons/collections/TestTypedCollection.java index 1648893..cd7f96c 100644 --- a/src/test/org/apache/commons/collections/TestTypedCollection.java +++ b/src/test/org/apache/commons/collections/TestTypedCollection.java @@ -27,25 +27,25 @@ import java.util.List; * * @author Stephen Colebourne */ -public abstract class TestTypedCollection extends BulkTest { +public abstract class TestTypedCollection<T> extends BulkTest { public TestTypedCollection(String name) { super(name); } + protected abstract Collection<T> typedCollection(); - protected abstract Collection typedCollection(); - - protected Class getType() { - return String.class; + @SuppressWarnings("unchecked") + protected Class<T> getType() { + return (Class<T>) String.class; } - + @SuppressWarnings("unchecked") public void testIllegalAdd() { - Collection c = typedCollection(); + Collection<T> c = typedCollection(); Integer i = new Integer(3); try { - c.add(i); + c.add((T) i); fail("Integer should fail string predicate."); } catch (IllegalArgumentException e) { // expected @@ -55,15 +55,16 @@ public abstract class TestTypedCollection extends BulkTest { } + @SuppressWarnings("unchecked") public void testIllegalAddAll() { - Collection c = typedCollection(); - List elements = new ArrayList(); + Collection<T> c = typedCollection(); + List<Object> elements = new ArrayList<Object>(); elements.add("one"); elements.add("two"); elements.add(new Integer(3)); elements.add("four"); try { - c.addAll(elements); + c.addAll((Collection<? extends T>) elements); fail("Integer should fail string predicate."); } catch (IllegalArgumentException e) { // expected
