001    package serp.bytecode.lowlevel;
002    
003    import junit.framework.*;
004    import junit.textui.*;
005    
006    /**
007     * Tests the {@link ConstantPool} type.
008     *
009     * @author Abe White
010     */
011    public class TestConstantPool extends TestCase {
012        private ConstantPool _pool = new ConstantPool();
013        private IntEntry _intEntry = new IntEntry(1);
014        private LongEntry _longEntry = new LongEntry(2L);
015        private UTF8Entry _utf8Entry = new UTF8Entry("4");
016    
017        public TestConstantPool(String test) {
018            super(test);
019        }
020    
021        /**
022         * Tests adding entries.
023         */
024        public void testAdd() {
025            assertEquals(0, _pool.size());
026            assertEquals(1, _pool.addEntry(_intEntry));
027            assertEquals(1, _pool.size());
028            assertEquals(2, _pool.addEntry(_longEntry));
029            assertEquals(3, _pool.size());
030            assertEquals(4, _pool.addEntry(_utf8Entry));
031            assertEquals(4, _pool.size());
032    
033            assertEquals(_intEntry, _pool.getEntry(1));
034            assertEquals(_longEntry, _pool.getEntry(2));
035            assertEquals(_utf8Entry, _pool.getEntry(4));
036            assertEquals(1, _pool.findIntEntry(1, false));
037            assertEquals(2, _pool.findLongEntry(2L, false));
038            assertEquals(4, _pool.findUTF8Entry("4", false));
039    
040            // add an entry multiple times
041            assertEquals(4, _pool.addEntry(_utf8Entry));
042            assertEquals(5, _pool.addEntry(new UTF8Entry("4")));
043    
044            // cannot add to another pool
045            ConstantPool pool = new ConstantPool();
046            try {
047                pool.addEntry(_intEntry);
048                fail("Entry already in another pool");
049            } catch (IllegalStateException ise) {
050            }
051    
052            assertEquals(0, pool.size());
053            _pool.removeEntry(_intEntry);
054            assertEquals(0, _pool.indexOf(_intEntry));
055    
056            pool.addEntry(_intEntry);
057            assertEquals(1, pool.size());
058            assertEquals(_intEntry, pool.getEntry(1));
059        }
060    
061        /**
062         * Tests removing entries.
063         */
064        public void testRemove() {
065            _pool.addEntry(_intEntry);
066            _pool.addEntry(_longEntry);
067            _pool.addEntry(_utf8Entry);
068    
069            assertEquals(4, _pool.size());
070            assertTrue(_pool.removeEntry(_longEntry));
071            assertEquals(2, _pool.size());
072            assertEquals(_intEntry, _pool.getEntry(1));
073            assertEquals(_utf8Entry, _pool.getEntry(2));
074            assertEquals(1, _pool.findIntEntry(1, false));
075            assertEquals(2, _pool.findUTF8Entry("4", false));
076            assertEquals(0, _pool.findLongEntry(2L, false));
077            assertTrue(!_pool.removeEntry(_longEntry));
078    
079            assertTrue(_pool.removeEntry(_intEntry));
080            assertEquals(1, _pool.size());
081            assertEquals(_utf8Entry, _pool.getEntry(1));
082            assertEquals(0, _pool.findIntEntry(1, false));
083            assertEquals(1, _pool.findUTF8Entry("4", false));
084            assertTrue(_pool.removeEntry(_utf8Entry));
085            assertEquals(0, _pool.size());
086            try {
087                _pool.getEntry(1);
088                fail("Invalid index");
089            } catch (IndexOutOfBoundsException ioobe) {
090            }
091            assertEquals(0, _pool.findUTF8Entry("4", false));
092        }
093    
094        /**
095         * Tests mutating entries.
096         */
097        public void testMutate() {
098            _intEntry.setValue(2);
099            _pool.addEntry(_intEntry);
100            _pool.addEntry(_longEntry);
101            _pool.addEntry(_utf8Entry);
102    
103            assertEquals(1, _pool.findIntEntry(2, false));
104            assertEquals(2, _pool.findLongEntry(2L, false));
105            assertEquals(4, _pool.findUTF8Entry("4", false));
106    
107            _intEntry.setValue(1);
108            _longEntry.setValue(3L);
109            _utf8Entry.setValue("foo");
110    
111            assertEquals(1, _pool.findIntEntry(1, false));
112            assertEquals(2, _pool.findLongEntry(3L, false));
113            assertEquals(4, _pool.findUTF8Entry("foo", false));
114        }
115    
116        /**
117         * Tests finding the index of entries.
118         */
119        public void testIndexOf() {
120            _pool.addEntry(_intEntry);
121            _pool.addEntry(_longEntry);
122            _pool.addEntry(_utf8Entry);
123    
124            assertEquals(1, _pool.indexOf(_intEntry));
125            assertEquals(2, _pool.indexOf(_longEntry));
126            assertEquals(4, _pool.indexOf(_utf8Entry));
127    
128            _pool.removeEntry(_longEntry);
129            assertEquals(1, _pool.indexOf(_intEntry));
130            assertEquals(0, _pool.indexOf(_longEntry));
131            assertEquals(2, _pool.indexOf(_utf8Entry));
132        }
133    
134        /**
135         * Tests getting all entries.
136         */
137        public void testGetEntries() {
138            _pool.addEntry(_intEntry);
139            _pool.addEntry(_longEntry);
140            _pool.addEntry(_utf8Entry);
141    
142            Entry[] entries = _pool.getEntries();
143            assertEquals(3, entries.length);
144            assertEquals(_intEntry, entries[0]);
145            assertEquals(_longEntry, entries[1]);
146            assertEquals(_utf8Entry, entries[2]);
147    
148            _pool.clear();
149            assertEquals(0, _pool.getEntries().length);
150        }
151    
152        /**
153         * Tests getting entries by index.
154         */
155        public void testGetEntry() {
156            _pool.addEntry(_intEntry);
157            _pool.addEntry(_longEntry);
158            _pool.addEntry(_utf8Entry);
159    
160            assertEquals(_intEntry, _pool.getEntry(1));
161            assertEquals(_longEntry, _pool.getEntry(2));
162            assertEquals(_utf8Entry, _pool.getEntry(4));
163    
164            try {
165                _pool.getEntry(0);
166                fail("0 index");
167            } catch (IndexOutOfBoundsException ioobe) {
168            }
169    
170            try {
171                _pool.getEntry(_pool.size() + 1);
172                fail("size() + 1 index");
173            } catch (IndexOutOfBoundsException ioobe) {
174            }
175    
176            try {
177                _pool.getEntry(3);
178                fail("Wide index");
179            } catch (IndexOutOfBoundsException ioobe) {
180            }
181        }
182    
183        /**
184         * Test clearing the pool.
185         */
186        public void testClear() {
187            // make sure clearing empty pool OK
188            _pool.clear();
189            assertEquals(0, _pool.size());
190    
191            _pool.addEntry(_intEntry);
192            _pool.addEntry(_longEntry);
193            _pool.addEntry(_utf8Entry);
194    
195            _pool.clear();
196            assertEquals(0, _pool.size());
197            assertEquals(0, _pool.findIntEntry(1, false));
198            assertEquals(0, _pool.findUTF8Entry("4", false));
199        }
200    
201        /**
202         * Test finding entry indexes.
203         */
204        public void testFind() {
205            int double1 = _pool.addEntry(new DoubleEntry(1D));
206            int double2 = _pool.addEntry(new DoubleEntry(2D));
207            int float1 = _pool.addEntry(new FloatEntry(1F));
208            int float2 = _pool.addEntry(new FloatEntry(2F));
209            int int1 = _pool.addEntry(new IntEntry(1));
210            int int2 = _pool.addEntry(new IntEntry(2));
211            int long1 = _pool.addEntry(new LongEntry(1L));
212            int long2 = _pool.addEntry(new LongEntry(2L));
213            int utf1 = _pool.addEntry(new UTF8Entry("1"));
214            int utf2 = _pool.addEntry(new UTF8Entry("2"));
215            int string1 = _pool.addEntry(new StringEntry(utf1));
216            int string2 = _pool.addEntry(new StringEntry(utf2));
217            int class1 = _pool.addEntry(new ClassEntry(utf1));
218            int class2 = _pool.addEntry(new ClassEntry(utf2));
219            int name1 = _pool.addEntry(new NameAndTypeEntry(utf1, utf2));
220            int name2 = _pool.addEntry(new NameAndTypeEntry(utf2, utf1));
221            int field1 = _pool.addEntry(new FieldEntry(class1, name1));
222            int field2 = _pool.addEntry(new FieldEntry(class2, name2));
223            int method1 = _pool.addEntry(new MethodEntry(class1, name1));
224            int method2 = _pool.addEntry(new MethodEntry(class2, name2));
225            int imethod1 = _pool.addEntry(new InterfaceMethodEntry(class1, name1));
226            int imethod2 = _pool.addEntry(new InterfaceMethodEntry(class2, name2));
227    
228            assertEquals(0, _pool.findDoubleEntry(0D, false));
229            assertEquals(double1, _pool.findDoubleEntry(1D, false));
230            assertEquals(double2, _pool.findDoubleEntry(2D, false));
231            assertEquals(double1, _pool.findDoubleEntry(1D, true));
232            assertEquals(double2, _pool.findDoubleEntry(2D, true));
233            assertEquals(_pool.size() + 1, _pool.findDoubleEntry(0D, true));
234    
235            assertEquals(0, _pool.findFloatEntry(0F, false));
236            assertEquals(float1, _pool.findFloatEntry(1F, false));
237            assertEquals(float2, _pool.findFloatEntry(2F, false));
238            assertEquals(float1, _pool.findFloatEntry(1F, true));
239            assertEquals(float2, _pool.findFloatEntry(2F, true));
240            assertEquals(_pool.size() + 1, _pool.findFloatEntry(0F, true));
241    
242            assertEquals(0, _pool.findIntEntry(0, false));
243            assertEquals(int1, _pool.findIntEntry(1, false));
244            assertEquals(int2, _pool.findIntEntry(2, false));
245            assertEquals(int1, _pool.findIntEntry(1, true));
246            assertEquals(int2, _pool.findIntEntry(2, true));
247            assertEquals(_pool.size() + 1, _pool.findIntEntry(0, true));
248    
249            assertEquals(0, _pool.findLongEntry(0L, false));
250            assertEquals(long1, _pool.findLongEntry(1L, false));
251            assertEquals(long2, _pool.findLongEntry(2L, false));
252            assertEquals(long1, _pool.findLongEntry(1L, true));
253            assertEquals(long2, _pool.findLongEntry(2L, true));
254            assertEquals(_pool.size() + 1, _pool.findLongEntry(0L, true));
255    
256            assertEquals(0, _pool.findUTF8Entry("0", false));
257            assertEquals(utf1, _pool.findUTF8Entry("1", false));
258            assertEquals(utf2, _pool.findUTF8Entry("2", false));
259            assertEquals(utf1, _pool.findUTF8Entry("1", true));
260            assertEquals(utf2, _pool.findUTF8Entry("2", true));
261            assertEquals(_pool.size() + 1, _pool.findUTF8Entry("0", true));
262    
263            assertEquals(0, _pool.findStringEntry("0", false));
264            assertEquals(string1, _pool.findStringEntry("1", false));
265            assertEquals(string2, _pool.findStringEntry("2", false));
266            assertEquals(string1, _pool.findStringEntry("1", true));
267            assertEquals(string2, _pool.findStringEntry("2", true));
268            assertEquals(_pool.size() + 1, _pool.findStringEntry("0", true));
269            assertEquals(_pool.size() + 2, _pool.findStringEntry("aaa", true));
270    
271            assertEquals(0, _pool.findClassEntry("0", false));
272            assertEquals(class1, _pool.findClassEntry("1", false));
273            assertEquals(class2, _pool.findClassEntry("2", false));
274            assertEquals(class1, _pool.findClassEntry("1", true));
275            assertEquals(class2, _pool.findClassEntry("2", true));
276            assertEquals(_pool.size() + 1, _pool.findClassEntry("0", true));
277            assertEquals(_pool.size() + 2, _pool.findStringEntry("bbb", true));
278    
279            assertEquals(0, _pool.findNameAndTypeEntry("0", "1", false));
280            assertEquals(name1, _pool.findNameAndTypeEntry("1", "2", false));
281            assertEquals(name2, _pool.findNameAndTypeEntry("2", "1", false));
282            assertEquals(name1, _pool.findNameAndTypeEntry("1", "2", true));
283            assertEquals(name2, _pool.findNameAndTypeEntry("2", "1", true));
284            assertEquals(_pool.size() + 1,
285                _pool.findNameAndTypeEntry("0", "1", true));
286            assertEquals(_pool.size() + 2,
287                _pool.findNameAndTypeEntry("2", "3", true));
288            assertEquals(_pool.size() + 3,
289                _pool.findNameAndTypeEntry("ccc", "ddd", true));
290    
291            assertEquals(0, _pool.findFieldEntry("0", "1", "2", false));
292            assertEquals(field1, _pool.findFieldEntry("1", "1", "2", false));
293            assertEquals(field2, _pool.findFieldEntry("2", "2", "1", false));
294            assertEquals(field1, _pool.findFieldEntry("1", "1", "2", true));
295            assertEquals(field2, _pool.findFieldEntry("2", "2", "1", true));
296            assertEquals(_pool.size() + 1, 
297                _pool.findFieldEntry("1", "2", "1", true));
298            assertEquals(_pool.size() + 3, 
299                _pool.findFieldEntry("1", "3", "4", true));
300            assertEquals(_pool.size() + 6,
301                _pool.findFieldEntry("eee", "fff", "ggg", true));
302    
303            assertEquals(0, _pool.findMethodEntry("0", "1", "2", false));
304            assertEquals(method1, _pool.findMethodEntry("1", "1", "2", false));
305            assertEquals(method2, _pool.findMethodEntry("2", "2", "1", false));
306            assertEquals(method1, _pool.findMethodEntry("1", "1", "2", true));
307            assertEquals(method2, _pool.findMethodEntry("2", "2", "1", true));
308            assertEquals(_pool.size() + 1,
309                _pool.findMethodEntry("1", "2", "1", true));
310            assertEquals(_pool.size() + 3,
311                _pool.findMethodEntry("1", "3", "5", true));
312            assertEquals(_pool.size() + 6,
313                _pool.findMethodEntry("hhh", "iii", "jjj", true));
314    
315            assertEquals(0, _pool.findInterfaceMethodEntry("0", "1", "2", false));
316            assertEquals(imethod1,
317                _pool.findInterfaceMethodEntry("1", "1", "2", false));
318            assertEquals(imethod2,
319                _pool.findInterfaceMethodEntry("2", "2", "1", false));
320            assertEquals(imethod1,
321                _pool.findInterfaceMethodEntry("1", "1", "2", true));
322            assertEquals(imethod2,
323                _pool.findInterfaceMethodEntry("2", "2", "1", true));
324            assertEquals(_pool.size() + 1,
325                _pool.findInterfaceMethodEntry("1", "2", "1", true));
326            assertEquals(_pool.size() + 3,
327                _pool.findInterfaceMethodEntry("1", "3", "6", true));
328            assertEquals(_pool.size() + 6,
329                _pool.findInterfaceMethodEntry("kkk", "lll", "mmm", true));
330        }
331    
332        public static Test suite() {
333            return new TestSuite(TestConstantPool.class);
334        }
335    
336        public static void main(String[] args) {
337            TestRunner.run(suite());
338        }
339    }