KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > test > prefuse > data > util > LongIntTreeMapTest


1 package test.prefuse.data.util;
2
3 import java.util.Arrays JavaDoc;
4 import java.util.NoSuchElementException JavaDoc;
5
6 import junit.framework.TestCase;
7 import prefuse.util.collections.LiteralIterator;
8 import prefuse.util.collections.LongIntTreeMap;
9
10 public class LongIntTreeMapTest extends TestCase {
11     
12     LongIntTreeMap map = new LongIntTreeMap(true);
13     int[] keys = { 1, 2, 5, 3, 4, 5, 10 };
14     int[] sort;
15     
16     public LongIntTreeMapTest() {
17         sort = (int[])keys.clone();
18         Arrays.sort(sort);
19     }
20     
21     protected void setUp() throws Exception JavaDoc {
22         super.setUp();
23         for ( int i=0; i<keys.length; ++i ) {
24             map.put(keys[i],keys[i]);
25         }
26     }
27
28     protected void tearDown() throws Exception JavaDoc {
29         super.tearDown();
30         map.clear();
31     }
32
33     /*
34      * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.clear()'
35      */

36     public void testClear() {
37         map.clear();
38         assertTrue(map.isEmpty());
39         try {
40             map.keyIterator().next();
41             fail("Iterator should be empty");
42         } catch ( NoSuchElementException JavaDoc success ) {
43         }
44         assertEquals(map.get(1),Integer.MIN_VALUE);
45     }
46
47     /*
48      * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.get(int)'
49      */

50     public void testGet() {
51         for ( int i=0; i<map.size(); ++i ) {
52             assertEquals(map.get(keys[i]),keys[i]);
53         }
54     }
55
56     /*
57      * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.put(int, int)'
58      */

59     public void testPut() {
60         map.clear();
61         int size = 0;
62         for ( int i=0; i<keys.length; ++i ) {
63             map.put(keys[i],keys[i]);
64             assertEquals(++size, map.size());
65             assertEquals(map.get(keys[i]), keys[i]);
66         }
67     }
68
69     /*
70      * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.remove(int)'
71      */

72     public void testRemoveInt() {
73         int size = map.size();
74         for ( int i=0; i<keys.length; ++i ) {
75             int val = map.remove(keys[i]);
76             assertEquals(keys[i], val);
77             assertEquals(--size, map.size());
78         }
79         for ( int i=0; i<keys.length; ++i ) {
80             assertEquals(map.get(keys[i]), Integer.MIN_VALUE);
81         }
82     }
83
84     /*
85      * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.firstKey()'
86      */

87     public void testFirstKey() {
88         assertEquals(map.firstKey(), sort[0]);
89     }
90
91     /*
92      * Test method for 'edu.berkeley.guir.prefuse.data.util.IntIntTreeMap.lastKey()'
93      */

94     public void testLastKey() {
95         assertEquals(map.lastKey(), sort[sort.length-1]);
96     }
97
98     /*
99      * 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             long key = iter.nextLong();
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         k1 = k; i1 = i;
116         for ( i=len, k=sort[len]; i>=0 && k==sort[len]; --i, k=sort[i] );
117         i2 = i;
118         
119         LiteralIterator iter = map.keyRangeIterator(k1, true, sort[len], false);
120         for ( i=i1; iter.hasNext() && i <= i2; ++i ) {
121             assertEquals(iter.nextLong(), sort[i]);
122         }
123         assertTrue(!iter.hasNext() && i == i2+1);
124         
125         iter = map.valueRangeIterator(k1, true, sort[len], false);
126         for ( i=i1; iter.hasNext() && i <= i2; ++i ) {
127             assertEquals(iter.nextInt(), sort[i]);
128         }
129         assertTrue(!iter.hasNext() && i == i2+1);
130     }
131
132     /*
133      * Test method for 'edu.berkeley.guir.prefuse.data.util.AbstractTreeMap.size()'
134      */

135     public void testSize() {
136         assertEquals(map.size(), keys.length);
137     }
138
139     /*
140      * Test method for 'edu.berkeley.guir.prefuse.data.util.AbstractTreeMap.isEmpty()'
141      */

142     public void testIsEmpty() {
143         assertFalse(map.isEmpty());
144     }
145
146     /*
147      * Test method for 'edu.berkeley.guir.prefuse.data.util.AbstractTreeMap.valueIterator()'
148      */

149     public void testValueIterator() {
150         LiteralIterator iter = map.valueIterator(true);
151         for ( int i=0; iter.hasNext(); ++i ) {
152             int val = iter.nextInt();
153             assertEquals(sort[i], val);
154         }
155     }
156
157 }
158
Popular Tags