diff --git a/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/RegionReflectionUtils.java b/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/RegionReflectionUtils.java
index 87a13f5..e33d2d2 100644
--- a/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/RegionReflectionUtils.java
+++ b/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/RegionReflectionUtils.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 IBM Corporation and others.
+ * Copyright (c) 2013, 2015 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
@@ -172,10 +172,10 @@
 		return (CollisionHook) newInstance(regionBundleCollisionHook, classParams, constructorArgs);
 	}
 
-	public static EventHook newRegionBundleEventHook(RegionDigraph digraph, FindHook findHook, ThreadLocal<Region> threadLocal) {
+	public static EventHook newRegionBundleEventHook(RegionDigraph digraph, ThreadLocal<Region> threadLocal, long bundleId) {
 		Class<?> regionBundleEventHook = loadRegionImplClass(RegionBundleEventHook);
-		Class<?>[] classParams = new Class<?>[] {RegionDigraph.class, FindHook.class, ThreadLocal.class};
-		Object[] constructorArgs = new Object[] {digraph, findHook, threadLocal};
+		Class<?>[] classParams = new Class<?>[] {RegionDigraph.class, ThreadLocal.class, long.class};
+		Object[] constructorArgs = new Object[] {digraph, threadLocal, bundleId};
 		return (EventHook) newInstance(regionBundleEventHook, classParams, constructorArgs);
 	}
 
diff --git a/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionBundleEventHookTests.java b/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionBundleEventHookTests.java
index 38f0de4..a6047b2 100644
--- a/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionBundleEventHookTests.java
+++ b/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionBundleEventHookTests.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011, 2013 VMware Inc.
+ * Copyright (c) 2011, 2015 VMware Inc. 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
@@ -11,76 +11,72 @@
 
 package org.eclipse.equinox.region.internal.tests.hook;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Collection;
-import java.util.HashSet;
-import org.easymock.EasyMock;
-import org.eclipse.equinox.region.Region;
-import org.eclipse.equinox.region.RegionDigraph;
+import java.util.*;
+import org.eclipse.equinox.region.*;
 import org.eclipse.equinox.region.internal.tests.RegionReflectionUtils;
 import org.eclipse.virgo.teststubs.osgi.framework.StubBundle;
 import org.eclipse.virgo.teststubs.osgi.framework.StubBundleContext;
 import org.junit.*;
 import org.osgi.framework.*;
 import org.osgi.framework.hooks.bundle.EventHook;
-import org.osgi.framework.hooks.bundle.FindHook;
 
 public class RegionBundleEventHookTests {
 
-	private BundleEvent bundleEvent;
+	private static final String BUNDLE_X = "X";
 
-	private Collection<BundleContext> contexts;
+	private static final Version BUNDLE_VERSION = new Version("0");
 
-	private Bundle eventBundle;
+	private long bundleId;
 
-	private RegionDigraph mockRegionDigraph;
+	private static final String REGION_A = "RegionA";
 
-	private ThreadLocal<Region> threadLocal;
+	private static final String BUNDLE_A = "BundleA";
+
+	private static final String REGION_B = "RegionB";
+
+	private static final String BUNDLE_B = "BundleB";
+
+	private static final String REGION_C = "RegionC";
+
+	private static final String BUNDLE_C = "BundleC";
+
+	private static final String REGION_D = "RegionD";
+
+	private static final String BUNDLE_D = "BundleD";
 
 	private RegionDigraph digraph;
 
-	private Region mockRegion1;
+	private EventHook bundleEventHook;
 
-	private Region mockRegion2;
+	private Map<String, Region> regions;
 
-	private BundleEvent installedEvent1;
+	private Map<String, Bundle> bundles;
 
-	private BundleEvent installedEvent2;
-
-	private StubBundle eventBundle1;
-
-	private StubBundle eventBundle2;
+	private ThreadLocal<Region> threadLocal;
 
 	@Before
 	public void setUp() throws Exception {
-		this.mockRegionDigraph = EasyMock.createMock(RegionDigraph.class);
-		this.eventBundle = new StubBundle();
-
-		this.eventBundle1 = new StubBundle(1L, "my.bundle1", new Version("0"), "loc1");
-		this.eventBundle2 = new StubBundle(2L, "my.bundle2", new Version("0"), "loc2");
-
-		this.bundleEvent = new BundleEvent(BundleEvent.STARTED, this.eventBundle, this.eventBundle);
-
-		this.installedEvent1 = new BundleEvent(BundleEvent.INSTALLED, eventBundle1, this.eventBundle);
-		this.installedEvent2 = new BundleEvent(BundleEvent.INSTALLED, eventBundle2, this.eventBundle);
-
-		this.contexts = new HashSet<BundleContext>();
-		StubBundleContext stubListenerBundleContext = new StubBundleContext();
-		this.contexts.add(stubListenerBundleContext);
-		this.threadLocal = new ThreadLocal<Region>();
+		this.bundleId = 1L;
+		this.regions = new HashMap<String, Region>();
+		this.bundles = new HashMap<String, Bundle>();
 
 		StubBundle stubSystemBundle = new StubBundle(0L, "osgi.framework", new Version("0"), "loc");
 		StubBundleContext stubBundleContext = new StubBundleContext();
 		stubBundleContext.addInstalledBundle(stubSystemBundle);
-		this.digraph = RegionReflectionUtils.newStandardRegionDigraph(stubBundleContext, new ThreadLocal<Region>());
-		this.digraph.createRegion("mockRegion1");
-		this.digraph.createRegion("mockRegion2");
-		this.mockRegion1 = digraph.getRegion("mockRegion1");
-		this.mockRegion2 = digraph.getRegion("mockRegion2");
-		this.mockRegion1.addBundle(this.eventBundle);
+		this.threadLocal = new ThreadLocal<Region>();
+		this.digraph = RegionReflectionUtils.newStandardRegionDigraph(stubBundleContext, this.threadLocal);
+		this.bundleEventHook = RegionReflectionUtils.newRegionBundleEventHook(digraph, threadLocal, stubSystemBundle.getBundleId());
 
+		// Create regions A, B, C, D containing bundles A, B, C, D, respectively.
+		createRegion(REGION_A, BUNDLE_A);
+		createRegion(REGION_B, BUNDLE_B);
+		createRegion(REGION_C, BUNDLE_C);
+		createRegion(REGION_D, BUNDLE_D);
+
+		createBundle(BUNDLE_X);
 	}
 
 	@After
@@ -89,53 +85,225 @@
 	}
 
 	@Test
-	public void testEventAllowed() {
-		FindHook mockFindHook = new FindHook() {
-
-			@Override
-			public void find(BundleContext context, Collection<Bundle> bundles) {
-				// nothing
-			}
-		};
-		EventHook eventHook = RegionReflectionUtils.newRegionBundleEventHook(this.mockRegionDigraph, mockFindHook, this.threadLocal);
-		eventHook.event(this.bundleEvent, this.contexts);
-		assertEquals(1, this.contexts.size());
+	public void testEventInSameRegion() {
+		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_A), contexts);
+		assertTrue(contexts.contains(bundleContext(BUNDLE_A)));
 	}
 
 	@Test
