Java tutorial
/* $Id: BooleanUtilsTest.java,v 1.2 2004-01-28 15:22:02 mvdb Exp $ Copyright 2002-2004 The Xulux Project 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. */ /* ==================================================================== * The Apache Software License, Version 1.1 * * Copyright (c) 2002-2003 The Apache Software Foundation. All rights * reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. The end-user documentation included with the redistribution, if * any, must include the following acknowledgement: * "This product includes software developed by the * Apache Software Foundation (http://www.apache.org/)." * Alternately, this acknowledgement may appear in the software itself, * if and wherever such third-party acknowledgements normally appear. * * 4. The names "The Jakarta Project", "Commons", and "Apache Software * Foundation" must not be used to endorse or promote products derived * from this software without prior written permission. For written * permission, please contact apache@apache.org. * * 5. Products derived from this software may not be called "Apache" * nor may "Apache" appear in their names without prior written * permission of the Apache Software Foundation. * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * ==================================================================== * * This software consists of voluntary contributions made by many * individuals on behalf of the Apache Software Foundation. For more * information on the Apache Software Foundation, please see * <http://www.apache.org/>. */ package org.xulux.utils; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; import junit.textui.TestRunner; /** * This class is a copy of ArrayUtils from jakarta commons lang, version * 1.8. This is to replace the dependency of complete jakarta commons lang * see http://jakarta.apache.org/commons/lang for the complete lang package. * * Unit tests {@link org.apache.commons.lang.BooleanUtils}. * * @author Stephen Colebourne * @author Matthew Hawthorne * @version $Id: BooleanUtilsTest.java,v 1.2 2004-01-28 15:22:02 mvdb Exp $ */ public class BooleanUtilsTest extends TestCase { public BooleanUtilsTest(String name) { super(name); } public static void main(String[] args) { TestRunner.run(suite()); } public static Test suite() { TestSuite suite = new TestSuite(BooleanUtilsTest.class); suite.setName("BooleanUtils Tests"); return suite; } protected void setUp() throws Exception { super.setUp(); } protected void tearDown() throws Exception { super.tearDown(); } //----------------------------------------------------------------------- public void testConstructor() { assertNotNull(new BooleanUtils()); Constructor[] cons = BooleanUtils.class.getDeclaredConstructors(); assertEquals(1, cons.length); assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); assertEquals(true, Modifier.isPublic(BooleanUtils.class.getModifiers())); assertEquals(false, Modifier.isFinal(BooleanUtils.class.getModifiers())); } //----------------------------------------------------------------------- public void test_negate_Boolean() { assertSame(null, BooleanUtils.negate(null)); assertSame(Boolean.TRUE, BooleanUtils.negate(Boolean.FALSE)); assertSame(Boolean.FALSE, BooleanUtils.negate(Boolean.TRUE)); } //----------------------------------------------------------------------- public void test_toBooleanObject_boolean() { assertSame(Boolean.TRUE, BooleanUtils.toBooleanObject(true)); assertSame(Boolean.FALSE, BooleanUtils.toBooleanObject(false)); } public void test_toBoolean_Boolean() { assertEquals(true, BooleanUtils.toBoolean(Boolean.TRUE)); assertEquals(false, BooleanUtils.toBoolean(Boolean.FALSE)); assertEquals(false, BooleanUtils.toBoolean((Boolean) null)); // added for object test.. assertEquals(true, BooleanUtils.toBoolean((Object) Boolean.TRUE)); assertEquals(false, BooleanUtils.toBoolean((Object) Boolean.FALSE)); assertEquals(false, BooleanUtils.toBoolean((Object) null)); } public void test_toBooleanDefaultIfNull_Boolean_boolean() { assertEquals(true, BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, true)); assertEquals(true, BooleanUtils.toBooleanDefaultIfNull(Boolean.TRUE, false)); assertEquals(false, BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, true)); assertEquals(false, BooleanUtils.toBooleanDefaultIfNull(Boolean.FALSE, false)); assertEquals(true, BooleanUtils.toBooleanDefaultIfNull((Boolean) null, true)); assertEquals(false, BooleanUtils.toBooleanDefaultIfNull((Boolean) null, false)); } //----------------------------------------------------------------------- //----------------------------------------------------------------------- public void test_toBoolean_int() { assertEquals(true, BooleanUtils.toBoolean(1)); assertEquals(true, BooleanUtils.toBoolean(-1)); assertEquals(false, BooleanUtils.toBoolean(0)); } public void test_toBooleanObject_int() { assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(1)); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(-1)); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(0)); } public void test_toBooleanObject_Integer() { assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(new Integer(1))); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(new Integer(-1))); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(new Integer(0))); assertEquals(null, BooleanUtils.toBooleanObject((Integer) null)); } //----------------------------------------------------------------------- public void test_toBoolean_int_int_int() { assertEquals(true, BooleanUtils.toBoolean(6, 6, 7)); assertEquals(false, BooleanUtils.toBoolean(7, 6, 7)); try { BooleanUtils.toBoolean(8, 6, 7); fail(); } catch (IllegalArgumentException ex) { } } public void test_toBoolean_Integer_Integer_Integer() { Integer six = new Integer(6); Integer seven = new Integer(7); assertEquals(true, BooleanUtils.toBoolean((Integer) null, null, seven)); assertEquals(false, BooleanUtils.toBoolean((Integer) null, six, null)); try { BooleanUtils.toBoolean(null, six, seven); fail(); } catch (IllegalArgumentException ex) { } assertEquals(true, BooleanUtils.toBoolean(new Integer(6), six, seven)); assertEquals(false, BooleanUtils.toBoolean(new Integer(7), six, seven)); try { BooleanUtils.toBoolean(new Integer(8), six, seven); fail(); } catch (IllegalArgumentException ex) { } } //----------------------------------------------------------------------- public void test_toBooleanObject_int_int_int() { assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(6, 6, 7, 8)); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(7, 6, 7, 8)); assertEquals(null, BooleanUtils.toBooleanObject(8, 6, 7, 8)); try { BooleanUtils.toBooleanObject(9, 6, 7, 8); fail(); } catch (IllegalArgumentException ex) { } } public void test_toBooleanObject_Integer_Integer_Integer_Integer() { Integer six = new Integer(6); Integer seven = new Integer(7); Integer eight = new Integer(8); assertSame(Boolean.TRUE, BooleanUtils.toBooleanObject((Integer) null, null, seven, eight)); assertSame(Boolean.FALSE, BooleanUtils.toBooleanObject((Integer) null, six, null, eight)); assertSame(null, BooleanUtils.toBooleanObject((Integer) null, six, seven, null)); try { BooleanUtils.toBooleanObject(null, six, seven, eight); fail(); } catch (IllegalArgumentException ex) { } assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject(new Integer(6), six, seven, eight)); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject(new Integer(7), six, seven, eight)); assertEquals(null, BooleanUtils.toBooleanObject(new Integer(8), six, seven, eight)); try { BooleanUtils.toBooleanObject(new Integer(9), six, seven, eight); fail(); } catch (IllegalArgumentException ex) { } } //----------------------------------------------------------------------- public void test_toInteger_boolean() { assertEquals(1, BooleanUtils.toInteger(true)); assertEquals(0, BooleanUtils.toInteger(false)); } public void test_toIntegerObject_boolean() { assertEquals(new Integer(1), BooleanUtils.toIntegerObject(true)); assertEquals(new Integer(0), BooleanUtils.toIntegerObject(false)); } public void test_toIntegerObject_Boolean() { assertEquals(new Integer(1), BooleanUtils.toIntegerObject(Boolean.TRUE)); assertEquals(new Integer(0), BooleanUtils.toIntegerObject(Boolean.FALSE)); assertEquals(null, BooleanUtils.toIntegerObject((Boolean) null)); } //----------------------------------------------------------------------- public void test_toInteger_boolean_int_int() { assertEquals(6, BooleanUtils.toInteger(true, 6, 7)); assertEquals(7, BooleanUtils.toInteger(false, 6, 7)); } public void test_toInteger_Boolean_int_int_int() { assertEquals(6, BooleanUtils.toInteger(Boolean.TRUE, 6, 7, 8)); assertEquals(7, BooleanUtils.toInteger(Boolean.FALSE, 6, 7, 8)); assertEquals(8, BooleanUtils.toInteger(null, 6, 7, 8)); } public void test_toIntegerObject_boolean_Integer_Integer() { Integer six = new Integer(6); Integer seven = new Integer(7); assertEquals(six, BooleanUtils.toIntegerObject(true, six, seven)); assertEquals(seven, BooleanUtils.toIntegerObject(false, six, seven)); } public void test_toIntegerObject_Boolean_Integer_Integer_Integer() { Integer six = new Integer(6); Integer seven = new Integer(7); Integer eight = new Integer(8); assertEquals(six, BooleanUtils.toIntegerObject(Boolean.TRUE, six, seven, eight)); assertEquals(seven, BooleanUtils.toIntegerObject(Boolean.FALSE, six, seven, eight)); assertEquals(eight, BooleanUtils.toIntegerObject((Boolean) null, six, seven, eight)); assertEquals(null, BooleanUtils.toIntegerObject((Boolean) null, six, seven, null)); } //----------------------------------------------------------------------- //----------------------------------------------------------------------- public void test_toBooleanObject_String() { assertEquals(null, BooleanUtils.toBooleanObject((String) null)); assertEquals(null, BooleanUtils.toBooleanObject("")); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("false")); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("no")); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("off")); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("FALSE")); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("NO")); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("OFF")); assertEquals(null, BooleanUtils.toBooleanObject("oof")); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("true")); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("yes")); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("on")); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("TRUE")); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("ON")); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("YES")); assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("TruE")); } public void test_toBooleanObject_String_String_String_String() { assertSame(Boolean.TRUE, BooleanUtils.toBooleanObject((String) null, null, "N", "U")); assertSame(Boolean.FALSE, BooleanUtils.toBooleanObject((String) null, "Y", null, "U")); assertSame(null, BooleanUtils.toBooleanObject((String) null, "Y", "N", null)); try { BooleanUtils.toBooleanObject((String) null, "Y", "N", "U"); fail(); } catch (IllegalArgumentException ex) { } assertEquals(Boolean.TRUE, BooleanUtils.toBooleanObject("Y", "Y", "N", "U")); assertEquals(Boolean.FALSE, BooleanUtils.toBooleanObject("N", "Y", "N", "U")); assertEquals(null, BooleanUtils.toBooleanObject("U", "Y", "N", "U")); try { BooleanUtils.toBooleanObject(null, "Y", "N", "U"); fail(); } catch (IllegalArgumentException ex) { } try { BooleanUtils.toBooleanObject("X", "Y", "N", "U"); fail(); } catch (IllegalArgumentException ex) { } } //----------------------------------------------------------------------- public void test_toBoolean_String() { assertEquals(false, BooleanUtils.toBoolean((String) null)); assertEquals(false, BooleanUtils.toBoolean("")); assertEquals(false, BooleanUtils.toBoolean("off")); assertEquals(false, BooleanUtils.toBoolean("oof")); assertEquals(false, BooleanUtils.toBoolean("yep")); assertEquals(false, BooleanUtils.toBoolean("trux")); assertEquals(false, BooleanUtils.toBoolean("false")); assertEquals(false, BooleanUtils.toBoolean("a")); assertEquals(true, BooleanUtils.toBoolean("true")); // interned handled differently assertEquals(true, BooleanUtils.toBoolean(new StringBuffer("tr").append("ue").toString())); assertEquals(true, BooleanUtils.toBoolean("truE")); assertEquals(true, BooleanUtils.toBoolean("trUe")); assertEquals(true, BooleanUtils.toBoolean("trUE")); assertEquals(true, BooleanUtils.toBoolean("tRue")); assertEquals(true, BooleanUtils.toBoolean("tRuE")); assertEquals(true, BooleanUtils.toBoolean("tRUe")); assertEquals(true, BooleanUtils.toBoolean("tRUE")); assertEquals(true, BooleanUtils.toBoolean("TRUE")); assertEquals(true, BooleanUtils.toBoolean("TRUe")); assertEquals(true, BooleanUtils.toBoolean("TRuE")); assertEquals(true, BooleanUtils.toBoolean("TRue")); assertEquals(true, BooleanUtils.toBoolean("TrUE")); assertEquals(true, BooleanUtils.toBoolean("TrUe")); assertEquals(true, BooleanUtils.toBoolean("TruE")); assertEquals(true, BooleanUtils.toBoolean("True")); assertEquals(true, BooleanUtils.toBoolean("on")); assertEquals(true, BooleanUtils.toBoolean("oN")); assertEquals(true, BooleanUtils.toBoolean("On")); assertEquals(true, BooleanUtils.toBoolean("ON")); assertEquals(true, BooleanUtils.toBoolean("yes")); assertEquals(true, BooleanUtils.toBoolean("yeS")); assertEquals(true, BooleanUtils.toBoolean("yEs")); assertEquals(true, BooleanUtils.toBoolean("yES")); assertEquals(true, BooleanUtils.toBoolean("Yes")); assertEquals(true, BooleanUtils.toBoolean("YeS")); assertEquals(true, BooleanUtils.toBoolean("YEs")); assertEquals(true, BooleanUtils.toBoolean("YES")); // copy & past from above, but now using the object thing! assertEquals(false, BooleanUtils.toBoolean((Object) null)); assertEquals(false, BooleanUtils.toBoolean((Object) "")); assertEquals(false, BooleanUtils.toBoolean((Object) "off")); assertEquals(false, BooleanUtils.toBoolean((Object) "oof")); assertEquals(false, BooleanUtils.toBoolean((Object) "yep")); assertEquals(false, BooleanUtils.toBoolean((Object) "trux")); assertEquals(false, BooleanUtils.toBoolean((Object) "false")); assertEquals(false, BooleanUtils.toBoolean((Object) "a")); assertEquals(true, BooleanUtils.toBoolean((Object) "true")); // interned handled differently assertEquals(true, BooleanUtils.toBoolean((Object) new StringBuffer("tr").append("ue").toString())); assertEquals(true, BooleanUtils.toBoolean((Object) "truE")); assertEquals(true, BooleanUtils.toBoolean((Object) "trUe")); assertEquals(true, BooleanUtils.toBoolean((Object) "trUE")); assertEquals(true, BooleanUtils.toBoolean((Object) "tRue")); assertEquals(true, BooleanUtils.toBoolean((Object) "tRuE")); assertEquals(true, BooleanUtils.toBoolean((Object) "tRUe")); assertEquals(true, BooleanUtils.toBoolean((Object) "tRUE")); assertEquals(true, BooleanUtils.toBoolean((Object) "TRUE")); assertEquals(true, BooleanUtils.toBoolean((Object) "TRUe")); assertEquals(true, BooleanUtils.toBoolean((Object) "TRuE")); assertEquals(true, BooleanUtils.toBoolean((Object) "TRue")); assertEquals(true, BooleanUtils.toBoolean((Object) "TrUE")); assertEquals(true, BooleanUtils.toBoolean((Object) "TrUe")); assertEquals(true, BooleanUtils.toBoolean((Object) "TruE")); assertEquals(true, BooleanUtils.toBoolean((Object) "True")); assertEquals(true, BooleanUtils.toBoolean((Object) "on")); assertEquals(true, BooleanUtils.toBoolean((Object) "oN")); assertEquals(true, BooleanUtils.toBoolean((Object) "On")); assertEquals(true, BooleanUtils.toBoolean((Object) "ON")); assertEquals(true, BooleanUtils.toBoolean((Object) "yes")); assertEquals(true, BooleanUtils.toBoolean((Object) "yeS")); assertEquals(true, BooleanUtils.toBoolean((Object) "yEs")); assertEquals(true, BooleanUtils.toBoolean((Object) "yES")); assertEquals(true, BooleanUtils.toBoolean((Object) "Yes")); assertEquals(true, BooleanUtils.toBoolean((Object) "YeS")); assertEquals(true, BooleanUtils.toBoolean((Object) "YEs")); assertEquals(true, BooleanUtils.toBoolean((Object) "YES")); } public void test_toBoolean_Object() { try { Object o = new Integer(0); BooleanUtils.toBoolean(o); fail("Excpected illegalArgumentException"); } catch (IllegalArgumentException iae) { } } public void test_toBoolean_String_String_String() { assertEquals(true, BooleanUtils.toBoolean((String) null, null, "N")); assertEquals(false, BooleanUtils.toBoolean((String) null, "Y", null)); try { BooleanUtils.toBooleanObject((String) null, "Y", "N", "U"); fail(); } catch (IllegalArgumentException ex) { } assertEquals(true, BooleanUtils.toBoolean("Y", "Y", "N")); assertEquals(false, BooleanUtils.toBoolean("N", "Y", "N")); try { BooleanUtils.toBoolean(null, "Y", "N"); fail(); } catch (IllegalArgumentException ex) { } try { BooleanUtils.toBoolean("X", "Y", "N"); fail(); } catch (IllegalArgumentException ex) { } } //----------------------------------------------------------------------- public void test_toStringTrueFalse_Boolean() { assertEquals(null, BooleanUtils.toStringTrueFalse((Boolean) null)); assertEquals("true", BooleanUtils.toStringTrueFalse(Boolean.TRUE)); assertEquals("false", BooleanUtils.toStringTrueFalse(Boolean.FALSE)); } public void test_toStringOnOff_Boolean() { assertEquals(null, BooleanUtils.toStringOnOff((Boolean) null)); assertEquals("on", BooleanUtils.toStringOnOff(Boolean.TRUE)); assertEquals("off", BooleanUtils.toStringOnOff(Boolean.FALSE)); } public void test_toStringYesNo_Boolean() { assertEquals(null, BooleanUtils.toStringYesNo((Boolean) null)); assertEquals("yes", BooleanUtils.toStringYesNo(Boolean.TRUE)); assertEquals("no", BooleanUtils.toStringYesNo(Boolean.FALSE)); } public void test_toString_Boolean_String_String_String() { assertEquals("U", BooleanUtils.toString((Boolean) null, "Y", "N", "U")); assertEquals("Y", BooleanUtils.toString(Boolean.TRUE, "Y", "N", "U")); assertEquals("N", BooleanUtils.toString(Boolean.FALSE, "Y", "N", "U")); } //----------------------------------------------------------------------- public void test_toStringTrueFalse_boolean() { assertEquals("true", BooleanUtils.toStringTrueFalse(true)); assertEquals("false", BooleanUtils.toStringTrueFalse(false)); } public void test_toStringOnOff_boolean() { assertEquals("on", BooleanUtils.toStringOnOff(true)); assertEquals("off", BooleanUtils.toStringOnOff(false)); } public void test_toStringYesNo_boolean() { assertEquals("yes", BooleanUtils.toStringYesNo(true)); assertEquals("no", BooleanUtils.toStringYesNo(false)); } public void test_toString_boolean_String_String_String() { assertEquals("Y", BooleanUtils.toString(true, "Y", "N")); assertEquals("N", BooleanUtils.toString(false, "Y", "N")); } // testXor // ----------------------------------------------------------------------- public void testXor_primitive_nullInput() { final boolean[] b = null; try { BooleanUtils.xor(b); fail("Exception was not thrown for null input."); } catch (IllegalArgumentException ex) { } } public void testXor_primitive_emptyInput() { try { BooleanUtils.xor(new boolean[] {}); fail("Exception was not thrown for empty input."); } catch (IllegalArgumentException ex) { } } public void testXor_primitive_validInput_2items() { assertTrue("True result for (true, true)", !BooleanUtils.xor(new boolean[] { true, true })); assertTrue("True result for (false, false)", !BooleanUtils.xor(new boolean[] { false, false })); assertTrue("False result for (true, false)", BooleanUtils.xor(new boolean[] { true, false })); assertTrue("False result for (false, true)", BooleanUtils.xor(new boolean[] { false, true })); } public void testXor_primitive_validInput_3items() { assertTrue("False result for (false, false, true)", BooleanUtils.xor(new boolean[] { false, false, true })); assertTrue("False result for (false, true, false)", BooleanUtils.xor(new boolean[] { false, true, false })); assertTrue("False result for (true, false, false)", BooleanUtils.xor(new boolean[] { true, false, false })); assertTrue("True result for (true, true, true)", !BooleanUtils.xor(new boolean[] { true, true, true })); assertTrue("True result for (false, false)", !BooleanUtils.xor(new boolean[] { false, false, false })); assertTrue("True result for (true, true, false)", !BooleanUtils.xor(new boolean[] { true, true, false })); assertTrue("True result for (true, false, true)", !BooleanUtils.xor(new boolean[] { true, false, true })); assertTrue("False result for (false, true, true)", !BooleanUtils.xor(new boolean[] { false, true, true })); } }