/*******************************************************************************
* Copyright (c) 2008, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.osgi.tests.eventmgr;
import java.util.*;
import junit.framework.*;
import org.eclipse.osgi.framework.eventmgr.CopyOnWriteIdentityMap;
public class EventManagerTests extends TestCase {
public static Test suite() {
return new TestSuite(EventManagerTests.class);
}
public void testCopyOnWriteIdentityMap() {
Object l1 = new Object();
Object l2 = new Object();
Object l3 = new Object();
Object l4 = new Object();
Object c1 = new Object();
Object c2 = new Object();
Object c3 = new Object();
Object c4 = new Object();
CopyOnWriteIdentityMap el1 = new CopyOnWriteIdentityMap();
assertTrue("not empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 0, el1.size()); //$NON-NLS-1$
assertNull("non null", el1.put(l1, c1)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 1, el1.size()); //$NON-NLS-1$
assertNull("non null", el1.put(l2, c2)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 2, el1.size()); //$NON-NLS-1$
assertNull("non null", el1.put(l3, c3)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 3, el1.size()); //$NON-NLS-1$
assertNull("non null", el1.put(l4, c4)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, el1.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el1.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c2, el1.get(l2)); //$NON-NLS-1$
assertEquals("wrong value", c3, el1.get(l3)); //$NON-NLS-1$
assertEquals("wrong value", c4, el1.get(l4)); //$NON-NLS-1$
CopyOnWriteIdentityMap el2 = new CopyOnWriteIdentityMap(el1);
assertFalse("empty", el2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, el2.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el2.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c2, el2.get(l2)); //$NON-NLS-1$
assertEquals("wrong value", c3, el2.get(l3)); //$NON-NLS-1$
assertEquals("wrong value", c4, el2.get(l4)); //$NON-NLS-1$
assertEquals("wrong value", c2, el1.remove(l2)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 3, el1.size()); //$NON-NLS-1$
assertEquals("not null", null, el1.remove(l2)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 3, el1.size()); //$NON-NLS-1$
assertEquals("wrong value", c4, el1.remove(l4)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 2, el1.size()); //$NON-NLS-1$
assertEquals("not null", null, el1.remove(l4)); //$NON-NLS-1$
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 2, el1.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el1.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c3, el1.get(l3)); //$NON-NLS-1$
assertFalse("empty", el2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, el2.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el2.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c2, el2.get(l2)); //$NON-NLS-1$
assertEquals("wrong value", c3, el2.get(l3)); //$NON-NLS-1$
assertEquals("wrong value", c4, el2.get(l4)); //$NON-NLS-1$
assertEquals("wrong value", c1, el2.remove(l1)); //$NON-NLS-1$
assertEquals("wrong value", c3, el2.remove(l3)); //$NON-NLS-1$
el1.putAll(el2);
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, el1.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el1.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c2, el1.get(l2)); //$NON-NLS-1$
assertEquals("wrong value", c3, el1.get(l3)); //$NON-NLS-1$
assertEquals("wrong value", c4, el1.get(l4)); //$NON-NLS-1$
assertFalse("empty", el2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 2, el2.size()); //$NON-NLS-1$
assertEquals("wrong value", c2, el2.get(l2)); //$NON-NLS-1$
assertEquals("wrong value", c4, el2.get(l4)); //$NON-NLS-1$
el2.putAll(el1);
assertFalse("empty", el1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, el1.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el1.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c2, el1.get(l2)); //$NON-NLS-1$
assertEquals("wrong value", c3, el1.get(l3)); //$NON-NLS-1$
assertEquals("wrong value", c4, el1.get(l4)); //$NON-NLS-1$
assertFalse("empty", el2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, el2.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el2.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c2, el2.get(l2)); //$NON-NLS-1$
assertEquals("wrong value", c3, el2.get(l3)); //$NON-NLS-1$
assertEquals("wrong value", c4, el2.get(l4)); //$NON-NLS-1$
el2.clear();
assertTrue("not empty", el2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 0, el2.size()); //$NON-NLS-1$
assertNull("non null", el2.put(l1, c1)); //$NON-NLS-1$
assertEquals("wrong value", c1, el2.put(l1, c3)); //$NON-NLS-1$
assertEquals("wrong value", c3, el2.get(l1)); //$NON-NLS-1$
assertTrue("missed key", el2.containsKey(l1)); //$NON-NLS-1$
assertTrue("missed value", el2.containsValue(c3)); //$NON-NLS-1$
assertFalse("invalid key", el2.containsKey(l2)); //$NON-NLS-1$
assertFalse("invalid value", el2.containsValue(c1)); //$NON-NLS-1$
el2.clear();
Map source = new HashMap();
source.put(l1, c1);
source.put(l4, c4);
el2.putAll(source);
assertFalse("empty", el2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 2, el2.size()); //$NON-NLS-1$
assertEquals("wrong value", c1, el2.get(l1)); //$NON-NLS-1$
assertEquals("wrong value", c4, el2.get(l4)); //$NON-NLS-1$
el2.clear();
Set k1 = el1.keySet();
Set k2 = el2.keySet();
Set k3 = el1.keySet();
Set k4 = el1.keySet();
Collection v1 = el1.values();
Collection v2 = el2.values();
Collection v3 = el1.values();
Collection v4 = el1.values();
Set e1 = el1.entrySet();
Set e2 = el2.entrySet();
Set e3 = el1.entrySet();
Set e4 = el1.entrySet();
Set e5 = el1.entrySet();
el1.clear();
assertFalse("empty", k1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, k1.size()); //$NON-NLS-1$
assertTrue("missed key", k1.contains(l1)); //$NON-NLS-1$
assertTrue("missed key", k1.contains(l2)); //$NON-NLS-1$
assertTrue("missed key", k1.contains(l3)); //$NON-NLS-1$
assertTrue("missed key", k1.contains(l4)); //$NON-NLS-1$
assertTrue("missed key", k1.containsAll(Arrays.asList(new Object[] {l1, l2, l3, l4}))); //$NON-NLS-1$
assertTrue("array unequal", Arrays.equals(new Object[] {l1, l3, l2, l4}, k1.toArray())); //$NON-NLS-1$
assertTrue("array unequal", Arrays.equals(new Object[] {l1, l3, l2, l4}, k1.toArray(new Object[4]))); //$NON-NLS-1$
Iterator i1 = k1.iterator();
assertTrue("missing next", i1.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", l1, i1.next()); //$NON-NLS-1$
i1.remove();
assertEquals("wrong size", 3, k1.size()); //$NON-NLS-1$
assertFalse("still present", k1.contains(l1));
assertTrue("missing next", i1.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", l3, i1.next()); //$NON-NLS-1$
i1.remove();
assertEquals("wrong size", 2, k1.size()); //$NON-NLS-1$
assertFalse("still present", k1.contains(l3));
assertTrue("missing next", i1.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", l2, i1.next()); //$NON-NLS-1$
i1.remove();
assertEquals("wrong size", 1, k1.size()); //$NON-NLS-1$
assertFalse("still present", k1.contains(l2));
assertTrue("missing next", i1.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", l4, i1.next()); //$NON-NLS-1$
i1.remove();
assertEquals("wrong size", 0, k1.size()); //$NON-NLS-1$
assertFalse("still present", k1.contains(l4));
assertFalse("extra next", i1.hasNext()); //$NON-NLS-1$
try {
i1.next();
fail("next did not throw exception"); //$NON-NLS-1$
} catch (NoSuchElementException e) {
//expected
}
assertTrue("not empty", k2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 0, k2.size()); //$NON-NLS-1$
Iterator i2 = k2.iterator();
assertFalse("extra next", i2.hasNext()); //$NON-NLS-1$
try {
i2.next();
fail("next did not throw exception"); //$NON-NLS-1$
} catch (NoSuchElementException e) {
//expected
}
try {
k2.add(l1);
fail("add did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
try {
k2.addAll(Arrays.asList(new Object[] {l1, l2}));
fail("addAll did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
k3.remove(l3);
assertFalse("not removed", k3.contains(l3)); //$NON-NLS-1$
k3.removeAll(Arrays.asList(new Object[] {l1, l2}));
assertFalse("not removed", k3.contains(l1)); //$NON-NLS-1$
assertFalse("not removed", k3.contains(l2)); //$NON-NLS-1$
k4.retainAll(Arrays.asList(new Object[] {l1, l2}));
assertTrue("missing", k4.contains(l1)); //$NON-NLS-1$
assertTrue("missing", k4.contains(l2)); //$NON-NLS-1$
assertFalse("not removed", k4.contains(l3)); //$NON-NLS-1$
assertFalse("not removed", k4.contains(l4)); //$NON-NLS-1$
k4.clear();
assertTrue("not empty", k4.isEmpty()); //$NON-NLS-1$
assertFalse("empty", v1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, v1.size()); //$NON-NLS-1$
assertTrue("missed key", v1.contains(c1)); //$NON-NLS-1$
assertTrue("missed key", v1.contains(c2)); //$NON-NLS-1$
assertTrue("missed key", v1.contains(c3)); //$NON-NLS-1$
assertTrue("missed key", v1.contains(c4)); //$NON-NLS-1$
assertTrue("missed key", v1.containsAll(Arrays.asList(new Object[] {c1, c2, c3, c4}))); //$NON-NLS-1$
assertTrue("array unequal", Arrays.equals(new Object[] {c1, c3, c2, c4}, v1.toArray())); //$NON-NLS-1$
assertTrue("array unequal", Arrays.equals(new Object[] {c1, c3, c2, c4}, v1.toArray(new Object[4]))); //$NON-NLS-1$
Iterator i3 = v1.iterator();
assertTrue("missing next", i3.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", c1, i3.next()); //$NON-NLS-1$
i3.remove();
assertEquals("wrong size", 3, v1.size()); //$NON-NLS-1$
assertFalse("still present", v1.contains(c1));
assertTrue("missing next", i3.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", c3, i3.next()); //$NON-NLS-1$
i3.remove();
assertEquals("wrong size", 2, v1.size()); //$NON-NLS-1$
assertFalse("still present", v1.contains(c3));
assertTrue("missing next", i3.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", c2, i3.next()); //$NON-NLS-1$
i3.remove();
assertEquals("wrong size", 1, v1.size()); //$NON-NLS-1$
assertFalse("still present", v1.contains(c2));
assertTrue("missing next", i3.hasNext()); //$NON-NLS-1$
assertEquals("wrong key", c4, i3.next()); //$NON-NLS-1$
i3.remove();
assertEquals("wrong size", 0, v1.size()); //$NON-NLS-1$
assertFalse("still present", v1.contains(c4));
assertFalse("extra next", i3.hasNext()); //$NON-NLS-1$
try {
i3.next();
fail("next did not throw exception"); //$NON-NLS-1$
} catch (NoSuchElementException e) {
//expected
}
assertTrue("not empty", v2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 0, v2.size()); //$NON-NLS-1$
Iterator i4 = v2.iterator();
assertFalse("extra next", i4.hasNext()); //$NON-NLS-1$
try {
i4.next();
fail("next did not throw exception"); //$NON-NLS-1$
} catch (NoSuchElementException e) {
//expected
}
try {
v2.add(c1);
fail("add did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
try {
v2.addAll(Arrays.asList(new Object[] {c1, c2}));
fail("addAll did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
v3.remove(c3);
assertFalse("not removed", v3.contains(c3)); //$NON-NLS-1$
v3.removeAll(Arrays.asList(new Object[] {c1, c2}));
assertFalse("not removed", v3.contains(c1)); //$NON-NLS-1$
assertFalse("not removed", v3.contains(c2)); //$NON-NLS-1$
v4.retainAll(Arrays.asList(new Object[] {c1, c2}));
assertTrue("missing", v4.contains(c1)); //$NON-NLS-1$
assertTrue("missing", v4.contains(c2)); //$NON-NLS-1$
assertFalse("not removed", v4.contains(c3)); //$NON-NLS-1$
assertFalse("not removed", v4.contains(c4)); //$NON-NLS-1$
v4.clear();
assertTrue("not empty", v4.isEmpty()); //$NON-NLS-1$
assertFalse("empty", e1.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 4, e1.size()); //$NON-NLS-1$
Iterator i5 = e1.iterator();
assertTrue("missing next", i5.hasNext()); //$NON-NLS-1$
Map.Entry me1 = (Map.Entry) i5.next();
assertEquals("wrong key", l1, me1.getKey()); //$NON-NLS-1$
assertEquals("wrong value", c1, me1.getValue()); //$NON-NLS-1$
try {
me1.setValue(c2);
fail("remove did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
i5.remove();
assertEquals("wrong size", 3, e1.size()); //$NON-NLS-1$
assertFalse("still present", e1.contains(me1));
assertTrue("missing next", i5.hasNext()); //$NON-NLS-1$
Map.Entry me3 = (Map.Entry) i5.next();
assertEquals("wrong key", l3, me3.getKey()); //$NON-NLS-1$
assertEquals("wrong value", c3, me3.getValue()); //$NON-NLS-1$
try {
me3.setValue(c2);
fail("remove did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
i5.remove();
assertEquals("wrong size", 2, e1.size()); //$NON-NLS-1$
assertFalse("still present", e1.contains(me3));
assertTrue("missing next", i5.hasNext()); //$NON-NLS-1$
Map.Entry me2 = (Map.Entry) i5.next();
assertEquals("wrong key", l2, me2.getKey()); //$NON-NLS-1$
assertEquals("wrong value", c2, me2.getValue()); //$NON-NLS-1$
try {
me2.setValue(c3);
fail("remove did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
i5.remove();
assertEquals("wrong size", 1, e1.size()); //$NON-NLS-1$
assertFalse("still present", e1.contains(me2));
assertTrue("missing next", i5.hasNext()); //$NON-NLS-1$
Map.Entry me4 = (Map.Entry) i5.next();
assertEquals("wrong key", l4, me4.getKey()); //$NON-NLS-1$
assertEquals("wrong value", c4, me4.getValue()); //$NON-NLS-1$
try {
me4.setValue(c2);
fail("remove did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
i5.remove();
assertEquals("wrong size", 0, e1.size()); //$NON-NLS-1$
assertFalse("still present", e1.contains(me4));
assertFalse("extra next", i5.hasNext()); //$NON-NLS-1$
try {
i1.next();
fail("next did not throw exception"); //$NON-NLS-1$
} catch (NoSuchElementException e) {
//expected
}
assertTrue("not empty", e2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 0, e2.size()); //$NON-NLS-1$
Iterator i6 = e2.iterator();
assertFalse("extra next", i6.hasNext()); //$NON-NLS-1$
try {
i6.next();
fail("next did not throw exception"); //$NON-NLS-1$
} catch (NoSuchElementException e) {
//expected
}
try {
e2.add(me1);
fail("add did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
try {
e2.addAll(Arrays.asList(new Map.Entry[] {me2, me4}));
fail("addAll did not throw exception"); //$NON-NLS-1$
} catch (UnsupportedOperationException e) {
//expected
}
e3.remove(me3);
assertFalse("not removed", e3.contains(me3)); //$NON-NLS-1$
e3.removeAll(Arrays.asList(new Object[] {me1, me2}));
assertFalse("not removed", e3.contains(me1)); //$NON-NLS-1$
assertFalse("not removed", e3.contains(me2)); //$NON-NLS-1$
e4.retainAll(Arrays.asList(new Object[] {me1, me2}));
assertTrue("missing", e4.contains(me1)); //$NON-NLS-1$
assertTrue("missing", e4.contains(me2)); //$NON-NLS-1$
assertFalse("not removed", e4.contains(me3)); //$NON-NLS-1$
assertFalse("not removed", e4.contains(me4)); //$NON-NLS-1$
e4.clear();
assertTrue("not empty", e4.isEmpty()); //$NON-NLS-1$
assertTrue("array unequal", Arrays.equals(new Map.Entry[] {me1, me3, me2, me4}, e5.toArray())); //$NON-NLS-1$
assertTrue("array unequal", Arrays.equals(new Map.Entry[] {me1, me3, me2, me4}, e5.toArray(new Map.Entry[4]))); //$NON-NLS-1$
el2.clear();
el2.putAll(new Object[] {l1, l3});
assertFalse("empty", el2.isEmpty()); //$NON-NLS-1$
assertEquals("wrong size", 2, el2.size()); //$NON-NLS-1$
assertTrue("missed key", el2.containsKey(l1)); //$NON-NLS-1$
assertTrue("missed key", el2.containsKey(l3)); //$NON-NLS-1$
assertNull("value not null", el2.get(l1)); //$NON-NLS-1$
assertNull("value not null", el2.get(l3)); //$NON-NLS-1$
}
}