001: ///////////////////////////////////////////////////////////////////////////////
002: // Copyright (c) 2001-2006, Eric D. Friedman All Rights Reserved.
003: //
004: // This library is free software; you can redistribute it and/or
005: // modify it under the terms of the GNU Lesser General Public
006: // License as published by the Free Software Foundation; either
007: // version 2.1 of the License, or (at your option) any later version.
008: //
009: // This library is distributed in the hope that it will be useful,
010: // but WITHOUT ANY WARRANTY; without even the implied warranty of
011: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
012: // GNU General Public License for more details.
013: //
014: // You should have received a copy of the GNU Lesser General Public
015: // License along with this program; if not, write to the Free Software
016: // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
017: ///////////////////////////////////////////////////////////////////////////////
018: package gnu.trove;
019:
020: import gnu.trove.decorator.TObjectIntHashMapDecorator;
021: import junit.framework.TestCase;
022:
023: import java.util.*;
024:
025: /**
026: *
027: */
028: public class O2PHashMapTest extends TestCase {
029:
030: public O2PHashMapTest(String name) {
031: super (name);
032: }
033:
034: public void testKeys() {
035: TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
036:
037: map.put("one", 1);
038: map.put("two", 2);
039:
040: assertEquals(2, map.size());
041:
042: String[] keys = map.keys(new String[map.size()]);
043: assertEquals(2, keys.length);
044: List<String> keys_list = Arrays.asList(keys);
045:
046: assertTrue(keys_list.contains("one"));
047: assertTrue(keys_list.contains("two"));
048:
049: Object[] keys2 = map.keys();
050: assertEquals(2, keys2.length);
051: List keys_list2 = Arrays.asList(keys2);
052:
053: assertTrue(keys_list2.contains("one"));
054: assertTrue(keys_list2.contains("two"));
055: }
056:
057: public void testDecorator() {
058: TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
059:
060: map.put("one", 1);
061: map.put("two", 2);
062:
063: Map<String, Integer> decorator = new TObjectIntHashMapDecorator<String>(
064: map);
065:
066: assertEquals(2, decorator.size());
067: assertEquals(Integer.valueOf(1), decorator.get("one"));
068: assertEquals(Integer.valueOf(2), decorator.get("two"));
069:
070: Set<String> decorator_keys = decorator.keySet();
071: assertEquals(2, decorator_keys.size());
072: Iterator<String> it = decorator_keys.iterator();
073: int count = 0;
074: while (it.hasNext()) {
075: count++;
076: System.out.println(it.next());
077: }
078: assertEquals(2, count);
079:
080: assertSame(map, ((TObjectIntHashMapDecorator) decorator)
081: .getMap());
082: }
083:
084: public void testIterator() {
085: TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
086:
087: TObjectIntIterator<String> iterator = map.iterator();
088: assertFalse(iterator.hasNext());
089:
090: map.put("one", 1);
091: map.put("two", 2);
092:
093: iterator = map.iterator();
094: assertTrue(iterator.hasNext());
095: iterator.advance();
096: assertTrue(iterator.hasNext());
097: iterator.advance();
098: assertFalse(iterator.hasNext());
099: }
100:
101: public void testIteratorRemoval() {
102: TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
103:
104: map.put("one", 1);
105: map.put("two", 2);
106: map.put("three", 3);
107: map.put("four", 4);
108: map.put("five", 5);
109: map.put("six", 6);
110: map.put("seven", 7);
111: map.put("eight", 8);
112: map.put("nine", 9);
113: map.put("ten", 10);
114:
115: TObjectIntIterator<String> iterator = map.iterator();
116: while (map.size() > 5 && iterator.hasNext()) {
117: iterator.advance();
118: iterator.remove();
119: }
120:
121: assertEquals(5, map.size());
122: iterator = map.iterator();
123: assertTrue(iterator.hasNext());
124: iterator.advance();
125: assertTrue(iterator.hasNext());
126: iterator.advance();
127: assertTrue(iterator.hasNext());
128: iterator.advance();
129: assertTrue(iterator.hasNext());
130: iterator.advance();
131: assertTrue(iterator.hasNext());
132: iterator.advance();
133: assertFalse(iterator.hasNext());
134:
135: iterator = map.iterator();
136: while (iterator.hasNext()) {
137: iterator.advance();
138: iterator.remove();
139: }
140:
141: assertEquals(0, map.size());
142: }
143:
144: public void testIteratorRemoval2() {
145: TIntObjectHashMap<String> map = new TIntObjectHashMap<String>(
146: 10000, 0.5f);
147:
148: for (int pass = 0; pass < 10; pass++) {
149: System.out.println("Test");
150: Random r = new Random();
151: System.out.println("ADD");
152: for (int i = 0; i <= 10000; i++) {
153: map.put(r.nextInt(), "Test" + i);
154: }
155:
156: System.out.println("REMOVE");
157: TIntObjectIterator iterator = map.iterator();
158: while (map.size() > 5000 && iterator.hasNext()) {
159: iterator.advance();
160: iterator.remove();
161: }
162: }
163: }
164:
165: public void testAdjustValue() {
166: TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
167:
168: map.put("one", 1);
169:
170: boolean changed = map.adjustValue("one", 1);
171: assertTrue(changed);
172: assertEquals(2, map.get("one"));
173:
174: changed = map.adjustValue("one", 5);
175: assertTrue(changed);
176: assertEquals(7, map.get("one"));
177:
178: changed = map.adjustValue("one", -3);
179: assertTrue(changed);
180: assertEquals(4, map.get("one"));
181:
182: changed = map.adjustValue("two", 1);
183: assertFalse(changed);
184: assertFalse(map.containsKey("two"));
185: }
186:
187: public void testAdjustOrPutValue() {
188: TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
189:
190: map.put("one", 1);
191:
192: long new_value = map.adjustOrPutValue("one", 1, 100);
193: assertEquals(2, new_value);
194: assertEquals(2, map.get("one"));
195:
196: new_value = map.adjustOrPutValue("one", 5, 100);
197: assertEquals(7, new_value);
198: assertEquals(7, map.get("one"));
199:
200: new_value = map.adjustOrPutValue("one", -3, 100);
201: assertEquals(4, new_value);
202: assertEquals(4, map.get("one"));
203:
204: new_value = map.adjustOrPutValue("two", 1, 100);
205: assertEquals(100, new_value);
206: assertTrue(map.containsKey("two"));
207: assertEquals(100, map.get("two"));
208:
209: new_value = map.adjustOrPutValue("two", 1, 100);
210: assertEquals(101, new_value);
211: assertEquals(101, map.get("two"));
212: }
213:
214: public void testRetain() {
215: TObjectIntHashMap<String> map = new TObjectIntHashMap<String>();
216:
217: map.put("one", 1);
218: map.put("two", 2);
219: map.put("three", 3);
220: map.put("four", 4);
221: map.put("five", 5);
222: map.put("six", 6);
223: map.put("seven", 7);
224: map.put("eight", 8);
225: map.put("nine", 9);
226: map.put("ten", 10);
227:
228: System.out.println("Start retain...");
229: map.retainEntries(new TObjectIntProcedure<String>() {
230: public boolean execute(String a, int b) {
231: if (b <= 5)
232: return false;
233: if (b > 8)
234: return false;
235:
236: return true;
237: }
238: });
239: System.out.println("... end retain");
240:
241: assertEquals(3, map.size());
242: assertFalse(map.containsKey("one"));
243: assertFalse(map.containsKey("two"));
244: assertFalse(map.containsKey("three"));
245: assertFalse(map.containsKey("four"));
246: assertFalse(map.containsKey("five"));
247: assertTrue(map.containsKey("six"));
248: assertTrue(map.containsKey("seven"));
249: assertTrue(map.containsKey("eight"));
250: assertFalse(map.containsKey("nine"));
251: assertFalse(map.containsKey("ten"));
252:
253: map.put("eleven", 11);
254: map.put("twelve", 12);
255: map.put("thirteen", 13);
256: map.put("fourteen", 14);
257: map.put("fifteen", 15);
258: map.put("sixteen", 16);
259: map.put("seventeen", 17);
260: map.put("eighteen", 18);
261: map.put("nineteen", 19);
262: map.put("twenty", 20);
263:
264: System.out.println("Start retain...");
265: map.retainEntries(new TObjectIntProcedure<String>() {
266: public boolean execute(String a, int b) {
267: if (b <= 15)
268: return false;
269:
270: return true;
271: }
272: });
273: System.out.println("... end retain");
274:
275: assertEquals(5, map.size());
276: assertFalse(map.containsKey("one"));
277: assertFalse(map.containsKey("two"));
278: assertFalse(map.containsKey("three"));
279: assertFalse(map.containsKey("four"));
280: assertFalse(map.containsKey("five"));
281: assertFalse(map.containsKey("six"));
282: assertFalse(map.containsKey("seven"));
283: assertFalse(map.containsKey("eight"));
284: assertFalse(map.containsKey("nine"));
285: assertFalse(map.containsKey("ten"));
286: assertFalse(map.containsKey("eleven"));
287: assertFalse(map.containsKey("twelve"));
288: assertFalse(map.containsKey("thirteen"));
289: assertFalse(map.containsKey("fourteen"));
290: assertFalse(map.containsKey("fifteen"));
291: assertTrue(map.containsKey("sixteen"));
292: assertTrue(map.containsKey("seventeen"));
293: assertTrue(map.containsKey("eighteen"));
294: assertTrue(map.containsKey("nineteen"));
295: assertTrue(map.containsKey("twenty"));
296:
297: System.out.println("Start retain...");
298: map.retainEntries(new TObjectIntProcedure<String>() {
299: public boolean execute(String a, int b) {
300: return false;
301: }
302: });
303: System.out.println("... end retain");
304:
305: System.out.println("Retain test done");
306:
307: assertEquals(0, map.size());
308: }
309: }
|