001: /*
002: * Copyright 2001-2004 The Apache Software Foundation
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.apache.commons.collections.comparators;
017:
018: import java.util.ArrayList;
019: import java.util.Comparator;
020: import java.util.List;
021:
022: import junit.framework.Test;
023: import junit.framework.TestSuite;
024:
025: /**
026: * Tests for {@link BooleanComparator}.
027: *
028: * @version $Revision: 155406 $ $Date: 2005-02-26 12:55:26 +0000 (Sat, 26 Feb 2005) $
029: *
030: * @author Rodney Waldhoff
031: */
032: public class TestBooleanComparator extends AbstractTestComparator {
033:
034: // conventional
035: // ------------------------------------------------------------------------
036:
037: public TestBooleanComparator(String testName) {
038: super (testName);
039: }
040:
041: public static Test suite() {
042: return new TestSuite(TestBooleanComparator.class);
043: }
044:
045: // collections testing framework
046: // ------------------------------------------------------------------------
047:
048: public Comparator makeComparator() {
049: return new BooleanComparator();
050: }
051:
052: public List getComparableObjectsOrdered() {
053: List list = new ArrayList();
054: list.add(new Boolean(false));
055: list.add(Boolean.FALSE);
056: list.add(new Boolean(false));
057: list.add(Boolean.TRUE);
058: list.add(new Boolean(true));
059: list.add(Boolean.TRUE);
060: return list;
061: }
062:
063: public String getCompatibilityVersion() {
064: return "3";
065: }
066:
067: // tests
068: // ------------------------------------------------------------------------
069:
070: public void testConstructors() {
071: allTests(false, new BooleanComparator());
072: allTests(false, new BooleanComparator(false));
073: allTests(true, new BooleanComparator(true));
074: }
075:
076: public void testStaticFactoryMethods() {
077: allTests(false, BooleanComparator.getFalseFirstComparator());
078: allTests(false, BooleanComparator.getBooleanComparator(false));
079: allTests(true, BooleanComparator.getTrueFirstComparator());
080: allTests(true, BooleanComparator.getBooleanComparator(true));
081: }
082:
083: public void testEqualsCompatibleInstance() {
084: assertEquals(new BooleanComparator(), new BooleanComparator(
085: false));
086: assertEquals(new BooleanComparator(false),
087: new BooleanComparator(false));
088: assertEquals(new BooleanComparator(false), BooleanComparator
089: .getFalseFirstComparator());
090: assertSame(BooleanComparator.getFalseFirstComparator(),
091: BooleanComparator.getBooleanComparator(false));
092:
093: assertEquals(new BooleanComparator(true),
094: new BooleanComparator(true));
095: assertEquals(new BooleanComparator(true), BooleanComparator
096: .getTrueFirstComparator());
097: assertSame(BooleanComparator.getTrueFirstComparator(),
098: BooleanComparator.getBooleanComparator(true));
099:
100: assertTrue(!(new BooleanComparator()
101: .equals(new BooleanComparator(true))));
102: assertTrue(!(new BooleanComparator(true)
103: .equals(new BooleanComparator(false))));
104: }
105:
106: // utilities
107: // ------------------------------------------------------------------------
108:
109: protected void allTests(boolean trueFirst, BooleanComparator comp) {
110: orderIndependentTests(comp);
111: if (trueFirst) {
112: trueFirstTests(comp);
113: } else {
114: falseFirstTests(comp);
115: }
116: }
117:
118: protected void trueFirstTests(BooleanComparator comp) {
119: assertNotNull(comp);
120: assertEquals(0, comp.compare(Boolean.TRUE, Boolean.TRUE));
121: assertEquals(0, comp.compare(Boolean.FALSE, Boolean.FALSE));
122: assertTrue(comp.compare(Boolean.FALSE, Boolean.TRUE) > 0);
123: assertTrue(comp.compare(Boolean.TRUE, Boolean.FALSE) < 0);
124:
125: assertEquals(0, comp.compare((Object) (Boolean.TRUE),
126: (Object) (Boolean.TRUE)));
127: assertEquals(0, comp.compare((Object) (Boolean.FALSE),
128: (Object) (Boolean.FALSE)));
129: assertTrue(comp.compare((Object) (Boolean.FALSE),
130: (Object) (Boolean.TRUE)) > 0);
131: assertTrue(comp.compare((Object) (Boolean.TRUE),
132: (Object) (Boolean.FALSE)) < 0);
133: }
134:
135: protected void falseFirstTests(BooleanComparator comp) {
136: assertNotNull(comp);
137: assertEquals(0, comp.compare(Boolean.TRUE, Boolean.TRUE));
138: assertEquals(0, comp.compare(Boolean.FALSE, Boolean.FALSE));
139: assertTrue(comp.compare(Boolean.FALSE, Boolean.TRUE) < 0);
140: assertTrue(comp.compare(Boolean.TRUE, Boolean.FALSE) > 0);
141:
142: assertEquals(0, comp.compare((Object) (Boolean.TRUE),
143: (Object) (Boolean.TRUE)));
144: assertEquals(0, comp.compare((Object) (Boolean.FALSE),
145: (Object) (Boolean.FALSE)));
146: assertTrue(comp.compare((Object) (Boolean.FALSE),
147: (Object) (Boolean.TRUE)) < 0);
148: assertTrue(comp.compare((Object) (Boolean.TRUE),
149: (Object) (Boolean.FALSE)) > 0);
150: }
151:
152: protected void orderIndependentTests(BooleanComparator comp) {
153: nullArgumentTests(comp);
154: nonBooleanArgumentTests(comp);
155: nullAndNonBooleanArgumentsTests(comp);
156: }
157:
158: protected void nullArgumentTests(BooleanComparator comp) {
159: assertNotNull(comp);
160: try {
161: comp.compare(null, null);
162: fail("Expected NullPointerException");
163: } catch (NullPointerException e) {
164: // expected
165: }
166: try {
167: comp.compare(Boolean.TRUE, null);
168: fail("Expected NullPointerException");
169: } catch (NullPointerException e) {
170: // expected
171: }
172: try {
173: comp.compare(Boolean.FALSE, null);
174: fail("Expected NullPointerException");
175: } catch (NullPointerException e) {
176: // expected
177: }
178: try {
179: comp.compare(null, Boolean.TRUE);
180: fail("Expected NullPointerException");
181: } catch (NullPointerException e) {
182: // expected
183: }
184: try {
185: comp.compare(null, Boolean.FALSE);
186: fail("Expected NullPointerException");
187: } catch (NullPointerException e) {
188: // expected
189: }
190: }
191:
192: protected void nonBooleanArgumentTests(BooleanComparator comp) {
193: assertNotNull(comp);
194: try {
195: comp.compare("string", "string");
196: fail("Expected ClassCastException");
197: } catch (ClassCastException e) {
198: // expected
199: }
200: try {
201: comp.compare(Boolean.TRUE, "string");
202: fail("Expected ClassCastException");
203: } catch (ClassCastException e) {
204: // expected
205: }
206: try {
207: comp.compare("string", Boolean.TRUE);
208: fail("Expected ClassCastException");
209: } catch (ClassCastException e) {
210: // expected
211: }
212: try {
213: comp.compare("string", new Integer(3));
214: fail("Expected ClassCastException");
215: } catch (ClassCastException e) {
216: // expected
217: }
218: try {
219: comp.compare(new Integer(3), "string");
220: fail("Expected ClassCastException");
221: } catch (ClassCastException e) {
222: // expected
223: }
224: }
225:
226: protected void nullAndNonBooleanArgumentsTests(
227: BooleanComparator comp) {
228: assertNotNull(comp);
229: try {
230: comp.compare(null, "string");
231: fail("Expected ClassCast or NullPointer Exception");
232: } catch (ClassCastException e) {
233: // expected
234: } catch (NullPointerException e) {
235: // expected
236: }
237: try {
238: comp.compare("string", null);
239: fail("Expected ClassCast or NullPointer Exception");
240: } catch (ClassCastException e) {
241: // expected
242: } catch (NullPointerException e) {
243: // expected
244: }
245: }
246:
247: }
|