tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/registry/RegistryListenerTest.java - gerrit/platform/eclipse.platform.runtime - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2012 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.core.tests.internal.registry;

 import java.io.IOException;
 import junit.framework.*;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.tests.harness.BundleTestingHelper;
 import org.eclipse.core.tests.runtime.RuntimeTestsPlugin;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleException;

 /**
  * Tests "new" registry event listener.
  * @since 3.4
  */
 public class RegistryListenerTest extends TestCase {

 	final private static int MAX_TIME_PER_BUNDLE = 10000; // maximum time to wait for bundle event in milliseconds

 	public RegistryListenerTest() {
 		super();
 	}

 	public RegistryListenerTest(String name) {
 		super(name);
 	}

 	/**
 	 * Producer and consumer bundles are installed and removed in a "normal" order
 	 */
 	public void testRegularOrder() throws IOException, BundleException {
 		Bundle bundle01 = null;
 		Bundle bundle02 = null;
 		WaitingRegistryListener listener = new WaitingRegistryListener();
 		listener.register("bundle01.xp1");
 		try {
 			bundle01 = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundle01");
 			bundle02 = BundleTestingHelper.installBundle("0.2", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundle02");

 			Bundle[] testBundles = new Bundle[] {bundle01, bundle02};
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			String[] extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
 			String[] extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
 			assertTrue(listener.isAdded());

 			assertNotNull(extPointIDs);
 			assertTrue(extPointIDs.length == 1);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));

 			assertNotNull(extensionsReceived);
 			assertTrue(extensionsReceived.length == 1);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

 			listener.reset();

 			bundle02.uninstall();
 			bundle02 = null; // reset as early as possible in case of exception
 			bundle01.uninstall();
 			bundle01 = null; // reset as early as possible in case of exception
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
 			extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
 			assertTrue(listener.isRemoved());

 			assertNotNull(extPointIDs);
 			assertTrue(extPointIDs.length == 1);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));

 			assertNotNull(extensionsReceived);
 			assertTrue(extensionsReceived.length == 1);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

 		} finally {
 			listener.unregister();
 			if (bundle01 != null)
 				bundle01.uninstall();
 			if (bundle02 != null)
 				bundle02.uninstall();
 		}
 	}

 	/**
 	 * Producer and consumer bundles are installed and removed in an inverse order
 	 */
 	public void testInverseOrder() throws IOException, BundleException {
 		Bundle bundle01 = null;
 		Bundle bundle02 = null;
 		WaitingRegistryListener listener = new WaitingRegistryListener();
 		listener.register("bundle01.xp1");
 		try {
 			bundle02 = BundleTestingHelper.installBundle("0.2", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryEvents/bundle02");
 			bundle01 = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryEvents/bundle01");

 			Bundle[] testBundles = new Bundle[] {bundle01, bundle02};
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			String[] extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
 			String[] extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
 			assertTrue(listener.isAdded());

 			assertNotNull(extPointIDs);
 			assertTrue(extPointIDs.length == 1);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));

 			assertNotNull(extensionsReceived);
 			assertTrue(extensionsReceived.length == 1);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

 			listener.reset();

 			bundle01.uninstall();
 			bundle01 = null; // reset as early as possible in case of exception
 			bundle02.uninstall();
 			bundle02 = null; // reset as early as possible in case of exception
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
 			extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
 			assertTrue(listener.isRemoved());

 			assertNotNull(extPointIDs);
 			assertTrue(extPointIDs.length == 1);
 			assertTrue("bundle01.xp1".equals(extPointIDs[0]));

 			assertNotNull(extensionsReceived);
 			assertTrue(extensionsReceived.length == 1);
 			assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

 		} finally {
 			listener.unregister();
 			if (bundle02 != null)
 				bundle02.uninstall();
 			if (bundle01 != null)
 				bundle01.uninstall();
 		}
 	}

 	/**
 	 * Tests modifications to multiple extensions and extension points
 	 * Three listeners are tested: global; on xp1 (two extensions); on xp2 (no extensions)
 	 */
 	public void testMultiplePoints() throws IOException, BundleException {
 		Bundle bundle = null;
 		WaitingRegistryListener listenerGlobal = new WaitingRegistryListener();
 		listenerGlobal.register(null);
 		WaitingRegistryListener listener1 = new WaitingRegistryListener();
 		listener1.register("bundleMultiple.xp1");
 		WaitingRegistryListener listener2 = new WaitingRegistryListener();
 		listener2.register("bundleMultiple.xp2");
 		try {
 			bundle = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundleMultiple");

 			Bundle[] testBundles = new Bundle[] {bundle};
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			// test additions on global listener
 			String[] extPointIDs = listenerGlobal.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			String[] extensionsReceived = listenerGlobal.extensionsReceived(MAX_TIME_PER_BUNDLE);
 			assertTrue(listenerGlobal.isAdded());
 			checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1", "bundleMultiple.xp2"});
 			checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

 			// test additions on listener on extension point with extensions
 			String[] extPointIDs1 = listener1.extPointsReceived(20000);
 			String[] extensionsReceived1 = listener1.extensionsReceived(20000);
 			assertTrue(listener1.isAdded());
 			checkIDs(extPointIDs1, new String[] {"bundleMultiple.xp1"});
 			checkIDs(extensionsReceived1, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

 			// test additions on listener on extension point with no extensions
 			String[] extPointIDs2 = listener2.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			String[] extensionsReceived2 = listener2.extensionsReceived(50);
 			assertTrue(listener2.isAdded());
 			checkIDs(extPointIDs2, new String[] {"bundleMultiple.xp2"});
 			assertNull(extensionsReceived2);

 			// removal
 			listenerGlobal.reset();
 			listener1.reset();
 			listener2.reset();
 			bundle.uninstall();
 			bundle = null; // reset as early as possible in case of exception
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			// test removals on global listener
 			extPointIDs = listenerGlobal.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			extensionsReceived = listenerGlobal.extensionsReceived(MAX_TIME_PER_BUNDLE);
 			assertTrue(listenerGlobal.isRemoved());
 			checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1", "bundleMultiple.xp2"});
 			checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

 			// test removals on listener on extension point with extensions
 			extPointIDs1 = listener1.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			extensionsReceived1 = listener1.extensionsReceived(MAX_TIME_PER_BUNDLE);
 			assertTrue(listener1.isRemoved());
 			checkIDs(extPointIDs1, new String[] {"bundleMultiple.xp1"});
 			checkIDs(extensionsReceived1, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

 			// test removals on listener on extension point with no extensions
 			extPointIDs2 = listener2.extPointsReceived(MAX_TIME_PER_BUNDLE);
 			extensionsReceived2 = listener2.extensionsReceived(50);
 			assertTrue(listener2.isRemoved());
 			checkIDs(extPointIDs2, new String[] {"bundleMultiple.xp2"});
 			assertNull(extensionsReceived2);

 		} finally {
 			listenerGlobal.unregister();
 			listener1.unregister();
 			listener2.unregister();
 			if (bundle != null)
 				bundle.uninstall();
 		}
 	}

 	/**
 	 * Tests listener registered multiple times: once on xp1, once on xp2
 	 */
 	public void testMultipleRegistrations() throws IOException, BundleException {
 		Bundle bundle = null;
 		WaitingRegistryListener listener = new WaitingRegistryListener();
 		Platform.getExtensionRegistry().addListener(listener, "bundleMultiple.xp1");
 		Platform.getExtensionRegistry().addListener(listener, "bundleMultiple.xp1");
 		try {
 			bundle = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundleMultiple");

 			Bundle[] testBundles = new Bundle[] {bundle};
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			// 1st registration: extension point; extension		=> 2 callbacks
 			// 2nd registration should be ignored: extension	=> 0 callbacks
 			// total: 2 callbacks
 			assertTrue(listener.waitFor(2, MAX_TIME_PER_BUNDLE) == 2);

 			// test additions on listener on extension point with extensions
 			String[] extPointIDs = listener.extPointsReceived(50);
 			String[] extensionsReceived = listener.extensionsReceived(50);
 			assertTrue(listener.isAdded());
 			checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1"});
 			checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

 			// removal: unregistering listener once should remove both registrations
 			listener.reset();
 			listener.unregister();
 			bundle.uninstall();
 			bundle = null; // reset as early as possible in case of exception
 			BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

 			// test removals on listener on extension point with extensions
 			assertTrue(listener.waitFor(3, 200) == 0);
 			extPointIDs = listener.extPointsReceived(50);
 			extensionsReceived = listener.extensionsReceived(50);
 			assertNull(extPointIDs);
 			assertNull(extensionsReceived);
 		} finally {
 			// second unregistration should have no effect
 			listener.unregister();
 			if (bundle != null)
 				bundle.uninstall();
 		}
 	}

 	// For simplicity, this method does not expect duplicate IDs in either array
 	private void checkIDs(String[] receivedIDs, String[] expectedIDs) {
 		assertNotNull(receivedIDs);
 		assertNotNull(expectedIDs);
 		assertTrue(receivedIDs.length == expectedIDs.length);
 		for (int i = 0; i < expectedIDs.length; i++) {
 			String expected = expectedIDs[i];
 			boolean found = false;
 			for (int j = 0; j < receivedIDs.length; j++) {
 				if (expected.equals(receivedIDs[j])) {
 					found = true;
 					break;
 				}
 			}
 			assertTrue(found);
 		}
 	}

 	public static Test suite() {
 		return new TestSuite(RegistryListenerTest.class);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2007, 2012 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.core.tests.internal.registry;

	import java.io.IOException;
	import junit.framework.*;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.tests.harness.BundleTestingHelper;
	import org.eclipse.core.tests.runtime.RuntimeTestsPlugin;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.BundleException;

	/**
	* Tests "new" registry event listener.
	* @since 3.4
	*/
	public class RegistryListenerTest extends TestCase {

	final private static int MAX_TIME_PER_BUNDLE = 10000; // maximum time to wait for bundle event in milliseconds

	public RegistryListenerTest() {
	super();
	}

	public RegistryListenerTest(String name) {
	super(name);
	}

	/**
	* Producer and consumer bundles are installed and removed in a "normal" order
	*/
	public void testRegularOrder() throws IOException, BundleException {
	Bundle bundle01 = null;
	Bundle bundle02 = null;
	WaitingRegistryListener listener = new WaitingRegistryListener();
	listener.register("bundle01.xp1");
	try {
	bundle01 = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundle01");
	bundle02 = BundleTestingHelper.installBundle("0.2", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundle02");

	Bundle[] testBundles = new Bundle[] {bundle01, bundle02};
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	String[] extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
	String[] extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
	assertTrue(listener.isAdded());

	assertNotNull(extPointIDs);
	assertTrue(extPointIDs.length == 1);
	assertTrue("bundle01.xp1".equals(extPointIDs[0]));

	assertNotNull(extensionsReceived);
	assertTrue(extensionsReceived.length == 1);
	assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

	listener.reset();

	bundle02.uninstall();
	bundle02 = null; // reset as early as possible in case of exception
	bundle01.uninstall();
	bundle01 = null; // reset as early as possible in case of exception
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
	extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
	assertTrue(listener.isRemoved());

	assertNotNull(extPointIDs);
	assertTrue(extPointIDs.length == 1);
	assertTrue("bundle01.xp1".equals(extPointIDs[0]));

	assertNotNull(extensionsReceived);
	assertTrue(extensionsReceived.length == 1);
	assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

	} finally {
	listener.unregister();
	if (bundle01 != null)
	bundle01.uninstall();
	if (bundle02 != null)
	bundle02.uninstall();
	}
	}

	/**
	* Producer and consumer bundles are installed and removed in an inverse order
	*/
	public void testInverseOrder() throws IOException, BundleException {
	Bundle bundle01 = null;
	Bundle bundle02 = null;
	WaitingRegistryListener listener = new WaitingRegistryListener();
	listener.register("bundle01.xp1");
	try {
	bundle02 = BundleTestingHelper.installBundle("0.2", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryEvents/bundle02");
	bundle01 = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryEvents/bundle01");

	Bundle[] testBundles = new Bundle[] {bundle01, bundle02};
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	String[] extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
	String[] extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
	assertTrue(listener.isAdded());

	assertNotNull(extPointIDs);
	assertTrue(extPointIDs.length == 1);
	assertTrue("bundle01.xp1".equals(extPointIDs[0]));

	assertNotNull(extensionsReceived);
	assertTrue(extensionsReceived.length == 1);
	assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

	listener.reset();

	bundle01.uninstall();
	bundle01 = null; // reset as early as possible in case of exception
	bundle02.uninstall();
	bundle02 = null; // reset as early as possible in case of exception
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	extPointIDs = listener.extPointsReceived(2 * MAX_TIME_PER_BUNDLE);
	extensionsReceived = listener.extensionsReceived(2 * MAX_TIME_PER_BUNDLE);
	assertTrue(listener.isRemoved());

	assertNotNull(extPointIDs);
	assertTrue(extPointIDs.length == 1);
	assertTrue("bundle01.xp1".equals(extPointIDs[0]));

	assertNotNull(extensionsReceived);
	assertTrue(extensionsReceived.length == 1);
	assertTrue("bundle02.ext1".equals(extensionsReceived[0]));

	} finally {
	listener.unregister();
	if (bundle02 != null)
	bundle02.uninstall();
	if (bundle01 != null)
	bundle01.uninstall();
	}
	}

	/**
	* Tests modifications to multiple extensions and extension points
	* Three listeners are tested: global; on xp1 (two extensions); on xp2 (no extensions)
	*/
	public void testMultiplePoints() throws IOException, BundleException {
	Bundle bundle = null;
	WaitingRegistryListener listenerGlobal = new WaitingRegistryListener();
	listenerGlobal.register(null);
	WaitingRegistryListener listener1 = new WaitingRegistryListener();
	listener1.register("bundleMultiple.xp1");
	WaitingRegistryListener listener2 = new WaitingRegistryListener();
	listener2.register("bundleMultiple.xp2");
	try {
	bundle = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundleMultiple");

	Bundle[] testBundles = new Bundle[] {bundle};
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	// test additions on global listener
	String[] extPointIDs = listenerGlobal.extPointsReceived(MAX_TIME_PER_BUNDLE);
	String[] extensionsReceived = listenerGlobal.extensionsReceived(MAX_TIME_PER_BUNDLE);
	assertTrue(listenerGlobal.isAdded());
	checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1", "bundleMultiple.xp2"});
	checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

	// test additions on listener on extension point with extensions
	String[] extPointIDs1 = listener1.extPointsReceived(20000);
	String[] extensionsReceived1 = listener1.extensionsReceived(20000);
	assertTrue(listener1.isAdded());
	checkIDs(extPointIDs1, new String[] {"bundleMultiple.xp1"});
	checkIDs(extensionsReceived1, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

	// test additions on listener on extension point with no extensions
	String[] extPointIDs2 = listener2.extPointsReceived(MAX_TIME_PER_BUNDLE);
	String[] extensionsReceived2 = listener2.extensionsReceived(50);
	assertTrue(listener2.isAdded());
	checkIDs(extPointIDs2, new String[] {"bundleMultiple.xp2"});
	assertNull(extensionsReceived2);

	// removal
	listenerGlobal.reset();
	listener1.reset();
	listener2.reset();
	bundle.uninstall();
	bundle = null; // reset as early as possible in case of exception
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	// test removals on global listener
	extPointIDs = listenerGlobal.extPointsReceived(MAX_TIME_PER_BUNDLE);
	extensionsReceived = listenerGlobal.extensionsReceived(MAX_TIME_PER_BUNDLE);
	assertTrue(listenerGlobal.isRemoved());
	checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1", "bundleMultiple.xp2"});
	checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

	// test removals on listener on extension point with extensions
	extPointIDs1 = listener1.extPointsReceived(MAX_TIME_PER_BUNDLE);
	extensionsReceived1 = listener1.extensionsReceived(MAX_TIME_PER_BUNDLE);
	assertTrue(listener1.isRemoved());
	checkIDs(extPointIDs1, new String[] {"bundleMultiple.xp1"});
	checkIDs(extensionsReceived1, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

	// test removals on listener on extension point with no extensions
	extPointIDs2 = listener2.extPointsReceived(MAX_TIME_PER_BUNDLE);
	extensionsReceived2 = listener2.extensionsReceived(50);
	assertTrue(listener2.isRemoved());
	checkIDs(extPointIDs2, new String[] {"bundleMultiple.xp2"});
	assertNull(extensionsReceived2);

	} finally {
	listenerGlobal.unregister();
	listener1.unregister();
	listener2.unregister();
	if (bundle != null)
	bundle.uninstall();
	}
	}

	/**
	* Tests listener registered multiple times: once on xp1, once on xp2
	*/
	public void testMultipleRegistrations() throws IOException, BundleException {
	Bundle bundle = null;
	WaitingRegistryListener listener = new WaitingRegistryListener();
	Platform.getExtensionRegistry().addListener(listener, "bundleMultiple.xp1");
	Platform.getExtensionRegistry().addListener(listener, "bundleMultiple.xp1");
	try {
	bundle = BundleTestingHelper.installBundle("0.1", RuntimeTestsPlugin.getContext(), RuntimeTestsPlugin.TEST_FILES_ROOT + "registryListener/bundleMultiple");

	Bundle[] testBundles = new Bundle[] {bundle};
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	// 1st registration: extension point; extension => 2 callbacks
	// 2nd registration should be ignored: extension => 0 callbacks
	// total: 2 callbacks
	assertTrue(listener.waitFor(2, MAX_TIME_PER_BUNDLE) == 2);

	// test additions on listener on extension point with extensions
	String[] extPointIDs = listener.extPointsReceived(50);
	String[] extensionsReceived = listener.extensionsReceived(50);
	assertTrue(listener.isAdded());
	checkIDs(extPointIDs, new String[] {"bundleMultiple.xp1"});
	checkIDs(extensionsReceived, new String[] {"bundleMultiple.ext11", "bundleMultiple.ext12"});

	// removal: unregistering listener once should remove both registrations
	listener.reset();
	listener.unregister();
	bundle.uninstall();
	bundle = null; // reset as early as possible in case of exception
	BundleTestingHelper.refreshPackages(RuntimeTestsPlugin.getContext(), testBundles);

	// test removals on listener on extension point with extensions
	assertTrue(listener.waitFor(3, 200) == 0);
	extPointIDs = listener.extPointsReceived(50);
	extensionsReceived = listener.extensionsReceived(50);
	assertNull(extPointIDs);
	assertNull(extensionsReceived);
	} finally {
	// second unregistration should have no effect
	listener.unregister();
	if (bundle != null)
	bundle.uninstall();
	}
	}

	// For simplicity, this method does not expect duplicate IDs in either array
	private void checkIDs(String[] receivedIDs, String[] expectedIDs) {
	assertNotNull(receivedIDs);
	assertNotNull(expectedIDs);
	assertTrue(receivedIDs.length == expectedIDs.length);
	for (int i = 0; i < expectedIDs.length; i++) {
	String expected = expectedIDs[i];
	boolean found = false;
	for (int j = 0; j < receivedIDs.length; j++) {
	if (expected.equals(receivedIDs[j])) {
	found = true;
	break;
	}
	}
	assertTrue(found);
	}
	}

	public static Test suite() {
	return new TestSuite(RegistryListenerTest.class);
	}

	}