-	public void testEventNotAllowed() {
-		FindHook mockFindHook = new FindHook() {
+	public void testEventInDisconnectedRegion() {
+		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_B), contexts);
+		assertFalse(contexts.contains(bundleContext(BUNDLE_A)));
+	}
 
-			@Override
-			public void find(BundleContext context, Collection<Bundle> bundles) {
-				bundles.clear();
-			}
-		};
-		EventHook eventHook = RegionReflectionUtils.newRegionBundleEventHook(this.mockRegionDigraph, mockFindHook, this.threadLocal);
-		eventHook.event(this.bundleEvent, this.contexts);
-		assertTrue(this.contexts.isEmpty());
+	@Test
+	public void testEventConnectedRegionAllowed() throws BundleException, InvalidSyntaxException {
+		doTestEventConnectedRegionAllowed(false);
+	}
+
+	@Test
+	public void testEventConnectedRegionAllowedWithNegate() throws BundleException, InvalidSyntaxException {
+		doTestEventConnectedRegionAllowed(true);
+	}
+
+	private void doTestEventConnectedRegionAllowed(boolean negate) throws BundleException, InvalidSyntaxException {
+		RegionFilter filter = createFilter(negate, BUNDLE_B);
+		region(REGION_A).connectRegion(region(REGION_B), filter);
+
+		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_B), contexts);
+		assertTrue(contexts.contains(bundleContext(BUNDLE_A)));
+	}
+
+	@Test
+	public void testEventConnectedRegionFiltering() throws BundleException, InvalidSyntaxException {
+		doTestEventConnectedRegionFiltering(false);
+	}
+
+	@Test
+	public void testEventConnectedRegionFilteringWithNegate() throws BundleException, InvalidSyntaxException {
+		doTestEventConnectedRegionFiltering(true);
+	}
+
+	private void doTestEventConnectedRegionFiltering(boolean negate) throws BundleException, InvalidSyntaxException {
+		region(REGION_A).connectRegion(region(REGION_B), createFilter(negate, BUNDLE_B));
+		Bundle x = createBundle(BUNDLE_X);
+		region(REGION_B).addBundle(x);
+
+		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A, BUNDLE_B, BUNDLE_X);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_X), contexts);
+		assertTrue(contexts.contains(bundleContext(BUNDLE_B)));
+		assertTrue(contexts.contains(bundleContext(BUNDLE_X)));
+		assertFalse(contexts.contains(bundleContext(BUNDLE_A)));
+	}
+
+	@Test
+	public void testEventTransitive() throws BundleException, InvalidSyntaxException {
+		doTestEventTransitive(false);
+	}
+
+	@Test
+	public void testEventTransitiveWithNegate() throws BundleException, InvalidSyntaxException {
+		doTestEventTransitive(true);
+	}
+
+	private void doTestEventTransitive(boolean negate) throws BundleException, InvalidSyntaxException {
+		region(REGION_A).connectRegion(region(REGION_B), createFilter(negate, BUNDLE_C));
+		region(REGION_B).connectRegion(region(REGION_C), createFilter(negate, BUNDLE_C));
+		region(REGION_C).addBundle(bundle(BUNDLE_X));
+
+		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A, BUNDLE_B, BUNDLE_X);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_C), contexts);
+		assertTrue(contexts.contains(bundleContext(BUNDLE_B)));
+		assertTrue(contexts.contains(bundleContext(BUNDLE_X)));
+		assertTrue(contexts.contains(bundleContext(BUNDLE_A)));
+
+		contexts = bundleContexts(BUNDLE_A, BUNDLE_B, BUNDLE_X);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_X), contexts);
+		assertFalse(contexts.contains(bundleContext(BUNDLE_B)));
+		assertTrue(contexts.contains(bundleContext(BUNDLE_X)));
+		assertFalse(contexts.contains(bundleContext(BUNDLE_A)));
+	}
+
+	@Test
+	public void testEventInCyclicGraph() throws BundleException, InvalidSyntaxException {
+		doTestEventInCyclicGraph(false);
+	}
+
+	@Test
+	public void testEventInCyclicGraphWithNegate() throws BundleException, InvalidSyntaxException {
+
+		doTestEventInCyclicGraph(true);
+	}
+
+	private void doTestEventInCyclicGraph(boolean negate) throws BundleException, InvalidSyntaxException {
+		region(REGION_D).addBundle(bundle(BUNDLE_X));
+
+		region(REGION_A).connectRegion(region(REGION_B), createFilter(negate, BUNDLE_D, BUNDLE_X));
+		region(REGION_B).connectRegion(region(REGION_A), createFilter(negate));
+
+		region(REGION_B).connectRegion(region(REGION_D), createFilter(negate, BUNDLE_D));
+		region(REGION_D).connectRegion(region(REGION_B), createFilter(negate));
+
+		region(REGION_B).connectRegion(region(REGION_C), createFilter(negate, BUNDLE_X));
+		region(REGION_C).connectRegion(region(REGION_B), createFilter(negate));
+
+		region(REGION_C).connectRegion(region(REGION_D), createFilter(negate, BUNDLE_X));
+		region(REGION_D).connectRegion(region(REGION_C), createFilter(negate));
+
+		region(REGION_A).connectRegion(region(REGION_C), createFilter(negate));
+		region(REGION_C).connectRegion(region(REGION_A), createFilter(negate));
+
+		region(REGION_D).connectRegion(region(REGION_A), createFilter(negate));
+		region(REGION_A).connectRegion(region(REGION_D), createFilter(negate));
+
+		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A, BUNDLE_B);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_B), contexts);
+		assertFalse(contexts.contains(bundleContext(BUNDLE_A)));
+		assertTrue(contexts.contains(bundleContext(BUNDLE_B)));
+
+		contexts = bundleContexts(BUNDLE_A, BUNDLE_B);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_C), contexts);
+		assertFalse(contexts.contains(bundleContext(BUNDLE_A)));
+		assertFalse(contexts.contains(bundleContext(BUNDLE_B)));
+
+		contexts = bundleContexts(BUNDLE_A, BUNDLE_B);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_D), contexts);
+		assertTrue(contexts.contains(bundleContext(BUNDLE_A)));
+		assertTrue(contexts.contains(bundleContext(BUNDLE_B)));
+
+		contexts = bundleContexts(BUNDLE_A, BUNDLE_B);
+		this.bundleEventHook.event(bundleEvent(BUNDLE_X), contexts);
+		assertTrue(contexts.contains(bundleContext(BUNDLE_A)));
+		assertTrue(contexts.contains(bundleContext(BUNDLE_B)));
+	}
+
+	@Test
+	public void testEventFromSystemBundle() {
+		Bundle systemBundle = new StubBundle(0L, "sys", BUNDLE_VERSION, "");
+		Collection<BundleContext> contexts = new ArrayList<BundleContext>(Arrays.asList(systemBundle.getBundleContext()));
+		this.bundleEventHook.event(bundleEvent(BUNDLE_A), contexts);
+		assertTrue(contexts.contains(systemBundle.getBundleContext()));
+	}
+
+	@Test
+	public void testEventFromBundleInNoRegion() {
+		Bundle stranger = createBundle("stranger");
+		Collection<BundleContext> contexts = new ArrayList<BundleContext>(Arrays.asList(stranger.getBundleContext()));
+		this.bundleEventHook.event(bundleEvent(BUNDLE_A), contexts);
+		assertTrue(contexts.isEmpty());
 	}
 
 	@Test
 	public void testDefaultRegion() {
-		FindHook mockFindHook = new FindHook() {
-
-			@Override
-			public void find(BundleContext context, Collection<Bundle> bundles) {
-				bundles.clear();
-			}
-		};
-
 		this.digraph.setDefaultRegion(null);
-		EventHook eventHook = RegionReflectionUtils.newRegionBundleEventHook(this.digraph, mockFindHook, this.threadLocal);
-		eventHook.event(this.installedEvent1, this.contexts);
-		assertTrue(this.digraph.getRegion(this.eventBundle1).equals(this.mockRegion1));
+		Bundle x = createBundle("installed.X");
+		this.bundleEventHook.event(new BundleEvent(BundleEvent.INSTALLED, x, bundle(BUNDLE_A)), Collections.<BundleContext> emptyList());
+		assertTrue(this.digraph.getRegion(x).equals(region(REGION_A)));
 
-		this.digraph.setDefaultRegion(this.mockRegion2);
-		eventHook = RegionReflectionUtils.newRegionBundleEventHook(this.digraph, mockFindHook, this.threadLocal);
-		eventHook.event(this.installedEvent2, this.contexts);
-		assertTrue(this.digraph.getRegion(this.eventBundle2).equals(this.mockRegion2));
-
+		this.digraph.setDefaultRegion(region(REGION_B));
+		Bundle y = createBundle("installed.Y");
+		this.bundleEventHook.event(new BundleEvent(BundleEvent.INSTALLED, y, bundle(BUNDLE_A)), Collections.<BundleContext> emptyList());
+		assertTrue(this.digraph.getRegion(y).equals(region(REGION_B)));
 	}
 
