Revise TestExtensionRegistry and related classes

- Revised visibility of methods in TestExtensionRegistry.
- Renamed addExtension() to registerExtension() in TestExtensionRegistry.
- Renamed LocalExtensionRegistry to DelegatingExtensionRegistry,
  documented its purpose, and avoided duplicate instantiation.
- Removed superfluous use of generics in TestExtensionRegistry.
- Overhauled documentation TestExtensionRegistry.
- Removed extensionInstance in RegisteredExtensionPoint since it
  effectively duplicated extensionPoint.

Issue: #112

Author: sbrannen

junit-tests/src/test/java/org/junit/gen5/engine/junit5/execution/ExtensionPointSortingTests.java

@@ -10,7 +10,9 @@
 
 package org.junit.gen5.engine.junit5.execution;
 
-import static org.junit.gen5.api.Assertions.*;
+import static org.junit.gen5.api.Assertions.assertEquals;
+import static org.junit.gen5.api.Assertions.assertTrue;
+import static org.junit.gen5.api.Assertions.expectThrows;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -32,7 +34,6 @@ public class ExtensionPointSortingTests {
 
 	private ExtensionPointSorter sorter;
 	private List<RegisteredExtensionPoint<LocalExtensionPoint>> pointsToSort;
-	private int pointIndex = 0;
 
 	@BeforeEach
 	public void init() {
@@ -148,7 +149,7 @@ protected void assertSorting(RegisteredExtensionPoint... points) {
 
 	protected RegisteredExtensionPoint<LocalExtensionPoint> createExtensionPoint(Position position) {
 		return new RegisteredExtensionPoint<>(() -> {
-		}, position, "" + ++pointIndex);
+		}, position);
 	}
 
 	@FunctionalInterface

junit-tests/src/test/java/org/junit/gen5/engine/junit5/execution/TestExtensionRegistryTests.java

@@ -30,6 +30,9 @@
 import org.junit.gen5.engine.junit5.extension.DisabledCondition;
 import org.junit.gen5.engine.junit5.extension.TestInfoParameterResolver;
 
+/**
+ * @since 5.0
+ */
 public class TestExtensionRegistryTests {
 
 	private TestExtensionRegistry registry;
@@ -41,17 +44,17 @@ public void initRegistry() {
 
 	@Test
 	public void checkDefaultExtensions() {
-		assertEquals(2, TestExtensionRegistry.getDefaultExtensionClasses().size());
+		assertEquals(2, TestExtensionRegistry.getDefaultExtensionTypes().size());
 
 		assertDefaultExtensionType(DisabledCondition.class);
 		assertDefaultExtensionType(TestInfoParameterResolver.class);
 	}
 
 	@Test
 	public void newRegistryWithoutParentHasDefaultExtensions() throws Exception {
-		Set<Class<? extends TestExtension>> extensions = registry.getRegisteredExtensionClasses();
+		Set<Class<? extends TestExtension>> extensions = registry.getRegisteredExtensionTypes();
 
-		assertEquals(TestExtensionRegistry.getDefaultExtensionClasses().size(), extensions.size());
+		assertEquals(TestExtensionRegistry.getDefaultExtensionTypes().size(), extensions.size());
 		assertExtensionRegistered(registry, DisabledCondition.class);
 		assertExtensionRegistered(registry, TestInfoParameterResolver.class);
 
@@ -63,28 +66,28 @@ public void newRegistryWithoutParentHasDefaultExtensions() throws Exception {
 	@Test
 	public void registerExtensionByImplementingClass() throws Exception {
 
-		registry.addExtension(MyExtension.class);
+		registry.registerExtension(MyExtension.class);
 
 		assertExtensionRegistered(registry, MyExtension.class);
 
-		int rememberSize = registry.getRegisteredExtensionClasses().size();
-		registry.addExtension(MyExtension.class);
-		registry.addExtension(MyExtension.class);
-		registry.addExtension(MyExtension.class);
+		int rememberSize = registry.getRegisteredExtensionTypes().size();
+		registry.registerExtension(MyExtension.class);
+		registry.registerExtension(MyExtension.class);
+		registry.registerExtension(MyExtension.class);
 
-		assertEquals(rememberSize, registry.getRegisteredExtensionClasses().size());
+		assertEquals(rememberSize, registry.getRegisteredExtensionTypes().size());
 		assertExtensionRegistered(registry, MyExtension.class);
 		assertEquals(1, countExtensionPoints(MyExtensionPoint.class));
 
-		registry.addExtension(YourExtension.class);
+		registry.registerExtension(YourExtension.class);
 		assertExtensionRegistered(registry, YourExtension.class);
 		assertEquals(2, countExtensionPoints(MyExtensionPoint.class));
 	}
 
 	@Test
 	public void registerTestExtensionThatImplementsMultipleExtensionPoints() throws Exception {
 
-		registry.addExtension(MultipleExtension.class);
+		registry.registerExtension(MultipleExtension.class);
 
 		assertExtensionRegistered(registry, MultipleExtension.class);
 
@@ -96,10 +99,10 @@ public void registerTestExtensionThatImplementsMultipleExtensionPoints() throws
 	public void extensionsAreInheritedFromParent() throws Exception {
 
 		TestExtensionRegistry parent = new TestExtensionRegistry();
-		parent.addExtension(MyExtension.class);
+		parent.registerExtension(MyExtension.class);
 
 		registry = new TestExtensionRegistry(parent);
-		registry.addExtension(YourExtension.class);
+		registry.registerExtension(YourExtension.class);
 
 		assertExtensionRegistered(registry, MyExtension.class);
 		assertExtensionRegistered(registry, YourExtension.class);
@@ -114,7 +117,7 @@ public void extensionsAreInheritedFromParent() throws Exception {
 	@Test
 	public void registerExtensionPointsByExtensionRegistrar() throws Exception {
 
-		registry.addExtension(MyExtensionRegistrar.class);
+		registry.registerExtension(MyExtensionRegistrar.class);
 
 		assertExtensionRegistered(registry, MyExtensionRegistrar.class);
 		assertEquals(1, countExtensionPoints(MyExtensionPoint.class));
@@ -124,15 +127,15 @@ public void registerExtensionPointsByExtensionRegistrar() throws Exception {
 	@Test
 	public void canStreamOverRegisteredExceptionPoint() throws Exception {
 
-		registry.addExtension(MyExtension.class);
+		registry.registerExtension(MyExtension.class);
 
 		AtomicBoolean hasRun = new AtomicBoolean(false);
 
 		registry.stream(MyExtensionPoint.class, TestExtensionRegistry.ApplicationOrder.FORWARD).forEach(
 			registeredExtensionPoint -> {
-				assertEquals(MyExtension.class, registeredExtensionPoint.getExtensionInstance().getClass());
-				assertEquals(Position.DEFAULT, registeredExtensionPoint.getPosition());
 				assertTrue(registeredExtensionPoint.getExtensionPoint() instanceof MyExtensionPoint);
+				assertEquals(MyExtension.class.getName(), registeredExtensionPoint.getExtensionName());
+				assertEquals(Position.DEFAULT, registeredExtensionPoint.getPosition());
 				hasRun.set(true);
 			});
 
@@ -143,16 +146,17 @@ public void canStreamOverRegisteredExceptionPoint() throws Exception {
 	@Test
 	public void registerExtensionPointDirectly() throws Exception {
 
-		registry.registerExtension((MyExtensionPoint) test -> {
-		}, Position.INNERMOST, "anonymous extension");
+		registry.registerExtensionPoint((MyExtensionPoint) test -> {
+		}, Position.INNERMOST);
 
 		AtomicBoolean hasRun = new AtomicBoolean(false);
 
 		registry.stream(MyExtensionPoint.class, TestExtensionRegistry.ApplicationOrder.FORWARD).forEach(
 			registeredExtensionPoint -> {
-				assertEquals("anonymous extension", registeredExtensionPoint.getExtensionName());
-				assertEquals(Position.INNERMOST, registeredExtensionPoint.getPosition());
 				assertTrue(registeredExtensionPoint.getExtensionPoint() instanceof MyExtensionPoint);
+				assertTrue(registeredExtensionPoint.getExtensionName().startsWith(getClass().getName() + "$$Lambda$"));
+				assertTrue(registeredExtensionPoint.getExtensionName().contains("$Lambda$"));
+				assertEquals(Position.INNERMOST, registeredExtensionPoint.getPosition());
 				hasRun.set(true);
 			});
 
@@ -169,12 +173,12 @@ private int countExtensionPoints(Class<? extends ExtensionPoint> extensionPointT
 
 	private void assertExtensionRegistered(TestExtensionRegistry registry,
 			Class<? extends TestExtension> extensionClass) {
-		assertTrue(registry.getRegisteredExtensionClasses().contains(extensionClass),
+		assertTrue(registry.getRegisteredExtensionTypes().contains(extensionClass),
 			() -> extensionClass.getSimpleName() + " should be present");
 	}
 
 	private void assertDefaultExtensionType(Class<?> extensionType) {
-		assertTrue(TestExtensionRegistry.getDefaultExtensionClasses().contains(extensionType),
+		assertTrue(TestExtensionRegistry.getDefaultExtensionTypes().contains(extensionType),
 			() -> extensionType.getName() + " should be a default extension");
 	}
 

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/ClassTestDescriptor.java

@@ -212,8 +212,7 @@ private void registerAnnotatedMethodsAsExtensions(TestExtensionRegistry extensio
 		findAnnotatedMethods(testClass, annotationType, MethodSortOrder.HierarchyDown).stream()
 			.peek(method -> methodValidator.accept(extensionType, method))
 			.forEach(method ->
-				extensionRegistry.registerExtension(extensionPointSynthesizer.apply(extensionRegistry, method),
-					ExtensionPoint.Position.DEFAULT, method));
+				extensionRegistry.registerExtensionPoint(extensionPointSynthesizer.apply(extensionRegistry, method)));
 		// @formatter:on
 	}
 

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/execution/ExtensionPointSorter.java

@@ -19,8 +19,13 @@
 import org.junit.gen5.api.extension.ExtensionPoint.Position;
 
 /**
- * Class for sorting {@linkplain RegisteredExtensionPoint points} according to their {@linkplain Position}:
- * {@code OUTERMOST -> OUTSIDE_DEFAULT -> DEFAULT -> INSIDE_DEFAULT -> INNERMOST}
+ * Utility for sorting {@linkplain RegisteredExtensionPoint extension points}
+ * according to their {@linkplain Position}:
+ * {@link Position#OUTERMOST OUTERMOST} »
+ * {@link Position#OUTSIDE_DEFAULT OUTSIDE_DEFAULT} »
+ * {@link Position#DEFAULT DEFAULT} »
+ * {@link Position#INSIDE_DEFAULT INSIDE_DEFAULT} »
+ * {@link Position#INNERMOST INNERMOST}.
  *
  * @since 5.0
  */
@@ -29,13 +34,12 @@ public class ExtensionPointSorter {
 	/**
 	 * Sort the list of extension points according to their specified {@linkplain Position}.
 	 *
-	 * <p>The list instance will be resorted.
+	 * <p>Note: the supplied list instance will be resorted.
 	 *
-	 * @param registeredExtensionPoints List of extension points in order of registration
+	 * @param registeredExtensionPoints list of extension points in order of registration
 	 * @param <T> concrete subtype of {@link ExtensionPoint}
 	 */
 	public <T extends ExtensionPoint> void sort(List<RegisteredExtensionPoint<T>> registeredExtensionPoints) {
-
 		checkPositionUnique(registeredExtensionPoints, Position.INNERMOST);
 		checkPositionUnique(registeredExtensionPoints, Position.OUTERMOST);
 		registeredExtensionPoints.sort(new DefaultComparator());

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/execution/RegisteredExtensionPoint.java

@@ -18,45 +18,38 @@
  * Represents an {@linkplain ExtensionPoint extension} registered in a
  * {@link TestExtensionRegistry}.
  *
- * @param <T> the concrete subtype of {@link ExtensionPoint} to be registered
+ * @param <E> the type of registered {@link ExtensionPoint}
  * @since 5.0
  */
-public class RegisteredExtensionPoint<T extends ExtensionPoint> {
+public class RegisteredExtensionPoint<E extends ExtensionPoint> {
 
-	private final T extensionPoint;
+	private final E extensionPoint;
 
 	private final Position position;
 
-	private final Object extensionInstance;
-
-	public RegisteredExtensionPoint(T extensionPoint, Position position, Object extensionInstance) {
+	public RegisteredExtensionPoint(E extensionPoint, Position position) {
 		this.extensionPoint = extensionPoint;
 		this.position = position;
-		this.extensionInstance = extensionInstance;
 	}
 
-	public T getExtensionPoint() {
-		return extensionPoint;
+	public E getExtensionPoint() {
+		return this.extensionPoint;
 	}
 
 	public Position getPosition() {
-		return position;
-	}
-
-	public Object getExtensionInstance() {
-		return extensionInstance;
+		return this.position;
 	}
 
 	public String getExtensionName() {
-		return extensionInstance.toString();
+		return this.extensionPoint.getClass().getName();
 	}
 
 	@Override
 	public String toString() {
 		// @formatter:off
 		return new ToStringBuilder(this)
 				.append("position", this.position)
-				.append("extensionInstance", this.extensionInstance)
+				.append("extensionPoint", this.extensionPoint)
 				.toString();
 		// @formatter:on
 	}

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/execution/TestExtensionRegistry.java

@@ -29,11 +29,16 @@
 import org.junit.gen5.engine.junit5.extension.TestInfoParameterResolver;
 
 /**
- * A {@code TestExtensionRegistry registry} serves to hold all registered extensions (i.e. instances of
- * {@linkplain ExtensionPoint}) for a given {@linkplain org.junit.gen5.engine.Container} or
- * {@linkplain org.junit.gen5.engine.Leaf}. A registry has a reference to a parent registry and all lookups are done in
- * itself and in its parent and thereby all its ancestors. Do not confuse with {@linkplain ExtensionRegistry} which is
- * an interface used by {@linkplain ExtensionRegistrar}
+ * A {@code TestExtensionRegistry} holds all registered extensions (i.e.
+ * instances of {@link ExtensionPoint}) for a given
+ * {@link org.junit.gen5.engine.Container} or {@link org.junit.gen5.engine.Leaf}.
+ *
+ * <p>A registry has a reference to its parent registry, and all lookups are
+ * performed first in the current registry itself and then in its parent and
+ * thereby all its ancestors.
+ *
+ * <p>Do not confuse this engine-specific {@code TestExtensionRegistry} with
+ * the {@link ExtensionRegistry} which is used by an {@link ExtensionRegistrar}.
  *
  * @since 5.0
  */
@@ -44,88 +49,94 @@ public enum ApplicationOrder {
 	}
 
 	/**
-	 * Used to create and populate a new registry from a list of extensions and a parent.
+	 * Factory for creating and populating a new registry from a list of
+	 * extension types and a parent registry.
 	 *
-	 * @param parentRegistry The parent registry to be used.
-	 * @param extensionClasses The extensions to be registered in the new registry
-	 * @return a new TestExtensionRegistry
+	 * @param parentRegistry the parent registry to be used
+	 * @param extensionTypes the types of extensions to be registered in
+	 * the new registry
+	 * @return a new {@code TestExtensionRegistry}
 	 */
 	public static TestExtensionRegistry newRegistryFrom(TestExtensionRegistry parentRegistry,
-			List<Class<? extends TestExtension>> extensionClasses) {
+			List<Class<? extends TestExtension>> extensionTypes) {
+
 		TestExtensionRegistry newTestExtensionRegistry = new TestExtensionRegistry(parentRegistry);
-		extensionClasses.forEach(newTestExtensionRegistry::addExtension);
+		extensionTypes.forEach(newTestExtensionRegistry::registerExtension);
 		return newTestExtensionRegistry;
 	}
 
-	private static final List<Class<? extends TestExtension>> defaultExtensionClasses = Collections.unmodifiableList(
+	private static final List<Class<? extends TestExtension>> defaultExtensionTypes = Collections.unmodifiableList(
 		Arrays.asList(DisabledCondition.class, TestInfoParameterResolver.class));
 
 	/**
-	 * @return all extension classes that are added by default to all root registries
+	 * @return the list of all extension types that are added by default to all root registries
 	 */
-	public static List<Class<? extends TestExtension>> getDefaultExtensionClasses() {
-		return defaultExtensionClasses;
+	static List<Class<? extends TestExtension>> getDefaultExtensionTypes() {
+		return defaultExtensionTypes;
 	}
 
-	private final Set<Class<? extends TestExtension>> registeredExtensionClasses = new LinkedHashSet<>();
+	private final Set<Class<? extends TestExtension>> registeredExtensionTypes = new LinkedHashSet<>();
 
 	private final List<RegisteredExtensionPoint<?>> registeredExtensionPoints = new ArrayList<>();
 
+	private final ExtensionRegistry delegatingExtensionRegistry = new DelegatingExtensionRegistry();
+
 	private final Optional<TestExtensionRegistry> parent;
 
 	public TestExtensionRegistry() {
 		this(null);
 	}
 
-	public TestExtensionRegistry(TestExtensionRegistry parent) {
+	TestExtensionRegistry(TestExtensionRegistry parent) {
 		this.parent = Optional.ofNullable(parent);
 		if (!this.parent.isPresent()) {
 			addDefaultExtensions();
 		}
 	}
 
 	private void addDefaultExtensions() {
-		getDefaultExtensionClasses().stream().forEach(this::addExtension);
+		getDefaultExtensionTypes().stream().forEach(this::registerExtension);
 	}
 
 	/**
-	 * @return all extension classes registered in this registry or one of its ancestors
+	 * @return all extension types registered in this registry or one of its ancestors
 	 */
-	public Set<Class<? extends TestExtension>> getRegisteredExtensionClasses() {
-		Set<Class<? extends TestExtension>> allRegisteredExtensionClasses = new LinkedHashSet<>();
+	Set<Class<? extends TestExtension>> getRegisteredExtensionTypes() {
+		Set<Class<? extends TestExtension>> allRegisteredExtensionTypes = new LinkedHashSet<>();
 		this.parent.ifPresent(
-			parentRegistry -> allRegisteredExtensionClasses.addAll(parentRegistry.getRegisteredExtensionClasses()));
-		allRegisteredExtensionClasses.addAll(this.registeredExtensionClasses);
-		return Collections.unmodifiableSet(allRegisteredExtensionClasses);
+			parentRegistry -> allRegisteredExtensionTypes.addAll(parentRegistry.getRegisteredExtensionTypes()));
+		allRegisteredExtensionTypes.addAll(this.registeredExtensionTypes);
+		return Collections.unmodifiableSet(allRegisteredExtensionTypes);
 	}
 
 	@SuppressWarnings("unchecked")
-	private <T extends ExtensionPoint> List<RegisteredExtensionPoint<T>> getRegisteredExtensionPoints(
-			Class<T> extensionClass) {
+	private <E extends ExtensionPoint> List<RegisteredExtensionPoint<E>> getRegisteredExtensionPoints(
+			Class<E> extensionType) {
 
-		List<RegisteredExtensionPoint<T>> allExtensionPoints = new ArrayList<>();
+		List<RegisteredExtensionPoint<E>> allExtensionPoints = new ArrayList<>();
 		this.parent.ifPresent(
-			parentRegistry -> allExtensionPoints.addAll(parentRegistry.getRegisteredExtensionPoints(extensionClass)));
+			parentRegistry -> allExtensionPoints.addAll(parentRegistry.getRegisteredExtensionPoints(extensionType)));
 
-		//@formatter:off
-		registeredExtensionPoints.stream()
-				.filter(registeredExtensionPoint -> extensionClass.isAssignableFrom(registeredExtensionPoint.getExtensionPoint().getClass()))
-				.forEach(extensionPoint -> allExtensionPoints.add((RegisteredExtensionPoint<T>) extensionPoint));
-		//@formatter:on
+		// @formatter:off
+		this.registeredExtensionPoints.stream()
+				.filter(registeredExtensionPoint -> extensionType.isAssignableFrom(registeredExtensionPoint.getExtensionPoint().getClass()))
+				.forEach(extensionPoint -> allExtensionPoints.add((RegisteredExtensionPoint<E>) extensionPoint));
+		// @formatter:on
 
 		return allExtensionPoints;
 	}
 
 	/**
-	 * Return a stream for iterating all registered extension points.
+	 * Return a stream for iterating over all registered extension points
+	 * of the specified type.
 	 *
-	 * @param <T> The exact {@link ExtensionPoint} for which to find all extensions
-	 * @param extensionClass The {@link ExtensionPoint} class
-	 * @param order The order in which to apply the extension points after sorting. FORWARD or BACKWARD.
+	 * @param extensionType the type of {@link ExtensionPoint} to stream
+	 * @param order the order in which to apply the extension points after sorting
 	 */
-	public <T extends ExtensionPoint> Stream<RegisteredExtensionPoint<T>> stream(Class<T> extensionClass,
+	public <E extends ExtensionPoint> Stream<RegisteredExtensionPoint<E>> stream(Class<E> extensionType,
 			ApplicationOrder order) {
-		List<RegisteredExtensionPoint<T>> registeredExtensionPoints = getRegisteredExtensionPoints(extensionClass);
+
+		List<RegisteredExtensionPoint<E>> registeredExtensionPoints = getRegisteredExtensionPoints(extensionType);
 		new ExtensionPointSorter().sort(registeredExtensionPoints);
 		if (order == ApplicationOrder.BACKWARD) {
 			Collections.reverse(registeredExtensionPoints);
@@ -134,58 +145,64 @@ public <T extends ExtensionPoint> Stream<RegisteredExtensionPoint<T>> stream(Cla
 	}
 
 	/**
-	 * Register an extension class which can be either an {@linkplain ExtensionPoint} implementatio or an
-	 * {@linkplain ExtensionRegistrar}
+	 * Instantiate an extension of the given type using its default constructor,
+	 * and register the extension in this registry.
+	 *
+	 * <p>If an extension of the given type already exists in this registry,
+	 * a new extension will not be registered.
 	 *
-	 * @param extensionClass The test extension class to be registered
+	 * <p>The extension type can be either an {@link ExtensionPoint} or an
+	 * {@link ExtensionRegistrar}.
+	 *
+	 * @param extensionType the type extension to register
 	 */
-	public void addExtension(Class<? extends TestExtension> extensionClass) {
-		boolean extensionExists = getRegisteredExtensionClasses().stream().anyMatch(
-			registeredClass -> registeredClass.equals(extensionClass));
-		if (!extensionExists) {
-			TestExtension testExtension = ReflectionUtils.newInstance(extensionClass);
-			registerExtensionPointImplementors(testExtension);
-			registerFromExtensionRegistrar(testExtension);
-			this.registeredExtensionClasses.add(extensionClass);
-		}
-	}
+	void registerExtension(Class<? extends TestExtension> extensionType) {
 
-	private void registerFromExtensionRegistrar(TestExtension testExtension) {
-		if (testExtension instanceof ExtensionRegistrar) {
-			ExtensionRegistrar extensionRegistrar = (ExtensionRegistrar) testExtension;
-			ExtensionRegistry extensionRegistry = createExtensionRegistry(extensionRegistrar);
-			extensionRegistrar.registerExtensions(extensionRegistry);
-		}
-	}
+		boolean extensionAlreadyRegistered = getRegisteredExtensionTypes().stream().anyMatch(
+			registeredType -> registeredType.equals(extensionType));
 
-	private TestExtensionRegistry.LocalExtensionRegistry createExtensionRegistry(Object extensionInstance) {
-		return new TestExtensionRegistry.LocalExtensionRegistry(extensionInstance);
+		if (!extensionAlreadyRegistered) {
+			TestExtension testExtension = ReflectionUtils.newInstance(extensionType);
+			registerExtensionPoint(testExtension);
+			registerExtensionPointsFromRegistrar(testExtension);
+			this.registeredExtensionTypes.add(extensionType);
+		}
 	}
 
-	private void registerExtensionPointImplementors(TestExtension testExtension) {
+	private void registerExtensionPoint(TestExtension testExtension) {
+		// TODO Determine why TestExtensions are not supported.
 		if (testExtension instanceof ExtensionPoint) {
-			ExtensionPoint extension = (ExtensionPoint) testExtension;
-			registerExtension(extension, Position.DEFAULT, testExtension);
+			registerExtensionPoint((ExtensionPoint) testExtension);
 		}
 	}
 
-	public <E extends ExtensionPoint> void registerExtension(E extension, Position position, Object extensionInstance) {
-		RegisteredExtensionPoint<E> registeredExtensionPoint = new RegisteredExtensionPoint<>(extension, position,
-			extensionInstance);
-		registeredExtensionPoints.add(registeredExtensionPoint);
+	public void registerExtensionPoint(ExtensionPoint extension) {
+		registerExtensionPoint(extension, Position.DEFAULT);
 	}
 
-	private class LocalExtensionRegistry implements ExtensionRegistry {
-
-		private Object extensionInstance;
+	void registerExtensionPoint(ExtensionPoint extension, Position position) {
+		this.registeredExtensionPoints.add(new RegisteredExtensionPoint<>(extension, position));
+	}
 
-		private LocalExtensionRegistry(Object extensionInstance) {
-			this.extensionInstance = extensionInstance;
+	private void registerExtensionPointsFromRegistrar(TestExtension testExtension) {
+		if (testExtension instanceof ExtensionRegistrar) {
+			ExtensionRegistrar extensionRegistrar = (ExtensionRegistrar) testExtension;
+			extensionRegistrar.registerExtensions(this.delegatingExtensionRegistry);
 		}
+	}
+
+	/**
+	 * {@link ExtensionRegistry} which internally delegates to the enclosing
+	 * {@link TestExtensionRegistry}: used in order to allow an
+	 * {@link ExtensionRegistrar} to populate a {@link TestExtensionRegistry}
+	 * via the {@code ExtensionRegistry} API.
+	 */
+	private class DelegatingExtensionRegistry implements ExtensionRegistry {
 
 		@Override
 		public <E extends ExtensionPoint> void register(E extension, Class<E> extensionPointType, Position position) {
-			registerExtension(extension, position, extensionInstance);
+			registerExtensionPoint(extension, position);
 		}
 	}
+
 }