001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package org.apache.harmony.luni.tests.java.util;
019:
020: import java.util.AbstractMap;
021: import java.util.ArrayList;
022: import java.util.Arrays;
023: import java.util.Collection;
024: import java.util.Iterator;
025: import java.util.LinkedHashMap;
026: import java.util.Map;
027: import java.util.Set;
028: import java.util.TreeMap;
029:
030: import tests.support.Support_MapTest2;
031: import tests.support.Support_UnmodifiableCollectionTest;
032:
033: /**
034: * @tests java.util.LinkedHashMap
035: */
036: public class LinkedHashMapTest extends junit.framework.TestCase {
037:
038: LinkedHashMap hm;
039:
040: final static int hmSize = 1000;
041:
042: static Object[] objArray;
043:
044: static Object[] objArray2;
045: {
046: objArray = new Object[hmSize];
047: objArray2 = new Object[hmSize];
048: for (int i = 0; i < objArray.length; i++) {
049: objArray[i] = new Integer(i);
050: objArray2[i] = objArray[i].toString();
051: }
052: }
053:
054: static final class CacheMap extends LinkedHashMap {
055: protected boolean removeEldestEntry(Map.Entry e) {
056: return size() > 5;
057: }
058: }
059:
060: private static class MockMapNull extends AbstractMap {
061: @Override
062: public Set entrySet() {
063: return null;
064: }
065:
066: @Override
067: public int size() {
068: return 10;
069: }
070: }
071:
072: /**
073: * @tests java.util.LinkedHashMap#LinkedHashMap()
074: */
075: public void test_Constructor() {
076: // Test for method java.util.LinkedHashMap()
077: new Support_MapTest2(new LinkedHashMap()).runTest();
078:
079: LinkedHashMap hm2 = new LinkedHashMap();
080: assertEquals("Created incorrect LinkedHashMap", 0, hm2.size());
081: }
082:
083: /**
084: * @tests java.util.LinkedHashMap#LinkedHashMap(int)
085: */
086: public void test_ConstructorI() {
087: // Test for method java.util.LinkedHashMap(int)
088: LinkedHashMap hm2 = new LinkedHashMap(5);
089: assertEquals("Created incorrect LinkedHashMap", 0, hm2.size());
090: try {
091: new LinkedHashMap(-1);
092: } catch (IllegalArgumentException e) {
093: return;
094: }
095: fail("Failed to throw IllegalArgumentException for initial capacity < 0");
096:
097: LinkedHashMap empty = new LinkedHashMap(0);
098: assertNull("Empty LinkedHashMap access", empty.get("nothing"));
099: empty.put("something", "here");
100: assertTrue("cannot get element",
101: empty.get("something") == "here");
102: }
103:
104: /**
105: * @tests java.util.LinkedHashMap#LinkedHashMap(int, float)
106: */
107: public void test_ConstructorIF() {
108: // Test for method java.util.LinkedHashMap(int, float)
109: LinkedHashMap hm2 = new LinkedHashMap(5, (float) 0.5);
110: assertEquals("Created incorrect LinkedHashMap", 0, hm2.size());
111: try {
112: new LinkedHashMap(0, 0);
113: } catch (IllegalArgumentException e) {
114: return;
115: }
116: fail("Failed to throw IllegalArgumentException for initial load factor <= 0");
117: LinkedHashMap empty = new LinkedHashMap(0, 0.75f);
118: assertNull("Empty hashtable access", empty.get("nothing"));
119: empty.put("something", "here");
120: assertTrue("cannot get element",
121: empty.get("something") == "here");
122: }
123:
124: /**
125: * @tests java.util.LinkedHashMap#LinkedHashMap(java.util.Map)
126: */
127: public void test_ConstructorLjava_util_Map() {
128: // Test for method java.util.LinkedHashMap(java.util.Map)
129: Map myMap = new TreeMap();
130: for (int counter = 0; counter < hmSize; counter++)
131: myMap.put(objArray2[counter], objArray[counter]);
132: LinkedHashMap hm2 = new LinkedHashMap(myMap);
133: for (int counter = 0; counter < hmSize; counter++)
134: assertTrue("Failed to construct correct LinkedHashMap", hm
135: .get(objArray2[counter]) == hm2
136: .get(objArray2[counter]));
137: }
138:
139: /**
140: * @tests java.util.LinkedHashMap#get(java.lang.Object)
141: */
142: public void test_getLjava_lang_Object() {
143: // Test for method java.lang.Object
144: // java.util.LinkedHashMap.get(java.lang.Object)
145: assertNull("Get returned non-null for non existent key", hm
146: .get("T"));
147: hm.put("T", "HELLO");
148: assertEquals("Get returned incorecct value for existing key",
149: "HELLO", hm.get("T"));
150:
151: LinkedHashMap m = new LinkedHashMap();
152: m.put(null, "test");
153: assertEquals("Failed with null key", "test", m.get(null));
154: assertNull("Failed with missing key matching null hash", m
155: .get(new Integer(0)));
156: }
157:
158: /**
159: * @tests java.util.LinkedHashMap#put(java.lang.Object, java.lang.Object)
160: */
161: public void test_putLjava_lang_ObjectLjava_lang_Object() {
162: // Test for method java.lang.Object
163: // java.util.LinkedHashMap.put(java.lang.Object, java.lang.Object)
164: hm.put("KEY", "VALUE");
165: assertEquals("Failed to install key/value pair", "VALUE", hm
166: .get("KEY"));
167:
168: LinkedHashMap m = new LinkedHashMap();
169: m.put(new Short((short) 0), "short");
170: m.put(null, "test");
171: m.put(new Integer(0), "int");
172: assertEquals("Failed adding to bucket containing null",
173: "short", m.get(new Short((short) 0)));
174: assertEquals("Failed adding to bucket containing null2", "int",
175: m.get(new Integer(0)));
176: }
177:
178: /**
179: * @tests java.util.LinkedHashMap#putAll(java.util.Map)
180: */
181: public void test_putAllLjava_util_Map() {
182: // Test for method void java.util.LinkedHashMap.putAll(java.util.Map)
183: LinkedHashMap hm2 = new LinkedHashMap();
184: hm2.putAll(hm);
185: for (int i = 0; i < 1000; i++)
186: assertTrue("Failed to clear all elements", hm2.get(
187: new Integer(i).toString()).equals((new Integer(i))));
188: }
189:
190: /**
191: * @tests java.util.LinkedHashMap#putAll(java.util.Map)
192: */
193: public void test_putAll_Ljava_util_Map_Null() {
194: LinkedHashMap linkedHashMap = new LinkedHashMap();
195: try {
196: linkedHashMap.putAll(new MockMapNull());
197: fail("Should throw NullPointerException");
198: } catch (NullPointerException e) {
199: // expected.
200: }
201:
202: try {
203: linkedHashMap = new LinkedHashMap(new MockMapNull());
204: fail("Should throw NullPointerException");
205: } catch (NullPointerException e) {
206: // expected.
207: }
208: }
209:
210: /**
211: * @tests java.util.LinkedHashMap#entrySet()
212: */
213: public void test_entrySet() {
214: // Test for method java.util.Set java.util.LinkedHashMap.entrySet()
215: Set s = hm.entrySet();
216: Iterator i = s.iterator();
217: assertTrue("Returned set of incorrect size", hm.size() == s
218: .size());
219: while (i.hasNext()) {
220: Map.Entry m = (Map.Entry) i.next();
221: assertTrue("Returned incorrect entry set", hm.containsKey(m
222: .getKey())
223: && hm.containsValue(m.getValue()));
224: }
225: }
226:
227: /**
228: * @tests java.util.LinkedHashMap#keySet()
229: */
230: public void test_keySet() {
231: // Test for method java.util.Set java.util.LinkedHashMap.keySet()
232: Set s = hm.keySet();
233: assertTrue("Returned set of incorrect size()", s.size() == hm
234: .size());
235: for (int i = 0; i < objArray.length; i++)
236: assertTrue("Returned set does not contain all keys", s
237: .contains(objArray[i].toString()));
238:
239: LinkedHashMap m = new LinkedHashMap();
240: m.put(null, "test");
241: assertTrue("Failed with null key", m.keySet().contains(null));
242: assertNull("Failed with null key", m.keySet().iterator().next());
243:
244: Map map = new LinkedHashMap(101);
245: map.put(new Integer(1), "1");
246: map.put(new Integer(102), "102");
247: map.put(new Integer(203), "203");
248: Iterator it = map.keySet().iterator();
249: Integer remove1 = (Integer) it.next();
250: it.hasNext();
251: it.remove();
252: Integer remove2 = (Integer) it.next();
253: it.remove();
254: ArrayList list = new ArrayList(Arrays.asList(new Integer[] {
255: new Integer(1), new Integer(102), new Integer(203) }));
256: list.remove(remove1);
257: list.remove(remove2);
258: assertTrue("Wrong result", it.next().equals(list.get(0)));
259: assertEquals("Wrong size", 1, map.size());
260: assertTrue("Wrong contents", map.keySet().iterator().next()
261: .equals(list.get(0)));
262:
263: Map map2 = new LinkedHashMap(101);
264: map2.put(new Integer(1), "1");
265: map2.put(new Integer(4), "4");
266: Iterator it2 = map2.keySet().iterator();
267: Integer remove3 = (Integer) it2.next();
268: Integer next;
269: if (remove3.intValue() == 1)
270: next = new Integer(4);
271: else
272: next = new Integer(1);
273: it2.hasNext();
274: it2.remove();
275: assertTrue("Wrong result 2", it2.next().equals(next));
276: assertEquals("Wrong size 2", 1, map2.size());
277: assertTrue("Wrong contents 2", map2.keySet().iterator().next()
278: .equals(next));
279: }
280:
281: /**
282: * @tests java.util.LinkedHashMap#values()
283: */
284: public void test_values() {
285: // Test for method java.util.Collection java.util.LinkedHashMap.values()
286: Collection c = hm.values();
287: assertTrue("Returned collection of incorrect size()",
288: c.size() == hm.size());
289: for (int i = 0; i < objArray.length; i++)
290: assertTrue("Returned collection does not contain all keys",
291: c.contains(objArray[i]));
292:
293: LinkedHashMap myLinkedHashMap = new LinkedHashMap();
294: for (int i = 0; i < 100; i++)
295: myLinkedHashMap.put(objArray2[i], objArray[i]);
296: Collection values = myLinkedHashMap.values();
297: new Support_UnmodifiableCollectionTest(
298: "Test Returned Collection From LinkedHashMap.values()",
299: values).runTest();
300: values.remove(new Integer(0));
301: assertTrue(
302: "Removing from the values collection should remove from the original map",
303: !myLinkedHashMap.containsValue(new Integer(0)));
304:
305: }
306:
307: /**
308: * @tests java.util.LinkedHashMap#remove(java.lang.Object)
309: */
310: public void test_removeLjava_lang_Object() {
311: // Test for method java.lang.Object
312: // java.util.LinkedHashMap.remove(java.lang.Object)
313: int size = hm.size();
314: Integer y = new Integer(9);
315: Integer x = ((Integer) hm.remove(y.toString()));
316: assertTrue("Remove returned incorrect value", x
317: .equals(new Integer(9)));
318: assertNull("Failed to remove given key", hm.get(new Integer(9)));
319: assertTrue("Failed to decrement size", hm.size() == (size - 1));
320: assertNull("Remove of non-existent key returned non-null", hm
321: .remove("LCLCLC"));
322:
323: LinkedHashMap m = new LinkedHashMap();
324: m.put(null, "test");
325: assertNull("Failed with same hash as null", m
326: .remove(new Integer(0)));
327: assertEquals("Failed with null key", "test", m.remove(null));
328: }
329:
330: /**
331: * @tests java.util.LinkedHashMap#clear()
332: */
333: public void test_clear() {
334: // Test for method void java.util.LinkedHashMap.clear()
335: hm.clear();
336: assertEquals("Clear failed to reset size", 0, hm.size());
337: for (int i = 0; i < hmSize; i++)
338: assertNull("Failed to clear all elements", hm
339: .get(objArray2[i]));
340:
341: }
342:
343: /**
344: * @tests java.util.LinkedHashMap#clone()
345: */
346: public void test_clone() {
347: // Test for method java.lang.Object java.util.LinkedHashMap.clone()
348: LinkedHashMap hm2 = (LinkedHashMap) hm.clone();
349: assertTrue("Clone answered equivalent LinkedHashMap", hm2 != hm);
350: for (int counter = 0; counter < hmSize; counter++)
351: assertTrue("Clone answered unequal LinkedHashMap", hm
352: .get(objArray2[counter]) == hm2
353: .get(objArray2[counter]));
354:
355: LinkedHashMap map = new LinkedHashMap();
356: map.put("key", "value");
357: // get the keySet() and values() on the original Map
358: Set keys = map.keySet();
359: Collection values = map.values();
360: assertEquals("values() does not work", "value", values
361: .iterator().next());
362: assertEquals("keySet() does not work", "key", keys.iterator()
363: .next());
364: AbstractMap map2 = (AbstractMap) map.clone();
365: map2.put("key", "value2");
366: Collection values2 = map2.values();
367: assertTrue("values() is identical", values2 != values);
368:
369: // values() and keySet() on the cloned() map should be different
370: assertEquals("values() was not cloned", "value2", values2
371: .iterator().next());
372: map2.clear();
373: map2.put("key2", "value3");
374: Set key2 = map2.keySet();
375: assertTrue("keySet() is identical", key2 != keys);
376: assertEquals("keySet() was not cloned", "key2", key2.iterator()
377: .next());
378: }
379:
380: // regresion test for HARMONY-4603
381: public void test_clone_Mock() {
382: LinkedHashMap hashMap = new MockMap();
383: String value = "value a";
384: hashMap.put("key", value);
385: MockMap cloneMap = (MockMap) hashMap.clone();
386: assertEquals(value, cloneMap.get("key"));
387: assertEquals(hashMap, cloneMap);
388: assertEquals(1, cloneMap.num);
389:
390: hashMap.put("key", "value b");
391: assertFalse(hashMap.equals(cloneMap));
392: }
393:
394: class MockMap extends LinkedHashMap {
395: int num;
396:
397: public Object put(Object k, Object v) {
398: num++;
399: return super .put(k, v);
400: }
401:
402: protected boolean removeEldestEntry(Map.Entry e) {
403: return num > 1;
404: }
405: }
406:
407: /**
408: * @tests java.util.LinkedHashMap#containsKey(java.lang.Object)
409: */
410: public void test_containsKeyLjava_lang_Object() {
411: // Test for method boolean
412: // java.util.LinkedHashMap.containsKey(java.lang.Object)
413: assertTrue("Returned false for valid key", hm
414: .containsKey(new Integer(876).toString()));
415: assertTrue("Returned true for invalid key", !hm
416: .containsKey("KKDKDKD"));
417:
418: LinkedHashMap m = new LinkedHashMap();
419: m.put(null, "test");
420: assertTrue("Failed with null key", m.containsKey(null));
421: assertTrue("Failed with missing key matching null hash", !m
422: .containsKey(new Integer(0)));
423: }
424:
425: /**
426: * @tests java.util.LinkedHashMap#containsValue(java.lang.Object)
427: */
428: public void test_containsValueLjava_lang_Object() {
429: // Test for method boolean
430: // java.util.LinkedHashMap.containsValue(java.lang.Object)
431: assertTrue("Returned false for valid value", hm
432: .containsValue(new Integer(875)));
433: assertTrue("Returned true for invalid valie", !hm
434: .containsValue(new Integer(-9)));
435: }
436:
437: /**
438: * @tests java.util.LinkedHashMap#isEmpty()
439: */
440: public void test_isEmpty() {
441: // Test for method boolean java.util.LinkedHashMap.isEmpty()
442: assertTrue("Returned false for new map", new LinkedHashMap()
443: .isEmpty());
444: assertTrue("Returned true for non-empty", !hm.isEmpty());
445: }
446:
447: /**
448: * @tests java.util.LinkedHashMap#size()
449: */
450: public void test_size() {
451: // Test for method int java.util.LinkedHashMap.size()
452: assertTrue("Returned incorrect size",
453: hm.size() == (objArray.length + 2));
454: }
455:
456: /**
457: * @tests java.util.LinkedHashMap#entrySet()
458: */
459: public void test_ordered_entrySet() {
460: int i;
461: int sz = 100;
462: LinkedHashMap lhm = new LinkedHashMap();
463: for (i = 0; i < sz; i++) {
464: Integer ii = new Integer(i);
465: lhm.put(ii, ii.toString());
466: }
467:
468: Set s1 = lhm.entrySet();
469: Iterator it1 = s1.iterator();
470: assertTrue("Returned set of incorrect size 1", lhm.size() == s1
471: .size());
472: for (i = 0; it1.hasNext(); i++) {
473: Map.Entry m = (Map.Entry) it1.next();
474: Integer jj = (Integer) m.getKey();
475: assertTrue("Returned incorrect entry set 1",
476: jj.intValue() == i);
477: }
478:
479: LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true);
480: for (i = 0; i < sz; i++) {
481: Integer ii = new Integer(i);
482: lruhm.put(ii, ii.toString());
483: }
484:
485: Set s3 = lruhm.entrySet();
486: Iterator it3 = s3.iterator();
487: assertTrue("Returned set of incorrect size 2",
488: lruhm.size() == s3.size());
489: for (i = 0; i < sz && it3.hasNext(); i++) {
490: Map.Entry m = (Map.Entry) it3.next();
491: Integer jj = (Integer) m.getKey();
492: assertTrue("Returned incorrect entry set 2",
493: jj.intValue() == i);
494: }
495:
496: /* fetch the even numbered entries to affect traversal order */
497: int p = 0;
498: for (i = 0; i < sz; i += 2) {
499: String ii = (String) lruhm.get(new Integer(i));
500: p = p + Integer.parseInt(ii);
501: }
502: assertEquals("invalid sum of even numbers", 2450, p);
503:
504: Set s2 = lruhm.entrySet();
505: Iterator it2 = s2.iterator();
506: assertTrue("Returned set of incorrect size 3",
507: lruhm.size() == s2.size());
508: for (i = 1; i < sz && it2.hasNext(); i += 2) {
509: Map.Entry m = (Map.Entry) it2.next();
510: Integer jj = (Integer) m.getKey();
511: assertTrue("Returned incorrect entry set 3",
512: jj.intValue() == i);
513: }
514: for (i = 0; i < sz && it2.hasNext(); i += 2) {
515: Map.Entry m = (Map.Entry) it2.next();
516: Integer jj = (Integer) m.getKey();
517: assertTrue("Returned incorrect entry set 4",
518: jj.intValue() == i);
519: }
520: assertTrue("Entries left to iterate on", !it2.hasNext());
521: }
522:
523: /**
524: * @tests java.util.LinkedHashMap#keySet()
525: */
526: public void test_ordered_keySet() {
527: int i;
528: int sz = 100;
529: LinkedHashMap lhm = new LinkedHashMap();
530: for (i = 0; i < sz; i++) {
531: Integer ii = new Integer(i);
532: lhm.put(ii, ii.toString());
533: }
534:
535: Set s1 = lhm.keySet();
536: Iterator it1 = s1.iterator();
537: assertTrue("Returned set of incorrect size", lhm.size() == s1
538: .size());
539: for (i = 0; it1.hasNext(); i++) {
540: Integer jj = (Integer) it1.next();
541: assertTrue("Returned incorrect entry set",
542: jj.intValue() == i);
543: }
544:
545: LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true);
546: for (i = 0; i < sz; i++) {
547: Integer ii = new Integer(i);
548: lruhm.put(ii, ii.toString());
549: }
550:
551: Set s3 = lruhm.keySet();
552: Iterator it3 = s3.iterator();
553: assertTrue("Returned set of incorrect size", lruhm.size() == s3
554: .size());
555: for (i = 0; i < sz && it3.hasNext(); i++) {
556: Integer jj = (Integer) it3.next();
557: assertTrue("Returned incorrect entry set",
558: jj.intValue() == i);
559: }
560:
561: /* fetch the even numbered entries to affect traversal order */
562: int p = 0;
563: for (i = 0; i < sz; i += 2) {
564: String ii = (String) lruhm.get(new Integer(i));
565: p = p + Integer.parseInt(ii);
566: }
567: assertEquals("invalid sum of even numbers", 2450, p);
568:
569: Set s2 = lruhm.keySet();
570: Iterator it2 = s2.iterator();
571: assertTrue("Returned set of incorrect size", lruhm.size() == s2
572: .size());
573: for (i = 1; i < sz && it2.hasNext(); i += 2) {
574: Integer jj = (Integer) it2.next();
575: assertTrue("Returned incorrect entry set",
576: jj.intValue() == i);
577: }
578: for (i = 0; i < sz && it2.hasNext(); i += 2) {
579: Integer jj = (Integer) it2.next();
580: assertTrue("Returned incorrect entry set",
581: jj.intValue() == i);
582: }
583: assertTrue("Entries left to iterate on", !it2.hasNext());
584: }
585:
586: /**
587: * @tests java.util.LinkedHashMap#values()
588: */
589: public void test_ordered_values() {
590: int i;
591: int sz = 100;
592: LinkedHashMap lhm = new LinkedHashMap();
593: for (i = 0; i < sz; i++) {
594: Integer ii = new Integer(i);
595: lhm.put(ii, new Integer(i * 2));
596: }
597:
598: Collection s1 = lhm.values();
599: Iterator it1 = s1.iterator();
600: assertTrue("Returned set of incorrect size 1", lhm.size() == s1
601: .size());
602: for (i = 0; it1.hasNext(); i++) {
603: Integer jj = (Integer) it1.next();
604: assertTrue("Returned incorrect entry set 1",
605: jj.intValue() == i * 2);
606: }
607:
608: LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true);
609: for (i = 0; i < sz; i++) {
610: Integer ii = new Integer(i);
611: lruhm.put(ii, new Integer(i * 2));
612: }
613:
614: Collection s3 = lruhm.values();
615: Iterator it3 = s3.iterator();
616: assertTrue("Returned set of incorrect size", lruhm.size() == s3
617: .size());
618: for (i = 0; i < sz && it3.hasNext(); i++) {
619: Integer jj = (Integer) it3.next();
620: assertTrue("Returned incorrect entry set",
621: jj.intValue() == i * 2);
622: }
623:
624: // fetch the even numbered entries to affect traversal order
625: int p = 0;
626: for (i = 0; i < sz; i += 2) {
627: Integer ii = (Integer) lruhm.get(new Integer(i));
628: p = p + ii.intValue();
629: }
630: assertTrue("invalid sum of even numbers", p == 2450 * 2);
631:
632: Collection s2 = lruhm.values();
633: Iterator it2 = s2.iterator();
634: assertTrue("Returned set of incorrect size", lruhm.size() == s2
635: .size());
636: for (i = 1; i < sz && it2.hasNext(); i += 2) {
637: Integer jj = (Integer) it2.next();
638: assertTrue("Returned incorrect entry set",
639: jj.intValue() == i * 2);
640: }
641: for (i = 0; i < sz && it2.hasNext(); i += 2) {
642: Integer jj = (Integer) it2.next();
643: assertTrue("Returned incorrect entry set",
644: jj.intValue() == i * 2);
645: }
646: assertTrue("Entries left to iterate on", !it2.hasNext());
647: }
648:
649: /**
650: * @tests java.util.LinkedHashMap#removeEldestEntry(java.util.Map$Entry)
651: */
652: public void test_remove_eldest() {
653: int i;
654: int sz = 10;
655: CacheMap lhm = new CacheMap();
656: for (i = 0; i < sz; i++) {
657: Integer ii = new Integer(i);
658: lhm.put(ii, new Integer(i * 2));
659: }
660:
661: Collection s1 = lhm.values();
662: Iterator it1 = s1.iterator();
663: assertTrue("Returned set of incorrect size 1", lhm.size() == s1
664: .size());
665: for (i = 5; it1.hasNext(); i++) {
666: Integer jj = (Integer) it1.next();
667: assertTrue("Returned incorrect entry set 1",
668: jj.intValue() == i * 2);
669: }
670: assertTrue("Entries left in map", !it1.hasNext());
671: }
672:
673: /**
674: * Sets up the fixture, for example, open a network connection. This method
675: * is called before a test is executed.
676: */
677: protected void setUp() {
678: hm = new LinkedHashMap();
679: for (int i = 0; i < objArray.length; i++)
680: hm.put(objArray2[i], objArray[i]);
681: hm.put("test", null);
682: hm.put(null, "test");
683: }
684:
685: /**
686: * Tears down the fixture, for example, close a network connection. This
687: * method is called after a test is executed.
688: */
689: protected void tearDown() {
690: }
691: }
|