Attachment #84225 for bug #207505

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




		return bundle;
	}

	private void applyDeltas(BundleDelta[] bundleDeltas) throws BundleException {
		Arrays.sort(bundleDeltas, new Comparator() {
			public int compare(Object delta0, Object delta1) {
				return (int) (((BundleDelta) delta0).getBundle().getBundleId() - ((BundleDelta) delta1).getBundle().getBundleId());
			}
		});
		ArrayList results = new ArrayList(bundleDeltas.length);
		for (int i = 0; i < bundleDeltas.length; i++) {
			int type = bundleDeltas[i].getType();
			if ((type & (BundleDelta.REMOVAL_PENDING | BundleDelta.REMOVAL_COMPLETE)) != 0)

						} catch (BundleException e) {
							framework.publishFrameworkEvent(FrameworkEvent.ERROR, bundle, e);
						}
					results.add(bundle);
				}
			}
		}
		return (AbstractBundle[]) (results.size() == 0 ? null : results.toArray(new AbstractBundle[results.size()]));
	}

	private AbstractBundle[] processDelta(BundleDelta[] bundleDeltas, boolean refreshPackages) {

		// then sort by dependency order
		StartLevelManager.sortByDependency(refresh);
		boolean[] previouslyResolved = new boolean[refresh.length];
		AbstractBundle[] resolved = null;
		try {
			try {
				if (Debug.DEBUG && Debug.DEBUG_PACKAGEADMIN) {

				}

				synchronized (framework.bundles) {
					for (int i = refresh.length - 1; i >= 0; i--)
						refresh[i].refresh();
				}
				// send out unresolved events outside synch block (defect #80610)
				// send out unresolved events in reverse dependency order (defect #207505)
				for (int i = refresh.length - 1; i >= 0; i--) {
					// send out unresolved events
					if (previouslyResolved[i])
						framework.publishBundleEvent(BundleEvent.UNRESOLVED, refresh[i]);

					Debug.println("refreshPackages: applying deltas to bundles"); //$NON-NLS-1$
				}
				synchronized (framework.bundles) {
					applyDeltas(bundleDeltas);
				}

			} finally {

		// send out any resolved.  This must be done after the state change locks have been release.
		if (Debug.DEBUG && Debug.DEBUG_PACKAGEADMIN)
			Debug.println("refreshPackages: send out RESOLVED events"); //$NON-NLS-1$
		for (int i = 0; i < refresh.length; i++)
			if (refresh[i].isResolved())
				framework.publishBundleEvent(BundleEvent.RESOLVED, refresh[i]);

		return refresh;
	}

Lines 16-21 Link Here

(-)src/org/eclipse/osgi/tests/bundles/BundleTests.java (+1 lines)
16	public class BundleTests {	16	public class BundleTests {
17	public static Test suite() {	17	public static Test suite() {
18	TestSuite suite = new TestSuite(BundleTests.class.getName());	18	TestSuite suite = new TestSuite(BundleTests.class.getName());
		19	suite.addTest(PackageAdminBundleTests.suite());
19	suite.addTest(PlatformAdminBundleTests.suite());	20	suite.addTest(PlatformAdminBundleTests.suite());
20	suite.addTest(ExtensionBundleTests.suite());	21	suite.addTest(ExtensionBundleTests.suite());
21	suite.addTest(ClassLoadingBundleTests.suite());	22	suite.addTest(ClassLoadingBundleTests.suite());




/*******************************************************************************
 * Copyright (c) 2007 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.bundles;

import java.util.ArrayList;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.osgi.tests.OSGiTestsActivator;
import org.osgi.framework.*;

public class PackageAdminBundleTests extends AbstractBundleTests {
	public class TestListener implements SynchronousBundleListener {
		ArrayList events = new ArrayList();

		public synchronized void bundleChanged(BundleEvent event) {
			events.add(event);
		}

		public synchronized BundleEvent[] getEvents() {
			try {
				return (BundleEvent[]) events.toArray(new BundleEvent[0]);
			} finally {
				events.clear();
			}
		}
	}

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

	public void testBundleEvents01() throws Exception {
		Bundle chainTest = installer.installBundle("chain.test");
		Bundle chainTestA = installer.installBundle("chain.test.a");
		Bundle chainTestB = installer.installBundle("chain.test.b");
		Bundle chainTestC = installer.installBundle("chain.test.c");
		Bundle chainTestD = installer.installBundle("chain.test.d");
		Bundle[] resolveBundles = new Bundle[] {chainTestC, chainTestA, chainTestB, chainTest, chainTestD};
		Bundle[] dependencyOrder = new Bundle[] {chainTest, chainTestA, chainTestB, chainTestC, chainTestD};
		TestListener testListener = new TestListener();
		OSGiTestsActivator.getContext().addBundleListener(testListener);
		try {
			installer.resolveBundles(resolveBundles);
			BundleEvent[] events = testListener.getEvents();
			assertEquals("Event count", 10, events.length);
			int j = 0;
			for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
				assertTrue("Resolved Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
				assertEquals("Expecting Resolved event", BundleEvent.RESOLVED, events[j].getType());
			}
			j = 5;
			for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
				assertTrue("Lazy Starting Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
				assertEquals("Expecting Lazy Starting event", BundleEvent.LAZY_ACTIVATION, events[j].getType());
			}
		} finally {
			OSGiTestsActivator.getContext().removeBundleListener(testListener);
		}
	}

	public void testBundleEvents02() throws Exception {
		Bundle chainTest = installer.installBundle("chain.test");
		Bundle chainTestA = installer.installBundle("chain.test.a");
		Bundle chainTestB = installer.installBundle("chain.test.b");
		Bundle chainTestC = installer.installBundle("chain.test.c");
		Bundle chainTestD = installer.installBundle("chain.test.d");
		Bundle[] resolveBundles = new Bundle[] {chainTestC, chainTestA, chainTestB, chainTest, chainTestD};
		Bundle[] dependencyOrder = new Bundle[] {chainTest, chainTestA, chainTestB, chainTestC, chainTestD};
		TestListener testListener = new TestListener();
		OSGiTestsActivator.getContext().addBundleListener(testListener);
		try {
			installer.resolveBundles(resolveBundles);
			BundleEvent[] events = testListener.getEvents();
			// throw away the events.  This was already tested
			installer.refreshPackages(resolveBundles);
			events = testListener.getEvents();
			assertEquals("Event count", 25, events.length);
			int j = 0;
			for (int i = 0; i < dependencyOrder.length; i++, j += 2) {
				assertTrue("Stopping Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
				assertEquals("Expecting Stopping event", BundleEvent.STOPPING, events[j].getType());
				assertTrue("Stopped Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j + 1].getBundle());
				assertEquals("Expecting Stopping event", BundleEvent.STOPPED, events[j + 1].getType());
			}
			j = 10;
			for (int i = 0; i < dependencyOrder.length; i++, j++) {
				assertTrue("Unresolved Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
				assertEquals("Expecting Unresolved event", BundleEvent.UNRESOLVED, events[j].getType());
			}
			j = 15;
			for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
				assertTrue("Resolved Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
				assertEquals("Expecting Resolved event", BundleEvent.RESOLVED, events[j].getType());
			}
			j = 20;
			for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
				assertTrue("Lazy Starting Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
				assertEquals("Expecting Lazy Starting event", BundleEvent.LAZY_ACTIVATION, events[j].getType());
			}

		} finally {
			OSGiTestsActivator.getContext().removeBundleListener(testListener);
		}
	}
}

Return to bug 207505

Lines 337-349 Link Here

(-)core/framework/org/eclipse/osgi/framework/internal/core/PackageAdminImpl.java (-11 / +8 lines)
337	return bundle;	337	return bundle;
338	}	338	}
339		339
340	private AbstractBundle[] applyDeltas(BundleDelta[] bundleDeltas) throws BundleException {	340	private void applyDeltas(BundleDelta[] bundleDeltas) throws BundleException {
341	Arrays.sort(bundleDeltas, new Comparator() {	341	Arrays.sort(bundleDeltas, new Comparator() {
342	public int compare(Object delta0, Object delta1) {	342	public int compare(Object delta0, Object delta1) {
343	return (int) (((BundleDelta) delta0).getBundle().getBundleId() - ((BundleDelta) delta1).getBundle().getBundleId());	343	return (int) (((BundleDelta) delta0).getBundle().getBundleId() - ((BundleDelta) delta1).getBundle().getBundleId());
344	}	344	}
345	});	345	});
346	ArrayList results = new ArrayList(bundleDeltas.length);
347	for (int i = 0; i < bundleDeltas.length; i++) {	346	for (int i = 0; i < bundleDeltas.length; i++) {
348	int type = bundleDeltas[i].getType();	347	int type = bundleDeltas[i].getType();
349	if ((type & (BundleDelta.REMOVAL_PENDING \| BundleDelta.REMOVAL_COMPLETE)) != 0)	348	if ((type & (BundleDelta.REMOVAL_PENDING \| BundleDelta.REMOVAL_COMPLETE)) != 0)
Lines 359-369 Link Here
359	} catch (BundleException e) {	358	} catch (BundleException e) {
360	framework.publishFrameworkEvent(FrameworkEvent.ERROR, bundle, e);	359	framework.publishFrameworkEvent(FrameworkEvent.ERROR, bundle, e);
361	}	360	}
362	results.add(bundle);
363	}	361	}
364	}	362	}
365	}	363	}
366	return (AbstractBundle[]) (results.size() == 0 ? null : results.toArray(new AbstractBundle[results.size()]));
367	}	364	}
368		365
369	private AbstractBundle[] processDelta(BundleDelta[] bundleDeltas, boolean refreshPackages) {	366	private AbstractBundle[] processDelta(BundleDelta[] bundleDeltas, boolean refreshPackages) {
Lines 383-389 Link Here
383	// then sort by dependency order	380	// then sort by dependency order
384	StartLevelManager.sortByDependency(refresh);	381	StartLevelManager.sortByDependency(refresh);
385	boolean[] previouslyResolved = new boolean[refresh.length];	382	boolean[] previouslyResolved = new boolean[refresh.length];
386	AbstractBundle[] resolved = null;
387	try {	383	try {
388	try {	384	try {
389	if (Debug.DEBUG && Debug.DEBUG_PACKAGEADMIN) {	385	if (Debug.DEBUG && Debug.DEBUG_PACKAGEADMIN) {
Lines 420-430 Link Here
420	}	416	}
421		417
422	synchronized (framework.bundles) {	418	synchronized (framework.bundles) {
423	for (int i = 0; i < refresh.length; i++)	419	for (int i = refresh.length - 1; i >= 0; i--)
424	refresh[i].refresh();	420	refresh[i].refresh();
425	}	421	}
426	// send out unresolved events outside synch block (defect #80610)	422	// send out unresolved events outside synch block (defect #80610)
427	for (int i = 0; i < refresh.length; i++) {	423	// send out unresolved events in reverse dependency order (defect #207505)
		424	for (int i = refresh.length - 1; i >= 0; i--) {
428	// send out unresolved events	425	// send out unresolved events
429	if (previouslyResolved[i])	426	if (previouslyResolved[i])
430	framework.publishBundleEvent(BundleEvent.UNRESOLVED, refresh[i]);	427	framework.publishBundleEvent(BundleEvent.UNRESOLVED, refresh[i]);
Lines 437-443 Link Here
437	Debug.println("refreshPackages: applying deltas to bundles"); //$NON-NLS-1$	434	Debug.println("refreshPackages: applying deltas to bundles"); //$NON-NLS-1$
438	}	435	}
439	synchronized (framework.bundles) {	436	synchronized (framework.bundles) {
440	resolved = applyDeltas(bundleDeltas);	437	applyDeltas(bundleDeltas);
441	}	438	}
442		439
443	} finally {	440	} finally {
Lines 480-488 Link Here
480	// send out any resolved. This must be done after the state change locks have been release.	477	// send out any resolved. This must be done after the state change locks have been release.
481	if (Debug.DEBUG && Debug.DEBUG_PACKAGEADMIN)	478	if (Debug.DEBUG && Debug.DEBUG_PACKAGEADMIN)
482	Debug.println("refreshPackages: send out RESOLVED events"); //$NON-NLS-1$	479	Debug.println("refreshPackages: send out RESOLVED events"); //$NON-NLS-1$
483	if (resolved != null)	480	for (int i = 0; i < refresh.length; i++)
484	for (int i = 0; i < resolved.length; i++)	481	if (refresh[i].isResolved())
485	framework.publishBundleEvent(BundleEvent.RESOLVED, resolved[i]);	482	framework.publishBundleEvent(BundleEvent.RESOLVED, refresh[i]);
486		483
487	return refresh;	484	return refresh;
488	}	485	}

Added Link Here

(-)src/org/eclipse/osgi/tests/bundles/PackageAdminBundleTests.java (+113 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.osgi.tests.bundles;
12
13	import java.util.ArrayList;
14	import junit.framework.Test;
15	import junit.framework.TestSuite;
16	import org.eclipse.osgi.tests.OSGiTestsActivator;
17	import org.osgi.framework.*;
18
19	public class PackageAdminBundleTests extends AbstractBundleTests {
20	public class TestListener implements SynchronousBundleListener {
21	ArrayList events = new ArrayList();
22
23	public synchronized void bundleChanged(BundleEvent event) {
24	events.add(event);
25	}
26
27	public synchronized BundleEvent[] getEvents() {
28	try {
29	return (BundleEvent[]) events.toArray(new BundleEvent[0]);
30	} finally {
31	events.clear();
32	}
33	}
34	}
35
36	public static Test suite() {
37	return new TestSuite(PackageAdminBundleTests.class);
38	}
39
40	public void testBundleEvents01() throws Exception {
41	Bundle chainTest = installer.installBundle("chain.test");
42	Bundle chainTestA = installer.installBundle("chain.test.a");
43	Bundle chainTestB = installer.installBundle("chain.test.b");
44	Bundle chainTestC = installer.installBundle("chain.test.c");
45	Bundle chainTestD = installer.installBundle("chain.test.d");
46	Bundle[] resolveBundles = new Bundle[] {chainTestC, chainTestA, chainTestB, chainTest, chainTestD};
47	Bundle[] dependencyOrder = new Bundle[] {chainTest, chainTestA, chainTestB, chainTestC, chainTestD};
48	TestListener testListener = new TestListener();
49	OSGiTestsActivator.getContext().addBundleListener(testListener);
50	try {
51	installer.resolveBundles(resolveBundles);
52	BundleEvent[] events = testListener.getEvents();
53	assertEquals("Event count", 10, events.length);
54	int j = 0;
55	for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
56	assertTrue("Resolved Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
57	assertEquals("Expecting Resolved event", BundleEvent.RESOLVED, events[j].getType());
58	}
59	j = 5;
60	for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
61	assertTrue("Lazy Starting Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
62	assertEquals("Expecting Lazy Starting event", BundleEvent.LAZY_ACTIVATION, events[j].getType());
63	}
64	} finally {
65	OSGiTestsActivator.getContext().removeBundleListener(testListener);
66	}
67	}
68
69	public void testBundleEvents02() throws Exception {
70	Bundle chainTest = installer.installBundle("chain.test");
71	Bundle chainTestA = installer.installBundle("chain.test.a");
72	Bundle chainTestB = installer.installBundle("chain.test.b");
73	Bundle chainTestC = installer.installBundle("chain.test.c");
74	Bundle chainTestD = installer.installBundle("chain.test.d");
75	Bundle[] resolveBundles = new Bundle[] {chainTestC, chainTestA, chainTestB, chainTest, chainTestD};
76	Bundle[] dependencyOrder = new Bundle[] {chainTest, chainTestA, chainTestB, chainTestC, chainTestD};
77	TestListener testListener = new TestListener();
78	OSGiTestsActivator.getContext().addBundleListener(testListener);
79	try {
80	installer.resolveBundles(resolveBundles);
81	BundleEvent[] events = testListener.getEvents();
82	// throw away the events. This was already tested
83	installer.refreshPackages(resolveBundles);
84	events = testListener.getEvents();
85	assertEquals("Event count", 25, events.length);
86	int j = 0;
87	for (int i = 0; i < dependencyOrder.length; i++, j += 2) {
88	assertTrue("Stopping Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
89	assertEquals("Expecting Stopping event", BundleEvent.STOPPING, events[j].getType());
90	assertTrue("Stopped Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j + 1].getBundle());
91	assertEquals("Expecting Stopping event", BundleEvent.STOPPED, events[j + 1].getType());
92	}
93	j = 10;
94	for (int i = 0; i < dependencyOrder.length; i++, j++) {
95	assertTrue("Unresolved Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
96	assertEquals("Expecting Unresolved event", BundleEvent.UNRESOLVED, events[j].getType());
97	}
98	j = 15;
99	for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
100	assertTrue("Resolved Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
101	assertEquals("Expecting Resolved event", BundleEvent.RESOLVED, events[j].getType());
102	}
103	j = 20;
104	for (int i = dependencyOrder.length - 1; i >= 0; i--, j++) {
105	assertTrue("Lazy Starting Event Bundle: " + dependencyOrder[i].getSymbolicName(), dependencyOrder[i] == events[j].getBundle());
106	assertEquals("Expecting Lazy Starting event", BundleEvent.LAZY_ACTIVATION, events[j].getType());
107	}
108
109	} finally {
110	OSGiTestsActivator.getContext().removeBundleListener(testListener);
111	}
112	}
113	}