Java tutorial
/* * Copyright 2001-2004,2006 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.HashMap; import java.util.Map; import junit.framework.Test; import junit.framework.TestSuite; import junit.textui.TestRunner; import org.enerj.apache.commons.collections.functors.NOPClosure; /** * Tests the org.apache.commons.collections.ClosureUtils class. * * @since Commons Collections 3.0 * @version $Revision: 375766 $ $Date: 2006-02-07 23:10:36 +0000 (Tue, 07 Feb 2006) $ * * @author Stephen Colebourne */ public class TestClosureUtils extends junit.framework.TestCase { private static final Object cString = "Hello"; /** * Construct */ public TestClosureUtils(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(TestClosureUtils.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() { } static class MockClosure implements Closure { int count = 0; public void execute(Object object) { count++; } } static class MockTransformer implements Transformer { int count = 0; public Object transform(Object object) { count++; return object; } } // exceptionClosure //------------------------------------------------------------------ public void testExceptionClosure() { assertNotNull(ClosureUtils.exceptionClosure()); assertSame(ClosureUtils.exceptionClosure(), ClosureUtils.exceptionClosure()); try { ClosureUtils.exceptionClosure().execute(null); } catch (FunctorException ex) { try { ClosureUtils.exceptionClosure().execute(cString); } catch (FunctorException ex2) { return; } } fail(); } // nopClosure //------------------------------------------------------------------ public void testNopClosure() { StringBuffer buf = new StringBuffer("Hello"); ClosureUtils.nopClosure().execute(null); assertEquals("Hello", buf.toString()); ClosureUtils.nopClosure().execute("Hello"); assertEquals("Hello", buf.toString()); } // invokeClosure //------------------------------------------------------------------ public void testInvokeClosure() { StringBuffer buf = new StringBuffer("Hello"); ClosureUtils.invokerClosure("reverse").execute(buf); assertEquals("olleH", buf.toString()); buf = new StringBuffer("Hello"); ClosureUtils.invokerClosure("setLength", new Class[] { Integer.TYPE }, new Object[] { new Integer(2) }) .execute(buf); assertEquals("He", buf.toString()); } // forClosure //------------------------------------------------------------------ public void testForClosure() { MockClosure cmd = new MockClosure(); ClosureUtils.forClosure(5, cmd).execute(null); assertEquals(5, cmd.count); assertSame(NOPClosure.INSTANCE, ClosureUtils.forClosure(0, new MockClosure())); assertSame(NOPClosure.INSTANCE, ClosureUtils.forClosure(-1, new MockClosure())); assertSame(NOPClosure.INSTANCE, ClosureUtils.forClosure(1, null)); assertSame(NOPClosure.INSTANCE, ClosureUtils.forClosure(3, null)); assertSame(cmd, ClosureUtils.forClosure(1, cmd)); } // whileClosure //------------------------------------------------------------------ public void testWhileClosure() { MockClosure cmd = new MockClosure(); ClosureUtils.whileClosure(PredicateUtils.falsePredicate(), cmd).execute(null); assertEquals(0, cmd.count); cmd = new MockClosure(); ClosureUtils.whileClosure(PredicateUtils.uniquePredicate(), cmd).execute(null); assertEquals(1, cmd.count); try { ClosureUtils.whileClosure(null, ClosureUtils.nopClosure()); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.whileClosure(PredicateUtils.falsePredicate(), null); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.whileClosure(null, null); fail(); } catch (IllegalArgumentException ex) { } } // doWhileClosure //------------------------------------------------------------------ public void testDoWhileClosure() { MockClosure cmd = new MockClosure(); ClosureUtils.doWhileClosure(cmd, PredicateUtils.falsePredicate()).execute(null); assertEquals(1, cmd.count); cmd = new MockClosure(); ClosureUtils.doWhileClosure(cmd, PredicateUtils.uniquePredicate()).execute(null); assertEquals(2, cmd.count); try { ClosureUtils.doWhileClosure(null, null); fail(); } catch (IllegalArgumentException ex) { } } // chainedClosure //------------------------------------------------------------------ public void testChainedClosure() { MockClosure a = new MockClosure(); MockClosure b = new MockClosure(); ClosureUtils.chainedClosure(a, b).execute(null); assertEquals(1, a.count); assertEquals(1, b.count); a = new MockClosure(); b = new MockClosure(); ClosureUtils.chainedClosure(new Closure[] { a, b, a }).execute(null); assertEquals(2, a.count); assertEquals(1, b.count); a = new MockClosure(); b = new MockClosure(); Collection coll = new ArrayList(); coll.add(b); coll.add(a); coll.add(b); ClosureUtils.chainedClosure(coll).execute(null); assertEquals(1, a.count); assertEquals(2, b.count); assertSame(NOPClosure.INSTANCE, ClosureUtils.chainedClosure(new Closure[0])); assertSame(NOPClosure.INSTANCE, ClosureUtils.chainedClosure(Collections.EMPTY_LIST)); try { ClosureUtils.chainedClosure(null, null); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.chainedClosure((Closure[]) null); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.chainedClosure((Collection) null); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.chainedClosure(new Closure[] { null, null }); fail(); } catch (IllegalArgumentException ex) { } try { coll = new ArrayList(); coll.add(null); coll.add(null); ClosureUtils.chainedClosure(coll); fail(); } catch (IllegalArgumentException ex) { } } // ifClosure //------------------------------------------------------------------ public void testIfClosure() { MockClosure a = new MockClosure(); MockClosure b = null; ClosureUtils.ifClosure(PredicateUtils.truePredicate(), a).execute(null); assertEquals(1, a.count); a = new MockClosure(); ClosureUtils.ifClosure(PredicateUtils.falsePredicate(), a).execute(null); assertEquals(0, a.count); a = new MockClosure(); b = new MockClosure(); ClosureUtils.ifClosure(PredicateUtils.truePredicate(), a, b).execute(null); assertEquals(1, a.count); assertEquals(0, b.count); a = new MockClosure(); b = new MockClosure(); ClosureUtils.ifClosure(PredicateUtils.falsePredicate(), a, b).execute(null); assertEquals(0, a.count); assertEquals(1, b.count); } // switchClosure //------------------------------------------------------------------ public void testSwitchClosure() { MockClosure a = new MockClosure(); MockClosure b = new MockClosure(); ClosureUtils.switchClosure( new Predicate[] { PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE") }, new Closure[] { a, b }).execute("WELL"); assertEquals(0, a.count); assertEquals(0, b.count); a = new MockClosure(); b = new MockClosure(); ClosureUtils.switchClosure( new Predicate[] { PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE") }, new Closure[] { a, b }).execute("HELLO"); assertEquals(1, a.count); assertEquals(0, b.count); a = new MockClosure(); b = new MockClosure(); MockClosure c = new MockClosure(); ClosureUtils.switchClosure( new Predicate[] { PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE") }, new Closure[] { a, b }, c).execute("WELL"); assertEquals(0, a.count); assertEquals(0, b.count); assertEquals(1, c.count); a = new MockClosure(); b = new MockClosure(); Map map = new HashMap(); map.put(PredicateUtils.equalPredicate("HELLO"), a); map.put(PredicateUtils.equalPredicate("THERE"), b); ClosureUtils.switchClosure(map).execute(null); assertEquals(0, a.count); assertEquals(0, b.count); a = new MockClosure(); b = new MockClosure(); map = new HashMap(); map.put(PredicateUtils.equalPredicate("HELLO"), a); map.put(PredicateUtils.equalPredicate("THERE"), b); ClosureUtils.switchClosure(map).execute("THERE"); assertEquals(0, a.count); assertEquals(1, b.count); a = new MockClosure(); b = new MockClosure(); c = new MockClosure(); map = new HashMap(); map.put(PredicateUtils.equalPredicate("HELLO"), a); map.put(PredicateUtils.equalPredicate("THERE"), b); map.put(null, c); ClosureUtils.switchClosure(map).execute("WELL"); assertEquals(0, a.count); assertEquals(0, b.count); assertEquals(1, c.count); assertSame(NOPClosure.INSTANCE, ClosureUtils.switchClosure(new Predicate[0], new Closure[0])); assertSame(NOPClosure.INSTANCE, ClosureUtils.switchClosure(new HashMap())); map = new HashMap(); map.put(null, null); assertSame(NOPClosure.INSTANCE, ClosureUtils.switchClosure(map)); try { ClosureUtils.switchClosure(null, null); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.switchClosure((Predicate[]) null, (Closure[]) null); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.switchClosure((Map) null); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.switchClosure(new Predicate[2], new Closure[2]); fail(); } catch (IllegalArgumentException ex) { } try { ClosureUtils.switchClosure(new Predicate[] { PredicateUtils.truePredicate() }, new Closure[] { a, b }); fail(); } catch (IllegalArgumentException ex) { } } // switchMapClosure //------------------------------------------------------------------ public void testSwitchMapClosure() { MockClosure a = new MockClosure(); MockClosure b = new MockClosure(); Map map = new HashMap(); map.put("HELLO", a); map.put("THERE", b); ClosureUtils.switchMapClosure(map).execute(null); assertEquals(0, a.count); assertEquals(0, b.count); a = new MockClosure(); b = new MockClosure(); map = new HashMap(); map.put("HELLO", a); map.put("THERE", b); ClosureUtils.switchMapClosure(map).execute("THERE"); assertEquals(0, a.count); assertEquals(1, b.count); a = new MockClosure(); b = new MockClosure(); MockClosure c = new MockClosure(); map = new HashMap(); map.put("HELLO", a); map.put("THERE", b); map.put(null, c); ClosureUtils.switchMapClosure(map).execute("WELL"); assertEquals(0, a.count); assertEquals(0, b.count); assertEquals(1, c.count); assertSame(NOPClosure.INSTANCE, ClosureUtils.switchMapClosure(new HashMap())); try { ClosureUtils.switchMapClosure(null); fail(); } catch (IllegalArgumentException ex) { } } // asClosure //------------------------------------------------------------------ public void testTransformerClosure() { MockTransformer mock = new MockTransformer(); Closure closure = ClosureUtils.asClosure(mock); closure.execute(null); assertEquals(1, mock.count); closure.execute(null); assertEquals(2, mock.count); assertSame(ClosureUtils.nopClosure(), ClosureUtils.asClosure(null)); } }