Java tutorial
/* * Copyright 2001-2004 The Apache Software Foundation * * Licensed 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. * See the License for the specific language governing permissions and * limitations under the License. */ package org.enerj.apache.commons.collections; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import junit.framework.Test; import junit.framework.TestSuite; import junit.textui.TestRunner; import org.enerj.apache.commons.collections.functors.ConstantTransformer; import org.enerj.apache.commons.collections.functors.NOPTransformer; /** * Tests the org.apache.commons.collections.TransformerUtils class. * * @since Commons Collections 3.0 * @version $Revision: 155406 $ $Date: 2005-02-26 12:55:26 +0000 (Sat, 26 Feb 2005) $ * * @author Stephen Colebourne * @author James Carman */ public class TestTransformerUtils extends junit.framework.TestCase { private static final Object cObject = new Object(); private static final Object cString = "Hello"; private static final Object cInteger = new Integer(6); /** * Construct */ public TestTransformerUtils(String name) { super(name); } /** * Main. * @param args */ public static void main(String[] args) { TestRunner.run(suite()); } /** * Return class as a test suite. */ public static Test suite() { return new TestSuite(TestTransformerUtils.class); } /** * Set up instance variables required by this test case. */ public void setUp() { } /** * Tear down instance variables required by this test case. */ public void tearDown() { } // exceptionTransformer //------------------------------------------------------------------ public void testExceptionTransformer() { assertNotNull(TransformerUtils.exceptionTransformer()); assertSame(TransformerUtils.exceptionTransformer(), TransformerUtils.exceptionTransformer()); try { TransformerUtils.exceptionTransformer().transform(null); } catch (FunctorException ex) { try { TransformerUtils.exceptionTransformer().transform(cString); } catch (FunctorException ex2) { return; } } fail(); } // nullTransformer //------------------------------------------------------------------ public void testNullTransformer() { assertNotNull(TransformerUtils.nullTransformer()); assertSame(TransformerUtils.nullTransformer(), TransformerUtils.nullTransformer()); assertEquals(null, TransformerUtils.nullTransformer().transform(null)); assertEquals(null, TransformerUtils.nullTransformer().transform(cObject)); assertEquals(null, TransformerUtils.nullTransformer().transform(cString)); assertEquals(null, TransformerUtils.nullTransformer().transform(cInteger)); } // nopTransformer //------------------------------------------------------------------ public void testNopTransformer() { assertNotNull(TransformerUtils.nullTransformer()); assertSame(TransformerUtils.nullTransformer(), TransformerUtils.nullTransformer()); assertEquals(null, TransformerUtils.nopTransformer().transform(null)); assertEquals(cObject, TransformerUtils.nopTransformer().transform(cObject)); assertEquals(cString, TransformerUtils.nopTransformer().transform(cString)); assertEquals(cInteger, TransformerUtils.nopTransformer().transform(cInteger)); } // constantTransformer //------------------------------------------------------------------ public void testConstantTransformer() { assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(null)); assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(cObject)); assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(cString)); assertEquals(cObject, TransformerUtils.constantTransformer(cObject).transform(cInteger)); assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.constantTransformer(null)); } // cloneTransformer //------------------------------------------------------------------ public void testCloneTransformer() { assertEquals(null, TransformerUtils.cloneTransformer().transform(null)); assertEquals(cString, TransformerUtils.cloneTransformer().transform(cString)); assertEquals(cInteger, TransformerUtils.cloneTransformer().transform(cInteger)); try { assertEquals(cObject, TransformerUtils.cloneTransformer().transform(cObject)); } catch (IllegalArgumentException ex) { return; } fail(); } // mapTransformer //------------------------------------------------------------------ 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)); 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)); assertEquals(null, TransformerUtils.mapTransformer(map).transform(cInteger)); assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.mapTransformer(null)); } // commandTransformer //------------------------------------------------------------------ public void testExecutorTransformer() { assertEquals(null, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(null)); assertEquals(cObject, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cObject)); assertEquals(cString, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cString)); assertEquals(cInteger, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cInteger)); try { TransformerUtils.asTransformer((Closure) null); } catch (IllegalArgumentException ex) { return; } fail(); } // predicateTransformer //------------------------------------------------------------------ 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)); try { TransformerUtils.asTransformer((Predicate) null); } catch (IllegalArgumentException ex) { return; } fail(); } // factoryTransformer //------------------------------------------------------------------ public void testFactoryTransformer() { assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(null)); assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cObject)); assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cString)); assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cInteger)); try { TransformerUtils.asTransformer((Factory) null); } catch (IllegalArgumentException ex) { return; } fail(); } // chainedTransformer //------------------------------------------------------------------ public void testChainedTransformer() { Transformer a = TransformerUtils.constantTransformer("A"); Transformer b = TransformerUtils.constantTransformer("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(); 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)); try { TransformerUtils.chainedTransformer(null, null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.chainedTransformer((Transformer[]) null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.chainedTransformer((Collection) null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.chainedTransformer(new Transformer[] { null, null }); fail(); } catch (IllegalArgumentException ex) { } try { coll = new ArrayList(); coll.add(null); coll.add(null); TransformerUtils.chainedTransformer(coll); fail(); } catch (IllegalArgumentException ex) { } } // switchTransformer //------------------------------------------------------------------ public void testSwitchTransformer() { Transformer a = TransformerUtils.constantTransformer("A"); Transformer b = TransformerUtils.constantTransformer("B"); Transformer c = TransformerUtils.constantTransformer("C"); assertEquals("A", TransformerUtils.switchTransformer(PredicateUtils.truePredicate(), a, b).transform(null)); assertEquals("B", TransformerUtils.switchTransformer(PredicateUtils.falsePredicate(), a, b).transform(null)); assertEquals(null, TransformerUtils .switchTransformer(new Predicate[] { PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE") }, new Transformer[] { a, b }) .transform("WELL")); assertEquals("A", TransformerUtils .switchTransformer(new Predicate[] { PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE") }, new Transformer[] { a, b }) .transform("HELLO")); assertEquals("B", TransformerUtils .switchTransformer(new Predicate[] { PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE") }, new Transformer[] { a, b }) .transform("THERE")); assertEquals("C", TransformerUtils .switchTransformer(new Predicate[] { PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE") }, new Transformer[] { a, b }, c) .transform("WELL")); Map map = new HashMap(); map.put(PredicateUtils.equalPredicate("HELLO"), a); map.put(PredicateUtils.equalPredicate("THERE"), b); assertEquals(null, TransformerUtils.switchTransformer(map).transform("WELL")); assertEquals("A", TransformerUtils.switchTransformer(map).transform("HELLO")); assertEquals("B", TransformerUtils.switchTransformer(map).transform("THERE")); map.put(null, c); assertEquals("C", TransformerUtils.switchTransformer(map).transform("WELL")); assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new Predicate[0], new Transformer[0])); assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(new HashMap())); map = new HashMap(); map.put(null, null); assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchTransformer(map)); try { TransformerUtils.switchTransformer(null, null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.switchTransformer((Predicate[]) null, (Transformer[]) null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.switchTransformer((Map) null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.switchTransformer(new Predicate[2], new Transformer[2]); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.switchTransformer(new Predicate[] { PredicateUtils.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(); map.put("HELLO", a); map.put("THERE", b); assertEquals(null, TransformerUtils.switchMapTransformer(map).transform("WELL")); assertEquals("A", TransformerUtils.switchMapTransformer(map).transform("HELLO")); assertEquals("B", TransformerUtils.switchMapTransformer(map).transform("THERE")); map.put(null, c); assertEquals("C", TransformerUtils.switchMapTransformer(map).transform("WELL")); assertSame(ConstantTransformer.NULL_INSTANCE, TransformerUtils.switchMapTransformer(new HashMap())); map = new HashMap(); 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(); assertEquals(new Integer(0), TransformerUtils.invokerTransformer("size").transform(list)); list.add(new Object()); assertEquals(new Integer(1), TransformerUtils.invokerTransformer("size").transform(list)); assertEquals(null, TransformerUtils.invokerTransformer("size").transform(null)); try { TransformerUtils.invokerTransformer(null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.invokerTransformer("noSuchMethod").transform(new Object()); 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.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)); try { TransformerUtils.invokerTransformer(null, null, null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils .invokerTransformer("noSuchMethod", new Class[] { Object.class }, new Object[] { cString }) .transform(new Object()); fail(); } catch (FunctorException ex) { } try { TransformerUtils.invokerTransformer("badArgs", null, new Object[] { cString }); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.invokerTransformer("badArgs", new Class[] { Object.class }, null); fail(); } catch (IllegalArgumentException ex) { } try { TransformerUtils.invokerTransformer("badArgs", new Class[] {}, new Object[] { cString }); fail(); } catch (IllegalArgumentException ex) { } } // stringValueTransformer //------------------------------------------------------------------ public void testStringValueTransformer() { assertNotNull("StringValueTransformer should NEVER return a null value.", TransformerUtils.stringValueTransformer().transform(null)); assertEquals("StringValueTransformer should return \"null\" when given a null argument.", "null", TransformerUtils.stringValueTransformer().transform(null)); 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" }); fail(); } catch (IllegalArgumentException ex) { } try { Transformer trans = TransformerUtils.instantiateTransformer(new Class[] {}, new Object[] { "str" }); fail(); } catch (IllegalArgumentException ex) { } Transformer 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) }); assertEquals(new Date(1000L), trans.transform(Date.class)); } }