geode-core/src/test/java/org/apache/geode/internal/ObjIdMapJUnitTest.java - geode - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
  * agreements. See the NOTICE file distributed with this work for additional information regarding
  * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance with the License. You may obtain a
  * copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 package org.apache.geode.internal;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Random;

 import org.junit.Test;


 /**
  * This class tests the functionality of the {@link ObjIdMap} class.
  */
 public class ObjIdMapJUnitTest {

   @Test
   public void testSimplePut() {
     ObjIdMap map = new ObjIdMap();
     int key = 4;
     Object value = new Integer(key);
     map.put(key, value);
     assertSame(value, map.get(key));
   }

   @Test
   public void testGetNotThere() {
     ObjIdMap map = new ObjIdMap();
     int key = 4;
     assertSame(null, map.get(key));
   }

   @Test
   public void testSimpleContainsKey() {
     ObjIdMap map = new ObjIdMap();
     int key = 4;
     Object value = new Integer(key);
     map.put(key, value);
     assertTrue(map.containsKey(key));
   }

   @Test
   public void testSimpleRemove() {
     ObjIdMap map = new ObjIdMap();
     int key = 4;
     Object value = new Integer(key);
     map.put(key, value);
     assertSame(value, map.remove(key));
   }

   @Test
   public void testSimpleValues() {
     ObjIdMap map = new ObjIdMap();
     for (int i = 0; i < 20; i++) {
       map.put(i, new Integer(i));
     }

     Object[] values = map.values();
     assertEquals(20, values.length);
     for (int i = 0; i < 20; i++) {
       boolean found = false;
       for (int j = 0; j < values.length; j++) {
         if (values[j].equals(new Integer(i))) {
           found = true;
           break;
         }
       }

       assertTrue("Didn't find " + i, found);
     }
   }

   @Test
   public void testRandomMap() {
     final ObjIdMap map = new ObjIdMap();
     final int size = 1000;

     // ----------------------
     // This test naively assumed that a list of 1000 ints or 1000 longs would
     // yield 1000 distinct values. This has been rewritten to ensure
     // this invariant...
     // ----------------------
     Random random = new Random();

     // Loop until we have 1000 keys. This addresses the slight
     // possibility of duplicates...
     HashSet<Integer> keySet = new HashSet<Integer>();
     while (keySet.size() != size) {
       int key = Math.abs(random.nextInt());
       keySet.add(new Integer(key));
     }

     // Loop until we have 1000 values
     HashSet<Long> valueSet = new HashSet<Long>();
     while (valueSet.size() != size) {
       long value = Math.abs(random.nextLong());
       valueSet.add(new Long(value));
     }

     Iterator<Integer> keyIt = keySet.iterator();
     Iterator<Long> valueIt = valueSet.iterator();
     int keys[] = new int[size];
     Long values[] = new Long[size];
     for (int i = 0; i < size; i++) {
       keys[i] = keyIt.next().intValue();
       values[i] = valueIt.next();;
     }

     // ----------------------
     // Now back to your regularly scheduled program...
     // ----------------------

     // Now populate the map...
     for (int i = 0; i < size; i++) {
       map.put(keys[i], values[i]);
     }
     assertEquals("Map is not correct size", size, map.size());

     for (int i = 0; i < size; i++) {
       int key = keys[i];
       assertTrue("Map does not contain key", map.containsKey(key));
       assertEquals("Map has wrong value for key", values[i], map.get(key));
     }

     Object[] valueArray = map.values();
     assertEquals("Value array for map is wrong size", size, valueArray.length);

     for (int i = 0; i < size; i++) {
       boolean found = false;
       int key = keys[i];
       Object value = values[i];
       for (int j = 0; j < valueArray.length; j++) {
         if (valueArray[j].equals(value)) {
           found = true;
           break;
         }
       }

       assertTrue("Didn't find " + key, found);
     }
   }

   @Test
   public void testRandomGrowRemoveRelease() {
     ObjIdMap map = new ObjIdMap();
     Random random = new Random(System.currentTimeMillis());
     List saver = new ArrayList();
     BitSet bits = new BitSet();
     int maxSize = 10000;
     boolean growing = true;
     int numAdds = 0;
     int numRemoves = 0;
     int numReleases = 0;
     int numChecks = 0;

     while (growing || saver.size() > 0) {
       int op = random.nextInt(8);
       // System.out.println("saver size: " + saver.size() + ", map size: " + map.size());
       switch (op) {
         case 0: // Add new value - more likely to occur than removes
         case 1:
         case 2:
           if (!growing)
             break;
           int key = Math.abs(random.nextInt(10 * maxSize));
           if (bits.get(key)) {
             // We don't want the newValue in the saver List twice
             // because it is only in the map once.
             continue;
           }
           Integer newValue = new Integer(key);
           numAdds++;
           map.put(key, new WeakReference(newValue));
           saver.add(newValue);
           bits.set(key);
           if (saver.size() >= maxSize)
             growing = false;
           break;
         case 3: // Explicitly remove random entry
           if (saver.size() == 0)
             break;
           numRemoves++;
           key = random.nextInt(saver.size());
           Integer value = (Integer) saver.remove(key);
           bits.clear(value.intValue());
           assertNotNull(map.remove(value.intValue()));
           break;
         case 4: // Release reference to random entry
           if (saver.size() == 0)
             break;
           numReleases++;
           key = random.nextInt(saver.size());
           value = (Integer) saver.remove(key);
           bits.clear(value.intValue());
           break;
         case 5: // Validate random entry
         case 6:
         case 7:
           if (saver.size() == 0)
             break;
           numChecks++;
           Integer valueToCheck = (Integer) saver.get(random.nextInt(saver.size()));
           WeakReference ref = (WeakReference) map.get(valueToCheck.intValue());
           assertTrue(ref != null);
           assertEquals(valueToCheck, ref.get());
           break;
         default:
           fail("Bad op: " + op);
       }
     }
     System.out.println("map size: " + map.size() + ", numAdds: " + numAdds + ", numRemoves: "
         + numRemoves + ", numReleases: " + numReleases + ", numChecks: " + numChecks);
   }

   @Test
   public void testIterator() {
     int size = 10;
     ObjIdMap map = new ObjIdMap();
     for (int i = 0; i < size; i++) {
       map.put(i, new Integer(i));
     }
     assertEquals(size, map.size());

     boolean[] found = new boolean[size];

     ObjIdMap.EntryIterator iter = map.iterator();
     for (ObjIdMap.Entry e = iter.next(); e != null; e = iter.next()) {
       int key = e.key;
       // System.out.println(key);
       assertFalse("Already saw " + key, found[key]);
       found[key] = true;
     }

     for (int i = 0; i < found.length; i++) {
       assertTrue(i + " not found", found[i]);
     }

   }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more contributor license
	* agreements. See the NOTICE file distributed with this work for additional information regarding
	* copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance with the License. You may obtain a
	* copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software distributed under the License
	* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
	* or implied. See the License for the specific language governing permissions and limitations under
	* the License.
	*/
	package org.apache.geode.internal;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertSame;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;

	import java.lang.ref.WeakReference;
	import java.util.ArrayList;
	import java.util.BitSet;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Random;

	import org.junit.Test;


	/**
	* This class tests the functionality of the {@link ObjIdMap} class.
	*/
	public class ObjIdMapJUnitTest {

	@Test
	public void testSimplePut() {
	ObjIdMap map = new ObjIdMap();
	int key = 4;
	Object value = new Integer(key);
	map.put(key, value);
	assertSame(value, map.get(key));
	}

	@Test
	public void testGetNotThere() {
	ObjIdMap map = new ObjIdMap();
	int key = 4;
	assertSame(null, map.get(key));
	}

	@Test
	public void testSimpleContainsKey() {
	ObjIdMap map = new ObjIdMap();
	int key = 4;
	Object value = new Integer(key);
	map.put(key, value);
	assertTrue(map.containsKey(key));
	}

	@Test
	public void testSimpleRemove() {
	ObjIdMap map = new ObjIdMap();
	int key = 4;
	Object value = new Integer(key);
	map.put(key, value);
	assertSame(value, map.remove(key));
	}

	@Test
	public void testSimpleValues() {
	ObjIdMap map = new ObjIdMap();
	for (int i = 0; i < 20; i++) {
	map.put(i, new Integer(i));
	}

	Object[] values = map.values();
	assertEquals(20, values.length);
	for (int i = 0; i < 20; i++) {
	boolean found = false;
	for (int j = 0; j < values.length; j++) {
	if (values[j].equals(new Integer(i))) {
	found = true;
	break;
	}
	}

	assertTrue("Didn't find " + i, found);
	}
	}

	@Test
	public void testRandomMap() {
	final ObjIdMap map = new ObjIdMap();
	final int size = 1000;

	// ----------------------
	// This test naively assumed that a list of 1000 ints or 1000 longs would
	// yield 1000 distinct values. This has been rewritten to ensure
	// this invariant...
	// ----------------------
	Random random = new Random();

	// Loop until we have 1000 keys. This addresses the slight
	// possibility of duplicates...
	HashSet<Integer> keySet = new HashSet<Integer>();
	while (keySet.size() != size) {
	int key = Math.abs(random.nextInt());
	keySet.add(new Integer(key));
	}

	// Loop until we have 1000 values
	HashSet<Long> valueSet = new HashSet<Long>();
	while (valueSet.size() != size) {
	long value = Math.abs(random.nextLong());
	valueSet.add(new Long(value));
	}

	Iterator<Integer> keyIt = keySet.iterator();
	Iterator<Long> valueIt = valueSet.iterator();
	int keys[] = new int[size];
	Long values[] = new Long[size];
	for (int i = 0; i < size; i++) {
	keys[i] = keyIt.next().intValue();
	values[i] = valueIt.next();;
	}

	// ----------------------
	// Now back to your regularly scheduled program...
	// ----------------------

	// Now populate the map...
	for (int i = 0; i < size; i++) {
	map.put(keys[i], values[i]);
	}
	assertEquals("Map is not correct size", size, map.size());

	for (int i = 0; i < size; i++) {
	int key = keys[i];
	assertTrue("Map does not contain key", map.containsKey(key));
	assertEquals("Map has wrong value for key", values[i], map.get(key));
	}

	Object[] valueArray = map.values();
	assertEquals("Value array for map is wrong size", size, valueArray.length);

	for (int i = 0; i < size; i++) {
	boolean found = false;
	int key = keys[i];
	Object value = values[i];
	for (int j = 0; j < valueArray.length; j++) {
	if (valueArray[j].equals(value)) {
	found = true;
	break;
	}
	}

	assertTrue("Didn't find " + key, found);
	}
	}

	@Test
	public void testRandomGrowRemoveRelease() {
	ObjIdMap map = new ObjIdMap();
	Random random = new Random(System.currentTimeMillis());
	List saver = new ArrayList();
	BitSet bits = new BitSet();
	int maxSize = 10000;
	boolean growing = true;
	int numAdds = 0;
	int numRemoves = 0;
	int numReleases = 0;
	int numChecks = 0;

	while (growing \|\| saver.size() > 0) {
	int op = random.nextInt(8);
	// System.out.println("saver size: " + saver.size() + ", map size: " + map.size());
	switch (op) {
	case 0: // Add new value - more likely to occur than removes
	case 1:
	case 2:
	if (!growing)
	break;
	int key = Math.abs(random.nextInt(10 * maxSize));
	if (bits.get(key)) {
	// We don't want the newValue in the saver List twice
	// because it is only in the map once.
	continue;
	}
	Integer newValue = new Integer(key);
	numAdds++;
	map.put(key, new WeakReference(newValue));
	saver.add(newValue);
	bits.set(key);
	if (saver.size() >= maxSize)
	growing = false;
	break;
	case 3: // Explicitly remove random entry
	if (saver.size() == 0)
	break;
	numRemoves++;
	key = random.nextInt(saver.size());
	Integer value = (Integer) saver.remove(key);
	bits.clear(value.intValue());
	assertNotNull(map.remove(value.intValue()));
	break;
	case 4: // Release reference to random entry
	if (saver.size() == 0)
	break;
	numReleases++;
	key = random.nextInt(saver.size());
	value = (Integer) saver.remove(key);
	bits.clear(value.intValue());
	break;
	case 5: // Validate random entry
	case 6:
	case 7:
	if (saver.size() == 0)
	break;
	numChecks++;
	Integer valueToCheck = (Integer) saver.get(random.nextInt(saver.size()));
	WeakReference ref = (WeakReference) map.get(valueToCheck.intValue());
	assertTrue(ref != null);
	assertEquals(valueToCheck, ref.get());
	break;
	default:
	fail("Bad op: " + op);
	}
	}
	System.out.println("map size: " + map.size() + ", numAdds: " + numAdds + ", numRemoves: "
	+ numRemoves + ", numReleases: " + numReleases + ", numChecks: " + numChecks);
	}

	@Test
	public void testIterator() {
	int size = 10;
	ObjIdMap map = new ObjIdMap();
	for (int i = 0; i < size; i++) {
	map.put(i, new Integer(i));
	}
	assertEquals(size, map.size());

	boolean[] found = new boolean[size];

	ObjIdMap.EntryIterator iter = map.iterator();
	for (ObjIdMap.Entry e = iter.next(); e != null; e = iter.next()) {
	int key = e.key;
	// System.out.println(key);
	assertFalse("Already saw " + key, found[key]);
	found[key] = true;
	}

	for (int i = 0; i < found.length; i++) {
	assertTrue(i + " not found", found[i]);
	}

	}

	}