001: package test.prefuse.data.util;
002:
003: import java.util.Arrays;
004: import java.util.NoSuchElementException;
005:
006: import junit.framework.TestCase;
007: import prefuse.util.collections.IntIntTreeMap;
008: import prefuse.util.collections.LiteralIterator;
009:
010: public class IntIntTreeMapTest extends TestCase {
011:
012: IntIntTreeMap map = new IntIntTreeMap(true);
013: int[] keys = { 1, 2, 5, 3, 4, 5, 10 };
014: int[] sort;
015:
016: public IntIntTreeMapTest() {
017: sort = (int[]) keys.clone();
018: Arrays.sort(sort);
019: }
020:
021: protected void setUp() throws Exception {
022: super .setUp();
023: for (int i = 0; i < keys.length; ++i) {
024: map.put(keys[i], keys[i]);
025: }
026: }
027:
028: protected void tearDown() throws Exception {
029: super .tearDown();
030: map.clear();
031: }
032:
033: /*
034: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.clear()'
035: */
036: public void testClear() {
037: map.clear();
038: assertTrue(map.isEmpty());
039: try {
040: map.keyIterator().next();
041: fail("Iterator should be empty");
042: } catch (NoSuchElementException success) {
043: }
044: assertEquals(map.get(1), Integer.MIN_VALUE);
045: }
046:
047: /*
048: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.get(int)'
049: */
050: public void testGet() {
051: for (int i = 0; i < map.size(); ++i) {
052: assertEquals(map.get(keys[i]), keys[i]);
053: }
054: }
055:
056: /*
057: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.put(int, int)'
058: */
059: public void testPut() {
060: map.clear();
061: int size = 0;
062: for (int i = 0; i < keys.length; ++i) {
063: map.put(keys[i], keys[i]);
064: assertEquals(++size, map.size());
065: assertEquals(map.get(keys[i]), keys[i]);
066: }
067: }
068:
069: /*
070: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.remove(int)'
071: */
072: public void testRemoveInt() {
073: int size = map.size();
074: for (int i = 0; i < keys.length; ++i) {
075: int val = map.remove(keys[i]);
076: assertEquals(keys[i], val);
077: assertEquals(--size, map.size());
078: }
079: for (int i = 0; i < keys.length; ++i) {
080: assertEquals(map.get(keys[i]), Integer.MIN_VALUE);
081: }
082: }
083:
084: /*
085: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.firstKey()'
086: */
087: public void testFirstKey() {
088: assertEquals(map.firstKey(), sort[0]);
089: }
090:
091: /*
092: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.lastKey()'
093: */
094: public void testLastKey() {
095: assertEquals(map.lastKey(), sort[sort.length - 1]);
096: }
097:
098: /*
099: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.keyIterator()'
100: */
101: public void testKeyIterator() {
102: LiteralIterator iter = map.keyIterator();
103: for (int i = 0; iter.hasNext(); ++i) {
104: int key = iter.nextInt();
105: assertEquals(sort[i], key);
106: }
107: }
108:
109: /*
110: * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.subMap(int, int)'
111: */
112: public void testSubMap() {
113: int k1, i1, i2, i, k, len = sort.length - 1;
114: for (i = 0, k = sort[0]; k == sort[0]; ++i, k = sort[i])
115: ;
116: k1 = k;
117: i1 = i;
118: for (i = len, k = sort[len]; i >= 0 && k == sort[len]; --i, k = sort[i])
119: ;
120: i2 = i;
121:
122: LiteralIterator iter = map.keyRangeIterator(k1, true,
123: sort[len], false);
124: for (i = i1; iter.hasNext() && i <= i2; ++i) {
125: assertEquals(iter.nextInt(), sort[i]);
126: }
127: assertTrue(!iter.hasNext() && i == i2 + 1);
128:
129: iter = map.valueRangeIterator(k1, true, sort[len], false);
130: for (i = i1; iter.hasNext() && i <= i2; ++i) {
131: assertEquals(iter.nextInt(), sort[i]);
132: }
133: assertTrue(!iter.hasNext() && i == i2 + 1);
134: }
135:
136: /*
137: * Test method for 'edu.berkeley.guir.prefuse.data.util.AbstractTreeMap.size()'
138: */
139: public void testSize() {
140: assertEquals(map.size(), keys.length);
141: }
142:
143: /*
144: * Test method for 'edu.berkeley.guir.prefuse.data.util.AbstractTreeMap.isEmpty()'
145: */
146: public void testIsEmpty() {
147: assertFalse(map.isEmpty());
148: }
149:
150: /*
151: * Test method for 'edu.berkeley.guir.prefuse.data.util.AbstractTreeMap.valueIterator()'
152: */
153: public void testValueIterator() {
154: LiteralIterator iter = map.valueIterator(true);
155: for (int i = 0; iter.hasNext(); ++i) {
156: int val = iter.nextInt();
157: assertEquals(sort[i], val);
158: }
159: }
160:
161: }
|