+	private Region createRegion(String regionName, String... bundleSymbolicNames) throws BundleException {
+		Region region = this.digraph.createRegion(regionName);
+		for (String bundleSymbolicName : bundleSymbolicNames) {
+			Bundle stubBundle = createBundle(bundleSymbolicName);
+			region.addBundle(stubBundle);
+		}
+		this.regions.put(regionName, region);
+		return region;
+	}
+
+	private Region region(String regionName) {
+		return this.regions.get(regionName);
+	}
+
+	private RegionFilter createFilter(boolean negate, String... bundleSymbolicNames) throws InvalidSyntaxException {
+		Collection<String> filters = new ArrayList<String>(bundleSymbolicNames.length);
+		for (String bundleSymbolicName : bundleSymbolicNames) {
+			filters.add('(' + RegionFilter.VISIBLE_BUNDLE_NAMESPACE + '=' + bundleSymbolicName + ')');
+		}
+		RegionFilterBuilder builder = digraph.createRegionFilterBuilder();
+		for (String filter : filters) {
+			builder.allow(RegionFilter.VISIBLE_BUNDLE_NAMESPACE, filter);
+		}
+
+		if (negate) {
+			String negateFilter = "(!(|" + "(" + RegionFilter.VISIBLE_ALL_NAMESPACE_ATTRIBUTE + "=" + RegionFilter.VISIBLE_BUNDLE_NAMESPACE + ")" + "(" + RegionFilter.VISIBLE_ALL_NAMESPACE_ATTRIBUTE + "=" + RegionFilter.VISIBLE_BUNDLE_LIFECYCLE_NAMESPACE + ")" + "))";
+			builder.allow(RegionFilter.VISIBLE_ALL_NAMESPACE, negateFilter);
+		}
+		return builder.build();
+	}
+
+	private Bundle createBundle(String bundleSymbolicName) {
+		Bundle stubBundle = new StubBundle(this.bundleId++, bundleSymbolicName, BUNDLE_VERSION, "loc:" + bundleSymbolicName);
+		this.bundles.put(bundleSymbolicName, stubBundle);
+		return stubBundle;
+	}
+
+	private Collection<BundleContext> bundleContexts(String... bundleSymbolicNames) {
+		Collection<BundleContext> contexts = new ArrayList<BundleContext>();
+		for (String symbolicName : bundleSymbolicNames) {
+			contexts.add(bundleContext(symbolicName));
+		}
+		return contexts;
+	}
+
+	private BundleContext bundleContext(String bundleSymbolicName) {
+		return bundle(bundleSymbolicName).getBundleContext();
+	}
+
+	private BundleEvent bundleEvent(String budnleSymbolicName) {
+		return new BundleEvent(BundleEvent.STARTED, bundle(budnleSymbolicName));
+	}
+
+	private Bundle bundle(String bundleSymbolicName) {
+		Bundle bundleA = this.bundles.get(bundleSymbolicName);
+		return bundleA;
+	}
 }
