From 7ec96c4306dc8eb6082b92597f2626f7b33931d4 Mon Sep 17 00:00:00 2001 From: "Gary D. Gregory" Date: Sat, 22 Oct 2005 22:03:23 +0000 Subject: [PATCH] [lang] Request for MutableBoolean implementation. http://issues.apache.org/bugzilla/show_bug.cgi?id=37111. git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/lang/trunk@327700 13f79535-47bb-0310-9956-ffa450edef68 --- .../commons/lang/mutable/MutableBoolean.java | 165 ++++++++++++++++++ .../lang/mutable/MutableBooleanTest.java | 148 ++++++++++++++++ .../lang/mutable/MutableTestSuite.java | 7 +- 3 files changed, 318 insertions(+), 2 deletions(-) create mode 100644 src/java/org/apache/commons/lang/mutable/MutableBoolean.java create mode 100644 src/test/org/apache/commons/lang/mutable/MutableBooleanTest.java diff --git a/src/java/org/apache/commons/lang/mutable/MutableBoolean.java b/src/java/org/apache/commons/lang/mutable/MutableBoolean.java new file mode 100644 index 000000000..cd3a23488 --- /dev/null +++ b/src/java/org/apache/commons/lang/mutable/MutableBoolean.java @@ -0,0 +1,165 @@ +/* + * Copyright 2004-2005 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.apache.commons.lang.mutable; + +import java.io.Serializable; + +/** + * A mutable boolean wrapper. + * + * @see Boolean + * @since 2.2 + * @author Apache Software Foundation + * @version $Id$ + */ +public class MutableBoolean implements Mutable, Serializable, Comparable { + + /** Serialization lock. */ + private static final long serialVersionUID = -4830728138360036487L; + + /** The mutable value. */ + private boolean value; + + /** + * Constructs a new MutableBoolean with the default value of false. + */ + public MutableBoolean() { + super(); + } + + /** + * Constructs a new MutableBoolean with the specified value. + * + * @param value + * a value. + */ + public MutableBoolean(boolean value) { + super(); + this.value = value; + } + + /** + * Constructs a new MutableBoolean with the specified value. + * + * @param value + * a value. + * @throws NullPointerException + * if the object is null + */ + public MutableBoolean(Boolean value) { + super(); + this.value = value.booleanValue(); + } + + // ----------------------------------------------------------------------- + /** + * Returns the value of this MutableBoolean as a boolean. + * + * @return the boolean value represented by this object. + */ + public boolean booleanValue() { + return value; + } + + /** + * Compares this mutable to another in ascending order. + * + * @param obj + * the mutable to compare to + * @return zero if this object represents the same boolean value as the argument; a positive value if this object + * represents true and the argument represents false; and a negative value if this object represents false + * and the argument represents true + * @throws ClassCastException + * if the argument is not a MutableInt + */ + public int compareTo(Object obj) { + MutableBoolean other = (MutableBoolean) obj; + boolean anotherVal = other.value; + return value == anotherVal ? 0 : (value ? 1 : -1); + } + + // ----------------------------------------------------------------------- + /** + * Compares this object to the specified object. The result is true if and only if the argument is + * not null and is an MutableBoolean object that contains the same + * boolean value as this object. + * + * @param obj + * the object to compare with. + * @return true if the objects are the same; false otherwise. + */ + public boolean equals(Object obj) { + if (obj instanceof MutableBoolean) { + return value == ((MutableBoolean) obj).booleanValue(); + } + return false; + } + + // ----------------------------------------------------------------------- + /** + * Gets the value as a Boolean instance. + * + * @return the value as a Boolean + */ + public Object getValue() { + return new Boolean(this.value); + } + + /** + * Returns a suitable hashcode for this mutable. + * + * @return the integer 1231 if this object represents true; returns the integer + * 1237 if this object represents false. + */ + public int hashCode() { + return value ? Boolean.TRUE.hashCode() : Boolean.FALSE.hashCode(); + } + + /** + * Sets the value. + * + * @param value + * the value to set + */ + public void setValue(boolean value) { + this.value = value; + } + + /** + * Sets the value from any Boolean instance. + * + * @param value + * the value to set + * @throws NullPointerException + * if the object is null + * @throws ClassCastException + * if the type is not a {@link Boolean} + */ + public void setValue(Object value) { + setValue(((Boolean) value).booleanValue()); + } + + /** + * Returns the String value of this mutable. + * + * @return the mutable value as a string + */ + public String toString() { + return String.valueOf(value); + } + +} diff --git a/src/test/org/apache/commons/lang/mutable/MutableBooleanTest.java b/src/test/org/apache/commons/lang/mutable/MutableBooleanTest.java new file mode 100644 index 000000000..34e934c21 --- /dev/null +++ b/src/test/org/apache/commons/lang/mutable/MutableBooleanTest.java @@ -0,0 +1,148 @@ +/* + * Copyright 2002-2005 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.apache.commons.lang.mutable; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; +import junit.textui.TestRunner; + +/** + * JUnit tests. + * + * @since 2.2 + * @see MutableBoolean + * @author Apache Software Foundation + * @version $Id$ + */ +public class MutableBooleanTest extends TestCase { + + public static void main(String[] args) { + TestRunner.run(suite()); + } + + public static Test suite() { + return new TestSuite(MutableBooleanTest.class); + } + + public MutableBooleanTest(String testName) { + super(testName); + } + + public void testCompareTo() { + final MutableBoolean mutBool = new MutableBoolean(false); + + assertEquals(0, mutBool.compareTo(new MutableBoolean(false))); + assertEquals(-1, mutBool.compareTo(new MutableBoolean(true))); + mutBool.setValue(true); + assertEquals(+1, mutBool.compareTo(new MutableBoolean(false))); + assertEquals(0, mutBool.compareTo(new MutableBoolean(true))); + + try { + mutBool.compareTo(null); + fail(); + } catch (NullPointerException ex) { + } + try { + mutBool.compareTo(Boolean.FALSE); + fail(); + } catch (ClassCastException ex) { + } + try { + mutBool.compareTo("false"); + fail(); + } catch (ClassCastException ex) { + } + } + + // ---------------------------------------------------------------- + public void testConstructors() { + assertEquals(false, new MutableBoolean().booleanValue()); + + assertEquals(true, new MutableBoolean(true).booleanValue()); + assertEquals(false, new MutableBoolean(false).booleanValue()); + + assertEquals(true, new MutableBoolean(Boolean.TRUE).booleanValue()); + assertEquals(false, new MutableBoolean(Boolean.FALSE).booleanValue()); + + try { + new MutableBoolean(null); + fail(); + } catch (NullPointerException ex) { + } + } + + public void testEquals() { + final MutableBoolean mutBoolA = new MutableBoolean(false); + final MutableBoolean mutBoolB = new MutableBoolean(false); + final MutableBoolean mutBoolC = new MutableBoolean(true); + + assertEquals(true, mutBoolA.equals(mutBoolA)); + assertEquals(true, mutBoolA.equals(mutBoolB)); + assertEquals(true, mutBoolB.equals(mutBoolA)); + assertEquals(true, mutBoolB.equals(mutBoolB)); + assertEquals(false, mutBoolA.equals(mutBoolC)); + assertEquals(false, mutBoolB.equals(mutBoolC)); + assertEquals(true, mutBoolC.equals(mutBoolC)); + assertEquals(false, mutBoolA.equals(null)); + assertEquals(false, mutBoolA.equals(Boolean.FALSE)); + assertEquals(false, mutBoolA.equals("false")); + } + + public void testGetSet() { + final MutableBoolean mutBool = new MutableBoolean(false); + assertEquals(false, new MutableBoolean().booleanValue()); + + mutBool.setValue(Boolean.TRUE); + assertEquals(true, mutBool.booleanValue()); + + mutBool.setValue(false); + assertEquals(false, mutBool.booleanValue()); + + mutBool.setValue(true); + assertEquals(true, mutBool.booleanValue()); + + try { + mutBool.setValue(null); + fail(); + } catch (NullPointerException ex) { + } + try { + mutBool.setValue("false"); + fail(); + } catch (ClassCastException ex) { + } + } + + public void testHashCode() { + final MutableBoolean mutBoolA = new MutableBoolean(false); + final MutableBoolean mutBoolB = new MutableBoolean(false); + final MutableBoolean mutBoolC = new MutableBoolean(true); + + assertEquals(true, mutBoolA.hashCode() == mutBoolA.hashCode()); + assertEquals(true, mutBoolA.hashCode() == mutBoolB.hashCode()); + assertEquals(false, mutBoolA.hashCode() == mutBoolC.hashCode()); + assertEquals(true, mutBoolA.hashCode() == Boolean.FALSE.hashCode()); + assertEquals(true, mutBoolC.hashCode() == Boolean.TRUE.hashCode()); + } + + public void testToString() { + assertEquals(Boolean.FALSE.toString(), new MutableBoolean(false).toString()); + assertEquals(Boolean.TRUE.toString(), new MutableBoolean(true).toString()); + } + +} diff --git a/src/test/org/apache/commons/lang/mutable/MutableTestSuite.java b/src/test/org/apache/commons/lang/mutable/MutableTestSuite.java index 16198f0cb..e4be2de5d 100755 --- a/src/test/org/apache/commons/lang/mutable/MutableTestSuite.java +++ b/src/test/org/apache/commons/lang/mutable/MutableTestSuite.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + package org.apache.commons.lang.mutable; import junit.framework.Test; @@ -21,7 +22,7 @@ import junit.textui.TestRunner; /** * JUnit tests. - * + * * @version $Id$ */ public class MutableTestSuite { @@ -33,6 +34,7 @@ public class MutableTestSuite { public static Test suite() { final TestSuite suite = new TestSuite(); + suite.addTest(MutableBooleanTest.suite()); suite.addTest(MutableByteTest.suite()); suite.addTest(MutableShortTest.suite()); suite.addTest(MutableIntTest.suite()); @@ -44,6 +46,7 @@ public class MutableTestSuite { return suite; } - private MutableTestSuite() {} + private MutableTestSuite() { + } }