001: /* ====================================================================
002: The Jicarilla Software License
003:
004: Copyright (c) 2003 Leo Simons.
005: All rights reserved.
006:
007: Permission is hereby granted, free of charge, to any person obtaining
008: a copy of this software and associated documentation files (the
009: "Software"), to deal in the Software without restriction, including
010: without limitation the rights to use, copy, modify, merge, publish,
011: distribute, sublicense, and/or sell copies of the Software, and to
012: permit persons to whom the Software is furnished to do so, subject to
013: the following conditions:
014:
015: The above copyright notice and this permission notice shall be
016: included in all copies or substantial portions of the Software.
017:
018: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
019: EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
020: MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
021: IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
022: CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
023: TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
024: SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
025: ==================================================================== */
026: package org.jicarilla.collections.test;
027:
028: import org.jicarilla.collections.DefaultNode;
029: import org.jicarilla.collections.Node;
030: import junit.framework.TestCase;
031:
032: import java.util.ArrayList;
033: import java.util.Collections;
034: import java.util.HashMap;
035: import java.util.Iterator;
036: import java.util.LinkedList;
037: import java.util.List;
038: import java.util.Map;
039: import java.util.Set;
040:
041: /**
042: * @author <a href="lsimons at jicarilla dot org">Leo Simons</a>
043: * @version $Id: DefaultNodeTestCase.java,v 1.3 2004/02/26 16:51:54 lsimons Exp $
044: */
045: public class DefaultNodeTestCase extends TestCase {
046: public DefaultNode node = new DefaultNode("");
047: public DefaultNode n2 = new DefaultNode("");
048: public DefaultNode n3 = new DefaultNode("blah");
049: //DefaultNode n4 = new DefaultNode("blah", new ArrayList(), someAttributes );
050: public DefaultNode n4 = new DefaultNode(null);
051: public DefaultNode n5 = new DefaultNode(null);
052:
053: public Map someAttributes = new HashMap();
054:
055: public void setUp() {
056: someAttributes.put("blah", "diblah");
057: someAttributes.put(this .getClass().getName(), this );
058: someAttributes.put(null, "jo");
059: someAttributes.put("jo", null);
060: }
061:
062: public void testConstructor() {
063: new DefaultNode(null);
064: new DefaultNode("");
065: new DefaultNode("blah");
066:
067: new DefaultNode(null, new ArrayList());
068: new DefaultNode(null, new LinkedList());
069: new DefaultNode("blah", new ArrayList());
070: new DefaultNode("<blah>", null);
071:
072: new DefaultNode(null, new ArrayList(), null);
073: new DefaultNode(null, new LinkedList(), new HashMap());
074: new DefaultNode("blah", new ArrayList(), someAttributes);
075: new DefaultNode("<blah>", null, Collections
076: .unmodifiableMap(someAttributes));
077: }
078:
079: public void testHashCode() {
080: n2 = new DefaultNode("blah", new ArrayList(), someAttributes);
081: assertFalse(node.hashCode() == n2.hashCode());
082:
083: n3 = new DefaultNode(null, null, null);
084: n4 = new DefaultNode(null, null, null);
085: assertTrue(n3.hashCode() == n4.hashCode());
086:
087: n3 = new DefaultNode(null, null, null);
088: n4 = new DefaultNode(null, null, null);
089:
090: n3.setContents("blah");
091: n4.setContents("blah");
092: assertTrue(n3.hashCode() == n4.hashCode());
093:
094: }
095:
096: public void testEquals() {
097: assertTrue(node.equals(node)); // o == this
098: assertTrue(node.equals(n2)); // everything == true
099: assertFalse(node.equals(this )); // instanceof node
100: assertFalse(node.equals(null)); // instanceof node
101:
102: assertFalse(node.equals(n3)); // name == name
103: assertFalse(node.equals(n4)); // name == name
104: assertFalse(n4.equals(node)); // name == name
105: assertTrue(n4.equals(n5)); // name == name
106:
107: // contents
108: n2.setContents(this );
109: assertFalse(node.equals(n2));
110: assertFalse(n2.equals(node));
111: node.setContents(this );
112: assertTrue(node.equals(n2));
113: assertTrue(n2.equals(node));
114:
115: // children
116: n2.addChild(n3);
117: assertFalse(node.equals(n2));
118: node.addChild(n3);
119: assertTrue(node.equals(n2));
120:
121: n2.addChild(n4);
122: assertFalse(node.equals(n2));
123: node.addChild(n4);
124: assertTrue(node.equals(n2));
125:
126: n2.addChild(node);
127: assertFalse(node.equals(n2));
128: node.addChild(new DefaultNode("another"));
129: assertFalse(node.equals(n2));
130:
131: // reset
132: node = new DefaultNode("");
133: n2 = new DefaultNode("");
134:
135: // attributes
136: n2.put("key", "value");
137: assertFalse(node.equals(n2));
138: node.put("key", "value");
139: assertTrue(node.equals(n2));
140:
141: n2.put("key2", null);
142: assertFalse(node.equals(n2));
143: node.put("key2", null);
144: assertTrue(node.equals(n2));
145:
146: node.put("key", "othervalue");
147: assertFalse(node.equals(n2));
148:
149: node.put("key", null);
150: assertFalse(node.equals(n2));
151:
152: n2.put("key", null);
153: assertTrue(node.equals(n2));
154:
155: // exceptions
156: n2 = new DefaultNode(null, null, null) {
157: protected boolean equalSizes(final Node n) {
158: throw new ClassCastException();
159: }
160: };
161: assertFalse(n2.equals(node));
162:
163: n2 = new DefaultNode(null, null, null) {
164: protected boolean equalSizes(final Node n) {
165: throw new NullPointerException();
166: }
167: };
168: assertFalse(n2.equals(node));
169: }
170:
171: // ----------------------------------------------------------------------
172: // Interface: Node / List
173: // ----------------------------------------------------------------------
174:
175: public void testSize() {
176: assertEquals(0, node.size());
177:
178: node.addChild(n2);
179: assertEquals(1, node.size());
180:
181: node.addChild(n3);
182: assertEquals(2, node.size());
183: }
184:
185: public void testIsEmpty() {
186: assertTrue(node.isEmpty());
187: node.addChild(n2);
188: assertFalse(node.isEmpty());
189:
190: assertTrue(n2.isEmpty());
191: n2.put("key", "value");
192: assertFalse(n2.isEmpty());
193: }
194:
195: public void testClear() {
196: node.put("key", "value");
197: node.addChild(n2);
198:
199: node.clear();
200:
201: assertNull(node.getName());
202: assertNull(node.getContents());
203: assertEquals(0, node.size());
204: assertEquals(0, node.keySet().size());
205: }
206:
207: public void testSetName() {
208: final String old = node.setName("blah");
209: assertEquals("", old);
210: }
211:
212: public void testGetAndSetContents() {
213: assertNull(node.getContents());
214: node.setContents(null);
215: assertNull(node.getContents());
216:
217: node.setContents("blah");
218: assertEquals("blah", node.getContents());
219: }
220:
221: public void testAddChild() {
222: assertTrue(node.addChild(n2));
223: assertTrue(node.addChild(n3));
224: assertTrue(node.addChild(null));
225: }
226:
227: public void testAddChildren() {
228: final List col = new ArrayList();
229: col.add(n2);
230: col.add(n3);
231:
232: assertTrue(node.addChildren(col));
233: }
234:
235: public void testContainsChild() {
236: assertFalse(node.containsChild(n2));
237:
238: node.addChild(n2);
239: assertTrue(node.containsChild(n2));
240: assertFalse(node.containsChild(n3));
241: }
242:
243: public void testContainsChildren() {
244: final List col = new ArrayList();
245: col.add(n2);
246: col.add(n3);
247:
248: assertFalse(node.containsChildren(col));
249: node.addChildren(col);
250: assertTrue(node.containsChildren(col));
251:
252: col.add(node);
253: assertFalse(node.containsChildren(col));
254: }
255:
256: public void testChildrenToArray() {
257: node.addChild(n2);
258: node.addChild(n3);
259: node.addChild(n4);
260: node.addChild(node);
261:
262: Node[] children = node.childrenToArray();
263: assertTrue(arrayContains(children, n2));
264: assertTrue(arrayContains(children, n3));
265: assertTrue(arrayContains(children, n4));
266:
267: children = node.childrenToArray(new Node[0]);
268: assertTrue(arrayContains(children, n2));
269: assertTrue(arrayContains(children, n3));
270: assertTrue(arrayContains(children, n4));
271:
272: children = node.childrenToArray(new Node[10]);
273: assertTrue(arrayContains(children, n2));
274: assertTrue(arrayContains(children, n3));
275: assertTrue(arrayContains(children, n4));
276: assertEquals(10, children.length);
277: }
278:
279: public void testChildrenToList() {
280: node.addChild(n2);
281: node.addChild(n3);
282: node.addChild(n4);
283: node.addChild(node);
284:
285: final List children = node.childrenToList();
286: assertTrue(children.contains(n2));
287: assertTrue(children.contains(n3));
288: assertTrue(children.contains(n4));
289: assertEquals(4, children.size());
290: }
291:
292: public void testIterator() {
293: node.addChild(n2);
294: node.addChild(n3);
295: node.addChild(n4);
296: node.addChild(node);
297:
298: final Node[] children = new Node[4];
299:
300: final Iterator it = node.iterator();
301: int i = 0;
302: while (it.hasNext()) {
303: final Node n = (Node) it.next();
304: children[i] = n;
305: i++;
306: }
307: assertTrue(arrayContains(children, n2));
308: assertTrue(arrayContains(children, n3));
309: assertTrue(arrayContains(children, n4));
310: }
311:
312: public void testRemoveChild() {
313: node.addChild(n2);
314: node.addChild(n3);
315: node.addChild(n4);
316: node.addChild(node);
317:
318: assertTrue(node.removeChild(n2));
319: assertFalse(node.containsChild(n2));
320: assertFalse(node.removeChild(n2));
321:
322: assertFalse(node.removeChild(null));
323: }
324:
325: public void testRemoveChildren() {
326: final List col = new ArrayList();
327: col.add(n2);
328: col.add(n3);
329:
330: node.addChildren(col);
331: node.addChild(n4);
332: node.addChild(node);
333:
334: assertTrue(node.removeChildren(col));
335: assertFalse(node.containsChild(n2));
336: assertFalse(node.removeChildren(col));
337:
338: Throwable t = null;
339: try {
340: node.removeChildren(null);
341: } catch (NullPointerException th) {
342: t = th;
343: }
344: assertNotNull(t);
345:
346: assertFalse(node.removeChildren(new ArrayList()));
347: }
348:
349: // ----------------------------------------------------------------------
350: // Interface: Map
351: // ----------------------------------------------------------------------
352:
353: public void testContainsKey() {
354: assertFalse(node.containsKey(""));
355: assertFalse(node.containsKey(null));
356:
357: node.put("key", "value");
358: assertTrue(node.containsKey("key"));
359: assertFalse(node.containsKey(""));
360:
361: node.put("key", null);
362: assertTrue(node.containsKey("key"));
363: node.remove("key");
364: assertFalse(node.containsKey("key"));
365:
366: }
367:
368: public void testContainsValue() {
369: assertFalse(node.containsValue(""));
370: assertFalse(node.containsValue(null));
371:
372: node.put("key", "value");
373: assertTrue(node.containsValue("value"));
374: assertFalse(node.containsValue(""));
375: assertFalse(node.containsValue(null));
376:
377: node.put("key", null);
378: assertTrue(node.containsValue(null));
379: assertFalse(node.containsValue("value"));
380:
381: node.remove("key");
382: assertFalse(node.containsValue(null));
383: }
384:
385: public void testGet() {
386: assertNull(node.get("key"));
387: assertNull(node.get(null));
388:
389: node.put("key", "value");
390: assertEquals("value", node.get("key"));
391:
392: node.put(null, "value");
393: assertEquals("value", node.get(null));
394: }
395:
396: public void testRemove() {
397: node.put("key", "value");
398: node.remove("key");
399: assertFalse(node.containsKey("key"));
400: assertFalse(node.containsKey("value"));
401: }
402:
403: public void testPutAllAndKeySet() {
404: final Map col = new HashMap();
405: col.put("key", "value");
406: col.put("key2", "value2");
407: col.put("key3", "value3");
408:
409: node.putAll(col);
410: node.putAll(new HashMap());
411:
412: final Set keys = node.keySet();
413: assertTrue(keys.contains("key"));
414: assertTrue(keys.contains("key2"));
415: assertTrue(keys.contains("key3"));
416:
417: Throwable t = null;
418: try {
419: node.putAll(null);
420: } catch (NullPointerException th) {
421: t = th;
422: }
423: assertNotNull(t);
424: }
425:
426: public void testValues() {
427: final Map col = new HashMap();
428: col.put("key", "value");
429: col.put("key2", "value2");
430: col.put("key3", "value3");
431:
432: node.putAll(col);
433:
434: final String[] values = (String[]) node.values().toArray(
435: new String[0]);
436:
437: assertTrue(arrayContains(values, "value"));
438: assertTrue(arrayContains(values, "value2"));
439: assertTrue(arrayContains(values, "value3"));
440: }
441:
442: // ----------------------------------------------------------------------
443: // Helper Methods
444: // ----------------------------------------------------------------------
445:
446: protected boolean arrayContains(final Object[] arr,
447: final Object needle) {
448: for (int i = 0; i < arr.length; i++) {
449: final Object o = arr[i];
450: if (needle.equals(o))
451: return true;
452: }
453: return false;
454: }
455:
456: }
|