diff --git a/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionServiceEventHookTests.java b/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionServiceEventHookTests.java
index cb0758b..014370f 100644
--- a/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionServiceEventHookTests.java
+++ b/bundles/org.eclipse.equinox.region.tests/src/org/eclipse/equinox/region/internal/tests/hook/RegionServiceEventHookTests.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011, 2015 VMware Inc.
+ * Copyright (c) 2011, 2015 VMware Inc. 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
@@ -94,21 +94,21 @@
 	}
 
 	@Test
-	public void testFindInSameRegion() {
+	public void testEventInSameRegion() {
 		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A);
 		this.serviceEventHook.event(serviceEvent(BUNDLE_A), contexts);
 		assertTrue(contexts.contains(bundleContext(BUNDLE_A)));
 	}
 
 	@Test
-	public void testFindInDisconnectedRegion() {
+	public void testEventInDisconnectedRegion() {
 		Collection<BundleContext> contexts = bundleContexts(BUNDLE_A);
 		this.serviceEventHook.event(serviceEvent(BUNDLE_B), contexts);
 		assertFalse(contexts.contains(bundleContext(BUNDLE_A)));
 	}
 
 	@Test
-	public void testFindConnectedRegionAllowed() throws BundleException, InvalidSyntaxException {
+	public void testEventConnectedRegionAllowed() throws BundleException, InvalidSyntaxException {
 		RegionFilter filter = createFilter(BUNDLE_B);
 		region(REGION_A).connectRegion(region(REGION_B), filter);
 
@@ -118,7 +118,7 @@
 	}
 
 	@Test
-	public void testFindConnectedRegionFiltering() throws BundleException, InvalidSyntaxException {
+	public void testEventConnectedRegionFiltering() throws BundleException, InvalidSyntaxException {
 		region(REGION_A).connectRegion(region(REGION_B), createFilter(BUNDLE_B));
 		Bundle x = createBundle(BUNDLE_X);
 		region(REGION_B).addBundle(x);
@@ -131,7 +131,7 @@
 	}
 
 	@Test
-	public void testFindTransitive() throws BundleException, InvalidSyntaxException {
+	public void testEventTransitive() throws BundleException, InvalidSyntaxException {
 		region(REGION_A).connectRegion(region(REGION_B), createFilter(BUNDLE_C));
 		region(REGION_B).connectRegion(region(REGION_C), createFilter(BUNDLE_C));
 		region(REGION_C).addBundle(bundle(BUNDLE_X));
@@ -147,11 +147,10 @@
 		assertFalse(contexts.contains(bundleContext(BUNDLE_B)));
 		assertTrue(contexts.contains(bundleContext(BUNDLE_X)));
 		assertFalse(contexts.contains(bundleContext(BUNDLE_A)));
-
 	}
 
 	@Test
-	public void testFindTransitiveDups() throws BundleException, InvalidSyntaxException {
+	public void testEventTransitiveDups() throws BundleException, InvalidSyntaxException {
 		region(REGION_A).connectRegion(region(REGION_B), createFilter(BUNDLE_C));
 		region(REGION_A).connectRegion(region(REGION_C), createFilter(DUPLICATE_FIlTER));
 		region(REGION_A).connectRegion(region(REGION_D), createFilter(DUPLICATE_FIlTER));
@@ -177,7 +176,7 @@
 	}
 
 	@Test
-	public void testFindInCyclicGraph() throws BundleException, InvalidSyntaxException {
+	public void testEventInCyclicGraph() throws BundleException, InvalidSyntaxException {
 		region(REGION_D).addBundle(bundle(BUNDLE_X));
 
 		region(REGION_A).connectRegion(region(REGION_B), createFilter(BUNDLE_D, BUNDLE_X));
@@ -220,7 +219,7 @@
 	}
 
 	@Test
-	public void testFindFromSystemBundle() {
+	public void testEventFromSystemBundle() {
 		Bundle systemBundle = new StubBundle(0L, "sys", BUNDLE_VERSION, "");
 		Collection<BundleContext> contexts = new ArrayList<BundleContext>(Arrays.asList(systemBundle.getBundleContext()));
 		this.serviceEventHook.event(serviceEvent(BUNDLE_A), contexts);
@@ -228,7 +227,7 @@
 	}
 
 	@Test
-	public void testFindFromBundleInNoRegion() {
+	public void testEventFromBundleInNoRegion() {
 		Bundle stranger = createBundle("stranger");
 		Collection<BundleContext> contexts = new ArrayList<BundleContext>(Arrays.asList(stranger.getBundleContext()));
 		this.serviceEventHook.event(serviceEvent(BUNDLE_A), contexts);
diff --git a/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/StandardRegionDigraph.java b/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/StandardRegionDigraph.java
index e592370..fedb941 100644
--- a/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/StandardRegionDigraph.java
+++ b/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/StandardRegionDigraph.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011, 2014 VMware Inc.
+ * Copyright (c) 2011, 2015 VMware Inc. 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
@@ -87,7 +87,7 @@
 		this.resolverHookFactory = new RegionResolverHookFactory(this);
 
 		this.bundleFindHook = new RegionBundleFindHook(this, bundleContext == null ? 0 : bundleContext.getBundle().getBundleId());
-		this.bundleEventHook = new RegionBundleEventHook(this, this.bundleFindHook, this.threadLocal);
+		this.bundleEventHook = new RegionBundleEventHook(this, this.threadLocal, bundleContext == null ? 0 : bundleContext.getBundle().getBundleId());
 		Object hook;
 		try {
 			hook = new RegionBundleCollisionHook(this, this.threadLocal);
diff --git a/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleEventHook.java b/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleEventHook.java
index 3edb511..8b27915 100644
--- a/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleEventHook.java
+++ b/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleEventHook.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011 VMware Inc.
+ * Copyright (c) 2011, 2015 VMware Inc. 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
@@ -16,7 +16,6 @@
 import org.eclipse.equinox.region.RegionDigraph;
 import org.osgi.framework.*;
 import org.osgi.framework.hooks.bundle.EventHook;
-import org.osgi.framework.hooks.bundle.FindHook;
 
 /**
  * {@link RegionBundleEventHook} manages the visibility of bundle events across regions according to the
@@ -33,14 +32,14 @@
 
 	private final RegionDigraph regionDigraph;
 
-	private final FindHook bundleFindHook;
-
 	private final ThreadLocal<Region> threadLocal;
 
-	public RegionBundleEventHook(RegionDigraph regionDigraph, FindHook bundleFindBook, ThreadLocal<Region> threadLocal) {
+	private final long hookImplID;
+
+	public RegionBundleEventHook(RegionDigraph regionDigraph, ThreadLocal<Region> threadLocal, long hookImplID) {
 		this.regionDigraph = regionDigraph;
-		this.bundleFindHook = bundleFindBook;
 		this.threadLocal = threadLocal;
+		this.hookImplID = hookImplID;
 	}
 
 	/**
@@ -52,10 +51,35 @@
 		if (event.getType() == BundleEvent.INSTALLED) {
 			bundleInstalled(eventBundle, event.getOrigin());
 		}
+		Map<Region, Boolean> regionAccess = new HashMap<Region, Boolean>();
 		Iterator<BundleContext> i = contexts.iterator();
 		while (i.hasNext()) {
-			if (!find(i.next(), eventBundle)) {
+			Bundle bundle = RegionBundleFindHook.getBundle(i.next());
+			if (bundle == null) {
+				// no bundle for context remove access from it
 				i.remove();
+				continue;
+			}
+
+			long bundleID = bundle.getBundleId();
+			if (bundleID == 0 || bundleID == hookImplID) {
+				// The system bundle and the hook impl bundle can see all bundles
+				continue;
+			}
+			Region region = regionDigraph.getRegion(bundle);
+			if (region == null) {
+				// no region for context remove access from it
+				i.remove();
+			} else {
+				Boolean accessible = regionAccess.get(region);
+				if (accessible == null) {
+					// we have not checked this region's access do it now
+					accessible = isAccessible(region, eventBundle);
+					regionAccess.put(region, accessible);
+				}
+				if (!accessible) {
+					i.remove();
+				}
 			}
 		}
 		if (event.getType() == BundleEvent.UNINSTALLED) {
@@ -63,10 +87,10 @@
 		}
 	}
 
-	private boolean find(BundleContext finderBundleContext, Bundle candidateBundle) {
+	private boolean isAccessible(Region region, Bundle candidateBundle) {
 		Collection<Bundle> candidates = new ArrayList<Bundle>(1);
 		candidates.add(candidateBundle);
-		this.bundleFindHook.find(finderBundleContext, candidates);
+		RegionBundleFindHook.find(region, candidates);
 		return !candidates.isEmpty();
 	}
 
diff --git a/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleFindHook.java b/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleFindHook.java
index 6c41f73..9cba364 100644
--- a/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleFindHook.java
+++ b/bundles/org.eclipse.equinox.region/src/org/eclipse/equinox/internal/region/hook/RegionBundleFindHook.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 VMware Inc.
+ * Copyright (c) 2013, 2015 VMware Inc. 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
@@ -53,6 +53,10 @@
 		}
 
 		Region finderRegion = this.regionDigraph.getRegion(finderBundle);
+		RegionBundleFindHook.find(finderRegion, bundles);
+	}
+
+	static void find(Region finderRegion, Collection<Bundle> bundles) {
 		if (finderRegion == null) {
 			bundles.clear();
 			return;
@@ -65,7 +69,7 @@
 		bundles.retainAll(allowed);
 	}
 
-	class Visitor extends RegionDigraphVisitorBase<Bundle> {
+	static class Visitor extends RegionDigraphVisitorBase<Bundle> {
 
 		Visitor(Collection<Bundle> candidates) {
 			super(candidates);