diff --git a/core/lib/Drupal/Component/Plugin/Derivative/DerivativeInterface.php b/core/lib/Drupal/Component/Plugin/Derivative/DerivativeInterface.php
new file mode 100644
index 0000000..bb07069
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Derivative/DerivativeInterface.php
@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Derivative\DerivativeInterface.
+ */
+
+namespace Drupal\Component\Plugin\Derivative;
+
+/**
+ * Plugin interface for derivative plugin handling.
+ */
+interface DerivativeInterface {
+
+  /**
+   * Returns the definition of a derivative plugin.
+   *
+   * @param string $derivative_id
+   *   The derivative id. The id must uniquely identify the derivative within a
+   *   given base plugin, but derivative ids can be reused across base plugins.
+   * @param array $base_plugin_definition
+   *   The definition array of the base plugin from which the derivative plugin
+   *   is derived.
+   *
+   * @return array
+   *   The full definition array of the derivative plugin, typically a merge of
+   *   $base_plugin_definition with extra derivative-specific information. NULL
+   *   if the derivative doesn't exist.
+   */
+  public function getDerivativeDefinition($derivative_id, array $base_plugin_definition);
+
+  /**
+   * Returns the definition of all derivatives of a base plugin.
+   *
+   * @param array $base_plugin_definition
+   *   The definition array of the base plugin.
+   * @return array
+   *   An array of full derivative definitions keyed on derivative id.
+   *
+   * @see getDerivativeDefinition()
+   */
+  public function getDerivativeDefinitions(array $base_plugin_definition);
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/Discovery/DerivativeDiscoveryDecorator.php b/core/lib/Drupal/Component/Plugin/Discovery/DerivativeDiscoveryDecorator.php
new file mode 100644
index 0000000..a7c8439
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Discovery/DerivativeDiscoveryDecorator.php
@@ -0,0 +1,157 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Discovery\DerivativeDiscoveryDecorator.
+ */
+
+namespace Drupal\Component\Plugin\Discovery;
+
+/**
+ * Base class providing the tools for a plugin discovery to be derivative aware.
+ *
+ * Provides a decorator that allows the use of plugin derivatives for normal
+ * implementations DiscoveryInterface.
+ */
+class DerivativeDiscoveryDecorator implements DiscoveryInterface {
+
+  protected $derivativeFetchers = array();
+  protected $decorated;
+
+  /**
+   * Creates a Drupal\Component\Plugin\Discovery\DerivativeDiscoveryDecorator
+   * object.
+   *
+   * @param DiscoveryInterface $discovery
+   *   The parent object implementing DiscoveryInterface that is being
+   *   decorated.
+   */
+  public function __construct(DiscoveryInterface $decorated) {
+    $this->decorated = $decorated;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\Discovery\DiscoveryInterface::getPluginDefinition().
+   */
+  public function getPluginDefinition($plugin_id) {
+
+    list($base_plugin_id, $derivative_id) = $this->decodePluginId($plugin_id);
+
+    $plugin_definition = $this->decorated->getPluginDefinition($base_plugin_id);
+    if (isset($plugin_definition)) {
+      $derivative_fetcher = $this->getDerivativeFetcher($base_plugin_id, $plugin_definition);
+      if ($derivative_fetcher) {
+        $plugin_definition = $derivative_fetcher->getDerivativeDefinition($derivative_id, $plugin_definition);
+      }
+    }
+
+    return $plugin_definition;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\Discovery\DiscoveryInterface::getPluginDefinitions().
+   */
+  public function getPluginDefinitions() {
+    $plugin_definitions = $this->decorated->getPluginDefinitions();
+    return $this->getDerivatives($plugin_definitions);
+  }
+
+  /**
+   * Adds derivatives to a list of plugin definitions.
+   *
+   * This should be called by the class extending this in
+   * DiscoveryInterface::getPluginDefinitions().
+   */
+  protected function getDerivatives(array $base_plugin_definitions) {
+    $plugin_definitions = array();
+    foreach ($base_plugin_definitions as $base_plugin_id => $plugin_definition) {
+      $derivative_fetcher = $this->getDerivativeFetcher($base_plugin_id, $plugin_definition);
+      if ($derivative_fetcher) {
+        $derivative_definitions = $derivative_fetcher->getDerivativeDefinitions($plugin_definition);
+        foreach ($derivative_definitions as $derivative_id => $derivative_definition) {
+          $plugin_id = $this->encodePluginId($base_plugin_id, $derivative_id);
+          $plugin_definitions[$plugin_id] = $derivative_definition;
+        }
+      }
+      else {
+        $plugin_definitions[$base_plugin_id] = $plugin_definition;
+      }
+    }
+
+    return $plugin_definitions;
+  }
+
+  /**
+   * Decodes derivative id and plugin id from a string.
+   *
+   * @param string $plugin_id
+   *   Plugin identifier that may point to a derivative plugin.
+   *
+   * @return array
+   *   An array with the base plugin id as the first index and the derivative id
+   *   as the second. If there is no derivative id it will be null.
+   */
+  protected function decodePluginId($plugin_id) {
+    // Try and split the passed plugin definition into a plugin and a
+    // derivative id. We don't need to check for !== FALSE because a leading
+    // colon would break the derivative system and doesn't makes sense.
+    if (strpos($plugin_id, ':')) {
+      return explode(':', $plugin_id, 2);
+    }
+
+    return array($plugin_id, NULL);
+  }
+
+  /**
+   * Encodes plugin and derivative id's into a string.
+   *
+   * @param string $base_plugin_id
+   *   The base plugin identifier.
+   * @param string $derivative_id
+   *   The derivative identifier.
+   *
+   * @return string
+   *   A uniquely encoded combination of the $base_plugin_id and $derivative_id.
+   */
+  protected function encodePluginId($base_plugin_id, $derivative_id) {
+    if ($derivative_id) {
+      return "$base_plugin_id:$derivative_id";
+    }
+
+    // By returning the unmerged plugin_id, we are able to support derivative
+    // plugins that support fetching the base definitions.
+    return $base_plugin_id;
+  }
+
+  /**
+   * Finds a Drupal\Component\Plugin\Discovery\DerivativeInterface.
+   *
+   * This Drupal\Component\Plugin\Discovery\DerivativeInterface can fetch
+   * derivatives for the plugin.
+   *
+   * @param string $base_plugin_id
+   *   The base plugin id of the plugin.
+   * @param array $base_definition
+   *   The base plugin definition to build derivatives.
+   *
+   * @return Drupal\Component\Plugin\Discovery\DerivativeInterface|null
+   *   A DerivativeInterface or null if none exists for the plugin.
+   */
+  protected function getDerivativeFetcher($base_plugin_id, array $base_definition) {
+    if (!isset($this->derivativeFetchers[$base_plugin_id])) {
+      $this->derivativeFetchers[$base_plugin_id] = FALSE;
+      if (isset($base_definition['derivative'])) {
+        $class = $base_definition['derivative'];
+        $this->derivativeFetchers[$base_plugin_id] = new $class($base_plugin_id);
+      }
+    }
+    return $this->derivativeFetchers[$base_plugin_id] ?: NULL;
+  }
+
+  /**
+   * Passes through all unknown calls onto the decorated object.
+   */
+  public function __call($method, $args) {
+    return call_user_func_array(array($this->decorated, $method), $args);
+  }
+}
diff --git a/core/lib/Drupal/Component/Plugin/Discovery/DiscoveryInterface.php b/core/lib/Drupal/Component/Plugin/Discovery/DiscoveryInterface.php
new file mode 100644
index 0000000..de4afdb
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Discovery/DiscoveryInterface.php
@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Discovery\DiscoveryInterface.
+ */
+
+namespace Drupal\Component\Plugin\Discovery;
+
+/**
+ * An interface defining the minimum requirements of building a plugin
+ * discovery component.
+ */
+interface DiscoveryInterface {
+
+  /**
+   * Gets a specific plugin definition.
+   *
+   * @param string $plugin_id
+   *   A plugin id.
+   *
+   * @return array
+   *   A plugin definition.
+   */
+  public function getPluginDefinition($plugin_id);
+
+  /**
+   * Gets the definition of all plugins for this type.
+   *
+   * @return array
+   *   An array of plugin definitions.
+   */
+  public function getPluginDefinitions();
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/Discovery/StaticDiscovery.php b/core/lib/Drupal/Component/Plugin/Discovery/StaticDiscovery.php
new file mode 100644
index 0000000..ebd4303
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Discovery/StaticDiscovery.php
@@ -0,0 +1,50 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Discovery\StaticDiscovery.
+ */
+
+namespace Drupal\Component\Plugin\Discovery;
+
+/**
+ * A discovery mechanism that allows plugin definitions to be manually
+ * registered rather than actively discovered.
+ */
+class StaticDiscovery implements DiscoveryInterface {
+
+  /**
+   * @todo
+   *
+   * @var Drupal\Component\Plugin\Discovery\DiscoveryInterface
+   */
+  protected $pluginDefinitions = array();
+
+  /**
+   * Implements DerivativeAwareDiscovery::getBasePluginDefinition().
+   */
+  public function getPluginDefinition($base_plugin_id) {
+    return isset($this->pluginDefinitions[$base_plugin_id]) ? $this->pluginDefinitions[$base_plugin_id] : NULL;
+  }
+
+  /**
+   * Implements DerivativeAwareDiscovery::getBasePluginDefinitions().
+   */
+  public function getPluginDefinitions() {
+    return $this->pluginDefinitions;
+  }
+
+  /**
+   * Sets a plugin definition.
+   */
+  public function setPluginDefinition($plugin, array $definition) {
+    $this->pluginDefinitions[$plugin] = $definition;
+  }
+
+  /**
+   * Deletes a plugin definition.
+   */
+  public function deletePluginDefinition($plugin) {
+    unset($this->pluginDefinitions[$plugin]);
+  }
+}
diff --git a/core/lib/Drupal/Component/Plugin/Exception/ExceptionInterface.php b/core/lib/Drupal/Component/Plugin/Exception/ExceptionInterface.php
new file mode 100644
index 0000000..57fb25b
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Exception/ExceptionInterface.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Exception\ExceptionInterface.
+ */
+
+namespace Drupal\Component\Plugin\Exception;
+
+/**
+ * Exception interface for all exceptions thrown by the Plugin component.
+ */
+interface ExceptionInterface { }
diff --git a/core/lib/Drupal/Component/Plugin/Exception/InvalidDecoratedMethod.php b/core/lib/Drupal/Component/Plugin/Exception/InvalidDecoratedMethod.php
new file mode 100644
index 0000000..a3ef8e6
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Exception/InvalidDecoratedMethod.php
@@ -0,0 +1,17 @@
+<?php
+/**
+* @file
+* Definition of Drupal\Core\Plugin\Exception\InvalidDecoratedMethod.
+*/
+
+namespace Drupal\Component\Plugin\Exception;
+
+use Drupal\Component\Plugin\Exception\ExceptionInterface;
+use \BadMethodCallException;
+
+/**
+ * Exception thrown when a decorator's _call() method is triggered, but the
+ * decorated object does not contain the requested method.
+ *
+ */
+class InvalidDecoratedMethod extends BadMethodCallException implements ExceptionInterface { }
diff --git a/core/lib/Drupal/Component/Plugin/Exception/MapperExceptionInterface.php b/core/lib/Drupal/Component/Plugin/Exception/MapperExceptionInterface.php
new file mode 100644
index 0000000..222b547
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Exception/MapperExceptionInterface.php
@@ -0,0 +1,13 @@
+<?php
+/**
+ * @file
+ * Base exception interface for grouping mapper exceptions.
+ */
+
+namespace Drupal\Component\Plugin\Exception;
+
+/**
+ * Extended interface for exceptions thrown specifically by the Mapper subsystem
+ * within the Plugin component.
+ */
+interface MapperExceptionInterface extends ExceptionInterface { }
diff --git a/core/lib/Drupal/Component/Plugin/Exception/PluginException.php b/core/lib/Drupal/Component/Plugin/Exception/PluginException.php
new file mode 100644
index 0000000..f83bdad
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Exception/PluginException.php
@@ -0,0 +1,15 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Exception\PluginException.
+ */
+
+namespace Drupal\Component\Plugin\Exception;
+
+use Exception;
+
+/**
+ * Generic Plugin exception class to be thrown when no more specific class
+ * is applicable.
+ */
+class PluginException extends Exception implements ExceptionInterface { }
diff --git a/core/lib/Drupal/Component/Plugin/Factory/DefaultFactory.php b/core/lib/Drupal/Component/Plugin/Factory/DefaultFactory.php
new file mode 100644
index 0000000..0e1dd91
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Factory/DefaultFactory.php
@@ -0,0 +1,80 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Factory\DefaultFactory.
+ */
+
+namespace Drupal\Component\Plugin\Factory;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+use Drupal\Component\Plugin\Exception\PluginException;
+use Drupal\Component\Plugin\Derivative\DerivativeInterface;
+
+/**
+ * Default plugin factory.
+ *
+ * Instantiates plugin instances by passing the full configuration array as a
+ * single constructor argument. Plugin types wanting to support plugin classes
+ * with more flexible constructor signatures can do so by using an alternate
+ * factory such as Drupal\Component\Plugin\Factory\ReflectionFactory.
+ */
+class DefaultFactory implements FactoryInterface {
+
+  /**
+   * @todo
+   *
+   * @var Drupal\Component\Plugin\Discovery\DiscoveryInterface
+   */
+  protected $discovery;
+
+  /**
+   * @todo
+   *
+   * @var string
+   */
+  protected $classKey;
+
+  /**
+   * Constructs a Drupal\Component\Plugin\Factory\DefaultFactory object.
+   */
+  public function __construct(DiscoveryInterface $discovery, $class_key = 'class') {
+    $this->discovery = $discovery;
+    $this->classKey = $class_key;
+  }
+
+  /**
+   * Implements FactoryInterface::createPluginInstance().
+   */
+  public function createPluginInstance($plugin_id, array $configuration) {
+    $plugin_class = $this->getPluginClass($plugin_id);
+    return new $plugin_class($configuration);
+  }
+
+  /**
+   * Finds the class relevant for a given plugin.
+   *
+   *  @param array $plugin_id
+   *    The id of a plugin.
+   *
+   *  @return string
+   *    The appropriate class name.
+   */
+  protected function getPluginClass($plugin_id) {
+    if (empty($this->classKey)) {
+      throw new PluginException("The plugin type did not specify a valid key for determining the plugin instance class.");
+    }
+
+    $plugin_definition = $this->discovery->getPluginDefinition($plugin_id);
+    if (empty($plugin_definition[$this->classKey])) {
+      throw new PluginException("The plugin did not specify an instance class.");
+    }
+
+    $class = $plugin_definition[$this->classKey];
+
+    if (!class_exists($class)) {
+      throw new PluginException(t("Plugin instance class @class does not exist.", array('@class' => $class)));
+    }
+
+    return $class;
+  }
+}
diff --git a/core/lib/Drupal/Component/Plugin/Factory/FactoryInterface.php b/core/lib/Drupal/Component/Plugin/Factory/FactoryInterface.php
new file mode 100644
index 0000000..3a15583
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Factory/FactoryInterface.php
@@ -0,0 +1,29 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Factory\FactoryInterface.
+ */
+
+namespace Drupal\Component\Plugin\Factory;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+
+/**
+ * Factory interface implemented by all plugin factories.
+ */
+interface FactoryInterface {
+
+  /**
+   * Returns a preconfigured instance of a plugin.
+   *
+   * @param string $plugin_id
+   *   The id of the plugin being instantiated.
+   * @param array $configuration
+   *   An array of configuration relevant to the plugin instance.
+   *
+   * @return object
+   *   A fully configured plugin instance.
+   */
+  public function createPluginInstance($plugin_id, array $configuration);
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/Factory/ReflectionFactory.php b/core/lib/Drupal/Component/Plugin/Factory/ReflectionFactory.php
new file mode 100644
index 0000000..2ccd10d
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Factory/ReflectionFactory.php
@@ -0,0 +1,85 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Factory\ReflectionFactory.
+ */
+
+namespace Drupal\Component\Plugin\Factory;
+
+use ReflectionClass;
+
+/**
+ * A plugin factory that maps instance configuration to constructor arguments.
+ *
+ * Provides logic for any basic plugin type that needs to provide individual
+ * plugins based upon some basic logic.
+ */
+class ReflectionFactory extends DefaultFactory {
+
+  /**
+   * Implements FactoryInterface::createPluginInstance().
+   */
+  public function createPluginInstance($plugin_id, array $configuration) {
+    $plugin_class = $this->getPluginClass($plugin_id);
+
+    // Lets figure out of there's a constructor for this class and pull
+    // arguments from the $options array if so to populate it.
+    $reflector = new ReflectionClass($plugin_class);
+    if ($reflector->hasMethod('__construct')) {
+      $arguments = $this->getPluginInstanceArguments($reflector, $plugin_id, $configuration);
+      $instance = $reflector->newInstanceArgs($arguments);
+    }
+    else {
+      $instance = new $plugin_class();
+    }
+
+    return $instance;
+  }
+
+  /**
+   * Inspects the plugin class and build a list of arguments for the constructor.
+   *
+   * This is provided as a helper method so factories extending this class can
+   * replace this and insert their own reflection logic.
+   *
+   * @param ReflectionClass $reflector
+   *   The reflector object being used to inspect the plugin class.
+   * @param string $plugin_id
+   *   The identifier of the plugin implementation.
+   * @param array $configuration
+   *   An array of configuration that may be passed to the instance.
+   *
+   * @return array
+   *   An array of arguments to be passed to the constructor.
+   */
+  protected function getPluginInstanceArguments(ReflectionClass $reflector, $plugin_id, array $configuration) {
+
+    $arguments = array();
+    foreach ($reflector->getMethod('__construct')->getParameters() as $param) {
+      $param_name = $param->getName();
+      $param_class = $param->getClass();
+
+      if ($param_name == 'plugin_id') {
+        $arguments[] = $plugin_id;
+      }
+      elseif ($param_name == 'configuration') {
+        $arguments[] = $configuration;
+      }
+      elseif ($param_class && $param_class->isInstance($this->discovery)) {
+        $arguments[] = $this->discovery;
+      }
+      elseif (isset($configuration[$param_name]) || array_key_exists($param_name, $configuration)) {
+        $arguments[] = $configuration[$param_name];
+      }
+      elseif ($param->isDefaultValueAvailable()) {
+        $arguments[] = $param->getDefaultValue();
+      }
+      else {
+        // Missing constructor argument.
+        // TODO - Do we throw an exception or just skip and let sub classes
+        // extend this.
+      }
+    }
+    return $arguments;
+  }
+}
diff --git a/core/lib/Drupal/Component/Plugin/Mapper/DefaultMapper.php b/core/lib/Drupal/Component/Plugin/Mapper/DefaultMapper.php
new file mode 100644
index 0000000..ada30ec
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Mapper/DefaultMapper.php
@@ -0,0 +1,92 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Mapper\DefaultMapper.
+ */
+
+namespace Drupal\Component\Plugin\Mapper;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+use Drupal\Component\Plugin\Factory\FactoryInterface;
+
+/**
+ * @todo
+ */
+class DefaultMapper implements MapperInterface {
+
+  /**
+   * A class which implements DiscoveryInterface.
+   *
+   * @var Drupal\Component\Plugin\Discovery\DiscoveryInterface
+   */
+  protected $discovery;
+
+  /**
+   * A class which implements FactoryInterface
+   *
+   * @var Drupal\Component\Plugin\Factory\FactoryInterface
+   */
+  protected $factory;
+
+  /**
+   * @todo
+   *
+   * @var string
+   */
+  protected $pluginIdKey;
+
+  /**
+   * @todo
+   *
+   * @var string
+   */
+  protected $defaultPluginId;
+
+  /**
+   * @todo
+   *
+   * @var array
+   */
+  protected $instances = array();
+
+  /**
+   * Implements MapperInterface::_construct().
+   */
+  public function __construct(DiscoveryInterface $discovery, FactoryInterface $factory, $options = array()) {
+    $this->discovery = $discovery;
+    $this->factory = $factory;
+    $this->pluginIdKey = isset($options['id_key']) ? $options['id_key'] : 'plugin';
+    $this->defaultPluginId = isset($options['default']) ? $options['default'] : 'default';
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\Mapper\MapperInterface::getPluginInstance().
+   *
+   * This implements a simple mapper that does the following:
+   * - Maps a single $options key to the desired plugin id.
+   * - If that plugin doesn't exist, uses a default one.
+   * - Forwards all of $options to the plugin instance configuration.
+   */
+  public function getPluginInstance(array $options) {
+    $instance_id = $this->getInstanceId($options);
+    if (!isset($this->instances[$instance_id])) {
+      $plugin_id = ($this->discovery->getPluginDefinition($options[$this->pluginIdKey]) !== NULL) ? $options[$this->pluginIdKey] : $this->defaultPluginId;
+      $configuration = $options;
+      $this->instances[$instance_id] = $this->factory->createPluginInstance($plugin_id, $configuration);
+    }
+    return $this->instances[$instance_id];
+  }
+
+  /**
+   * Returns an identifier for a given set of plugin options in order to reuse instances.
+   *
+   * @param array $options
+   *   @todo
+   *
+   * @return
+   *   @todo
+   */
+  protected function getInstanceId(array $options) {
+    return serialize($options);
+  }
+}
diff --git a/core/lib/Drupal/Component/Plugin/Mapper/MapperInterface.php b/core/lib/Drupal/Component/Plugin/Mapper/MapperInterface.php
new file mode 100644
index 0000000..ab20693
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/Mapper/MapperInterface.php
@@ -0,0 +1,33 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\Mapper\MapperInterface.
+ */
+
+namespace Drupal\Component\Plugin\Mapper;
+
+/**
+ * Plugin mapper interface.
+ *
+ * Plugin mappers are responsible for mapping a plugin request to its
+ * implementation. For example, it might map a cache bin to a memcache bin.
+ *
+ * Mapper objects incorporate the best practices of retrieving configurations,
+ * type information, and factory instantiation.
+ */
+interface MapperInterface {
+
+  /**
+   * Returns a preconfigured instance of a plugin.
+   *
+   * @param array $options
+   *   An array of options that can be used to determine a suitable plugin to
+   *   instantiate and how to configure it.
+   *
+   * @return object
+   *   A fully configured plugin instance. The interface of the plugin instance
+   *   will depends on the plugin type.
+   */
+  public function getPluginInstance(array $options);
+
+}
diff --git a/core/lib/Drupal/Component/Plugin/PluginAbstract.php b/core/lib/Drupal/Component/Plugin/PluginAbstract.php
new file mode 100644
index 0000000..bad42a1
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/PluginAbstract.php
@@ -0,0 +1,70 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\PluginAbstract
+ */
+
+namespace Drupal\Component\Plugin;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+
+/*
+ * Class for shortcuting the basic implementation of the plugin interface.
+ */
+abstract class PluginAbstract implements PluginInspectionInterface {
+
+  /**
+   * The discovery object.
+   *
+   * @var Drupal\Component\Plugin\Discovery\DiscoveryInterface
+   */
+  protected $discovery;
+
+  /**
+   * The plugin_id.
+   *
+   * @var string
+   */
+  protected $plugin_id;
+
+  /**
+   * Configuration information passed into the plugin.
+   *
+   * @var array
+   */
+  protected $configuration;
+
+  /**
+   * Constructs a Drupal\Component\Plugin\PluginAbstract object.
+   *
+   * @param string $plugin_id
+   *   The plugin_id for the plugin instance.
+   * @param DiscoveryInterface $discovery
+   *   The Discovery class that holds access to the plugin implementation
+   *   definition.
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   */
+  public function __construct($plugin_id, DiscoveryInterface $discovery, array $configuration = array()) {
+    $this->plugin_id = $plugin_id;
+    $this->discovery = $discovery;
+    $this->configuration = $configuration;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\PluginInspectionInterface::getPluginId().
+   */
+  public function getPluginId() {
+    return $this->plugin_id;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\PluginInspectionInterface::getPluginDefinition().
+   */
+  public function getpluginDefinition() {
+    return $this->discovery->getPluginDefinition($this->plugin_id);
+  }
+
+  // Note: Plugin configuration is optional so its left to the plugin type to
+  // require a getter as part of its interface.
+}
diff --git a/core/lib/Drupal/Component/Plugin/PluginInspectionInterface.php b/core/lib/Drupal/Component/Plugin/PluginInspectionInterface.php
new file mode 100644
index 0000000..e49898d
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/PluginInspectionInterface.php
@@ -0,0 +1,33 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\PluginInspectionInterface.
+ */
+
+namespace Drupal\Component\Plugin;
+
+/**
+ * Plugin interface for providing some metadata inspection.
+ *
+ * This interface provides some simple tools for code recieving a plugin to
+ * interact with the plugin system.
+ */
+interface PluginInspectionInterface {
+
+  /**
+   * Returns the plugin_id of the plugin instance.
+   *
+   * @return string
+   *   The plugin_id of the plugin instance.
+   */
+  public function getPluginId();
+
+  /**
+   * Returns the definition of the plugin implementation.
+   *
+   * @return array
+   *   The plugin definition, as returned by the discovery object used by the
+   *   plugin type.
+   */
+  public function getPluginDefinition();
+}
diff --git a/core/lib/Drupal/Component/Plugin/PluginType.php b/core/lib/Drupal/Component/Plugin/PluginType.php
new file mode 100644
index 0000000..7fae9b2
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/PluginType.php
@@ -0,0 +1,95 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\PluginType
+ */
+
+namespace Drupal\Component\Plugin;
+
+/**
+ * An abstract class for defining new plugin types and the various additional
+ * classes used for a given plugin type definition.
+ */
+abstract class PluginType implements PluginTypeInterface {
+
+  /**
+   * A class which implements DiscoveryInterface that is appropriate for
+   * discovering plugins of this type.
+   *
+   * @var Drupal\Component\Plugin\Discovery\DiscoveryInterface
+   */
+  protected $discovery;
+
+  /**
+   * A class which implements FactoryInterface that is responsible for properly
+   * instantiating classes of this plugin type.
+   *
+   * @var Drupal\Component\Plugin\Factory\FactoryInterface
+   */
+  protected $factory;
+
+  /**
+   * @todo
+   *
+   * @var Drupal\Component\Plugin\Mapper\MapperInterface
+   */
+  protected $mapper;
+
+  /**
+   * A set of defaults to be referenced by $this->processPluginDefinition() if
+   * additional processing of plugins is necessary or helpful for development
+   * purposes.
+   *
+   * @var array
+   */
+  protected $defaults = array();
+
+  /**
+   * Implements Drupal\Component\Plugin\PluginTypeInterface::getPluginDefinition().
+   */
+  public function getPluginDefinition($plugin_id) {
+    $definition = $this->discovery->getPluginDefinition($plugin_id);
+    if (isset($definition)) {
+      $this->processPluginDefinition($definition, $plugin_id);
+    }
+    return $definition;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\PluginTypeInterface::getPluginDefinitions().
+   */
+  public function getPluginDefinitions() {
+    $definitions = $this->discovery->getPluginDefinitions();
+    foreach ($definitions as $plugin_id => &$definition) {
+      $this->processPluginDefinition($definition, $plugin_id);
+    }
+
+    return $definitions;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\PluginTypeInterface::createPluginInstance().
+   */
+  public function createPluginInstance($plugin_id, array $configuration = array()) {
+    return $this->factory->createPluginInstance($plugin_id, $configuration);
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\PluginTypeInterface::getPluginInstance().
+   */
+  public function getPluginInstance(array $options) {
+    return $this->mapper->getPluginInstance($options);
+  }
+
+  /**
+   * Performs extra processing on plugin definitions.
+   *
+   * By default we add defaults for the type to the definition. If a type has
+   * additional processing logic they can do that by replacing or extending the
+   * method.
+   */
+  protected function processPluginDefinition(&$definition, $plugin_id) {
+    $definition += $this->defaults;
+  }
+}
diff --git a/core/lib/Drupal/Component/Plugin/PluginTypeInterface.php b/core/lib/Drupal/Component/Plugin/PluginTypeInterface.php
new file mode 100644
index 0000000..7487a66
--- /dev/null
+++ b/core/lib/Drupal/Component/Plugin/PluginTypeInterface.php
@@ -0,0 +1,24 @@
+<?php
+/**
+ * @file
+ * Definition of Drupal\Component\Plugin\PluginTypeInterface
+ */
+
+namespace Drupal\Component\Plugin;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+use Drupal\Component\Plugin\Factory\FactoryInterface;
+use Drupal\Component\Plugin\Mapper\MapperInterface;
+
+/**
+ * Interface implemented by plugin type implementations.
+ *
+ * There are no explicit methods on the type interface. Instead the type is
+ * expected to broker the interactions of the the different plugin components.
+ * In implementation this means the type extends the specific interfaces from
+ * each component. It is however unlikely the plugin type itself would
+ * implement this logic but rather proxy the requests as appropriate and
+ * providing type specific business and implementation logic.
+ */
+interface PluginTypeInterface extends DiscoveryInterface, FactoryInterface, MapperInterface {
+}
diff --git a/core/lib/Drupal/Core/Plugin/Discovery/CacheDecorator.php b/core/lib/Drupal/Core/Plugin/Discovery/CacheDecorator.php
new file mode 100644
index 0000000..209ccf0
--- /dev/null
+++ b/core/lib/Drupal/Core/Plugin/Discovery/CacheDecorator.php
@@ -0,0 +1,124 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Core\Plugin\Discovery\CacheDecorator.
+ */
+
+namespace Drupal\Core\Plugin\Discovery;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+
+/**
+ * Enables static and persistent caching of discovered plugin definitions.
+ */
+class CacheDecorator implements DiscoveryInterface {
+
+  /**
+   * The cache key used to store the definition list.
+   *
+   * @var string
+   */
+  protected $cacheKey;
+
+  /**
+   * The cache bin used to store the definition list.
+   *
+   * @var string
+   */
+  protected $cacheBin;
+
+  /**
+   * The plugin definitions of the decorated discovery class.
+   *
+   * @var array
+   */
+  protected $definitions;
+
+  /**
+   * The Discovery object being decorated.
+   *
+   * @var Drupal\Component\Plugin\Discovery\DiscoveryInterface
+   */
+  protected $decorated;
+
+  /**
+   * Constructs a Drupal\Core\Plugin\Discovery\CacheDecorator object.
+   *
+   * It uses the DiscoveryInterface object it should decorate.
+   *
+   * @param Drupal\Component\Plugin\Discovery\DiscoveryInterface $decorated
+   *   The object implementing DiscoveryInterface that is being decorated.
+   * @param string $cache_key
+   *   The cache identifier used for storage of the definition list.
+   * @param string $cache_bin
+   *   The cache bin used for storage and retrieval of the definition list.
+   */
+  public function __construct(DiscoveryInterface $decorated, $cache_key, $cache_bin = 'default') {
+    $this->decorated = $decorated;
+    $this->cacheKey = $cache_key;
+    $this->cacheBin = $cache_bin;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\Discovery\DicoveryInterface::getPluginDefinition().
+   */
+  public function getPluginDefinition($plugin_id) {
+    $definitions = $this->getCachedDefinitions();
+    if (isset($definitions)) {
+      $definition = isset($definitions[$plugin_id]) ? $definitions[$plugin_id] : NULL;
+    }
+    else {
+      $definition = $this->decorated->getPluginDefinition($plugin_id);
+    }
+    return $definition;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\Discovery\DicoveryInterface::getPluginDefinitions().
+   */
+  public function getPluginDefinitions() {
+    $definitions = $this->getCachedDefinitions();
+    if (!isset($definitions)) {
+      $definitions = $this->decorated->getPluginDefinitions();
+      $this->setCachedDefinitions($definitions);
+    }
+    return $definitions;
+  }
+
+  /**
+   * Returns the cached plugin definitions of the decorated discovery class.
+   *
+   * @return mixed
+   *   On success this will return an array of plugin definitions. On failure
+   *   this should return NULL, indicating to other methods that this has not
+   *   yet been defined. Success with no values should return as an empty array
+   *   and would actually be returned by the getPluginDefinitions() method.
+   */
+  protected function getCachedDefinitions() {
+    if (!isset($this->definitions) && isset($this->cacheKey) && $cache = cache($this->cacheBin)->get($this->cacheKey)) {
+      $this->definitions = $cache->data;
+    }
+    return $this->definitions;
+  }
+
+  /**
+   * Sets a cache of plugin definitions for the decorated discovery class.
+   *
+   * @param array $definitions
+   *   List of definitions to store in cache.
+   */
+  protected function setCachedDefinitions($definitions) {
+    if (isset($this->cacheKey)) {
+      cache($this->cacheBin)->set($this->cacheKey, $definitions);
+    }
+    $this->definitions = $definitions;
+  }
+
+  /**
+   * Passes through all unknown calls onto the decorated object.
+   */
+  public function __call($method, $args) {
+    return call_user_func_array(array($this->decorated, $method), $args);
+  }
+}
diff --git a/core/lib/Drupal/Core/Plugin/Discovery/HookDiscovery.php b/core/lib/Drupal/Core/Plugin/Discovery/HookDiscovery.php
new file mode 100644
index 0000000..6aba72c
--- /dev/null
+++ b/core/lib/Drupal/Core/Plugin/Discovery/HookDiscovery.php
@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Core\Plugin\Discovery\HookDiscovery.
+ */
+
+namespace Drupal\Core\Plugin\Discovery;
+
+use Drupal\Component\Plugin\Discovery\DiscoveryInterface;
+
+/**
+ * Provides a hook-based plugin discovery class.
+ */
+class HookDiscovery implements DiscoveryInterface {
+
+  /**
+   * The name of the hook that will be implemented by this discovery instance.
+   *
+   * @var string
+   */
+  protected $hook;
+
+  /**
+   * Constructs a Drupal\Core\Plugin\Discovery\HookDiscovery object.
+   *
+   * @param string $hook
+   *   The Drupal hook that a module can implement in order to interface to
+   *   this discovery class.
+   */
+  function __construct($hook) {
+    $this->hook = $hook;
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\Discovery\DicoveryInterface::getPluginDefinition().
+   */
+  public function getPluginDefinition($plugin_id) {
+    $plugins = $this->getPluginDefinitions();
+    return isset($plugins[$plugin_id]) ? $plugins[$plugin_id] : array();
+  }
+
+  /**
+   * Implements Drupal\Component\Plugin\Discovery\DicoveryInterface::getPluginDefinitions().
+   */
+  public function getPluginDefinitions() {
+    foreach (module_implements($this->hook) as $module) {
+      $function = $module . '_' . $this->hook;
+      foreach ($function() as $plugin_id => $definition) {
+        $definition['module'] = $module;
+        $definitions[$plugin_id] = $definition;
+      }
+    }
+    drupal_alter($this->hook, $definitions);
+    return $definitions;
+  }
+}
diff --git a/core/modules/simpletest/simpletest.info b/core/modules/simpletest/simpletest.info
index 46f00c3..6e18c42 100644
--- a/core/modules/simpletest/simpletest.info
+++ b/core/modules/simpletest/simpletest.info
@@ -4,3 +4,4 @@ package = Core
 version = VERSION
 core = 8.x
 configure = admin/config/development/testing/settings
+
diff --git a/core/modules/system/lib/Drupal/system/Tests/Plugin/DerivativePluginTest.php b/core/modules/system/lib/Drupal/system/Tests/Plugin/DerivativePluginTest.php
new file mode 100644
index 0000000..0c15368
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Plugin/DerivativePluginTest.php
@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\system\Tests\Plugin\PluginTest
+ */
+
+namespace Drupal\system\Tests\Plugin;
+
+use Drupal\plugin_test\Plugin\Type\MockBlockPluginType;
+
+/**
+ * Tests the plugin system.
+ */
+class DerivativePluginTest extends PluginTestBase {
+  protected $testPluginType;
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Derivative Discovery',
+      'description' => 'Tests the the plugin system derivative integration.',
+      'group' => 'Plugin API',
+    );
+  }
+
+  public function setUp() {
+    parent::setUp();
+
+    // Real modules implementing plugin types may expose a module-specific API
+    // for retrieving its plugin type objects, or make them available in
+    // Drupal's dependency injection container, but for unit testing, we get
+    // the object directly.
+    $this->testPluginType = new MockBlockPluginType();
+  }
+
+  /**
+   * Tests getPluginDefinitions() and getPluginDefinition() with a derivativeDecorator.
+   */
+  function testDerivativeDecorator() {
+
+    // @see MockBlockPluginType::_construct().
+    $expected = array(
+      'user_login' => array(
+        'label' => 'User login',
+        'class' => 'Drupal\plugin_test\Plugin\MockUserLoginBlock',
+      ),
+      'menu:main_menu' => array(
+        'label' => 'Main menu',
+        'class' => 'Drupal\plugin_test\Plugin\MockMenuBlock',
+      ),
+      'menu:navigation' => array(
+        'label' => 'Navigation',
+        'class' => 'Drupal\plugin_test\Plugin\MockMenuBlock',
+      ),
+      'layout' => array(
+        'label' => 'Layout',
+        'class' => 'Drupal\plugin_test\Plugin\MockLayoutBlock',
+      ),
+      'layout:foo' => array(
+        'label' => 'Layout Foo',
+        'class' => 'Drupal\plugin_test\Plugin\MockLayoutBlock',
+      ),
+    );
+
+    // Ensure that getPluginDefinitions() returns the expected definitions.
+    $this->assertIdentical($this->testPluginType->getPluginDefinitions(), $expected);
+
+    // Ensure that getPluginDefinition() returns the expected definition.
+    foreach ($expected as $id => $definition) {
+      $this->assertIdentical($this->testPluginType->getPluginDefinition($id), $definition);
+    }
+
+    // Ensure that NULL is returned as the definition of a non-existing base
+    // plugin, a non-existing derivative plugin, or a base plugin that may not
+    // be used without deriving.
+    $this->assertIdentical($this->testPluginType->getPluginDefinition('non_existing'), NULL, 'NULL returned as the definition of a non-existing base plugin.');
+    $this->assertIdentical($this->testPluginType->getPluginDefinition('menu:non_existing'), NULL, 'NULL returned as the definition of a non-existing derivative plugin.');
+    $this->assertIdentical($this->testPluginType->getPluginDefinition('menu'), NULL, 'NULL returned as the definition of a base plugin that may not be used without deriving.');
+  }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Plugin/DiscoveryPluginTest.php b/core/modules/system/lib/Drupal/system/Tests/Plugin/DiscoveryPluginTest.php
new file mode 100644
index 0000000..967946c
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Plugin/DiscoveryPluginTest.php
@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\system\Tests\Plugin\PluginTest
+ */
+
+namespace Drupal\system\Tests\Plugin;
+
+use Drupal\plugin_test\Plugin\Type\TestPluginType;
+
+/**
+ * Tests the plugin system.
+ */
+class DiscoveryPluginTest extends PluginTestBase {
+  protected $testPluginType;
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Discovery API',
+      'description' => 'Tests the the plugin system API.',
+      'group' => 'Plugin API',
+    );
+  }
+
+  public function setUp() {
+    parent::setUp();
+
+    // Real modules implementing plugin types may expose a module-specific API
+    // for retrieving its plugin type objects, or make them available in
+    // Drupal's dependency injection container, but for unit testing, we get
+    // the object directly.
+
+    // A very basic mock plugin type.
+    $this->testPluginType = new TestPluginType();
+  }
+
+  /**
+   * Tests getPluginDefinitions() and getPluginDefinition().
+   */
+  function testDiscoveryInterface() {
+
+    // @see TestPluginType::_construct().
+    $expected = array(
+      'user_login' => array(
+        'label' => 'User login',
+        'class' => 'Drupal\plugin_test\Plugin\MockUserLoginBlock',
+      ),
+    );
+
+    // Ensure that getPluginDefinitions() returns the expected definitions.
+    $this->assertIdentical($this->testPluginType->getPluginDefinitions(), $expected);
+
+    // Ensure that getPluginDefinition() returns the expected definition.
+    foreach ($expected as $id => $definition) {
+      $this->assertIdentical($this->testPluginType->getPluginDefinition($id), $definition);
+    }
+
+    // Ensure that NULL is returned as the definition of a non-existing plugin.
+    $this->assertIdentical($this->testPluginType->getPluginDefinition('non_existing'), NULL, 'NULL returned as the definition of a non-existing base plugin.');
+  }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Plugin/FactoryPluginTest.php b/core/modules/system/lib/Drupal/system/Tests/Plugin/FactoryPluginTest.php
new file mode 100644
index 0000000..21f366b
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Plugin/FactoryPluginTest.php
@@ -0,0 +1,105 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\system\Tests\Plugin\PluginTest
+ */
+
+namespace Drupal\system\Tests\Plugin;
+
+use Drupal\plugin_test\Plugin\Type\TestPluginType;
+use Drupal\plugin_test\Plugin\Type\MockBlockPluginType;
+use Drupal\Component\Plugin\Exception\ExceptionInterface;
+use Exception;
+
+/**
+ * Tests the plugin system.
+ */
+class FactoryPluginTest extends PluginTestBase {
+  protected $testPluginType;
+  protected $mockBlockPluginType;
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Factory Tests',
+      'description' => 'Test the base plugin factories.',
+      'group' => 'Plugin API',
+    );
+  }
+
+  public function setUp() {
+    parent::setUp();
+
+    // Real modules implementing plugin types may expose a module-specific API
+    // for retrieving its plugin type objects, or make them available in
+    // Drupal's dependency injection container, but for unit testing, we get
+    // the object directly.
+
+    // A very basic mock plugin type.
+    $this->testPluginType = new TestPluginType();
+    // A slightly more advanced plugin type mocking a block system with
+    // derivatives.
+    $this->mockBlockPluginType = new MockBlockPluginType();
+  }
+
+  /**
+   * Test that DefaultFactory can create a plugin instance.
+   */
+  function testDefaultFactory() {
+    // Ensure a non-derivative plugin can be instantiated.
+    $plugin = $this->testPluginType->createPluginInstance('user_login', array('title' => 'Please enter your login name and password'));
+    $this->assertIdentical(get_class($plugin), 'Drupal\plugin_test\Plugin\MockUserLoginBlock', 'Correct plugin class instantiated with default factory.');
+    $this->assertIdentical($plugin->getTitle(), 'Please enter your login name and password', 'Plugin instance correctly configured.');
+
+    // Ensure that attempting to instantiate non-existing plugins throws a
+    // PluginException.
+    try {
+      $this->testPluginType->createPluginInstance('non_existing');
+      $this->fail('Drupal\Component\Plugin\Exception\ExceptionInterface expected');
+    }
+    catch (ExceptionInterface $e) {
+      $this->pass('Drupal\Component\Plugin\Exception\ExceptionInterface expected and caught.');
+    }
+    catch (Exception $e) {
+      $this->fail('Drupal\Component\Plugin\Exception\ExceptionInterface expected, but ' . get_class($e) . ' was thrown.');
+    }
+  }
+
+  /**
+   * Test that the Reflection factory can create a plugin instance.
+   *
+   * The mock plugin classes use different values for their constructors
+   * allowing us to test the reflection capabilities as well.
+   *
+   * We use derivative classes here because the block test type has the
+   * reflection factory and it provides some additional variety in plugin
+   * object creation.
+   */
+  function testReflectionFactory() {
+    // Ensure a non-derivative plugin can be instantiated.
+    $plugin = $this->mockBlockPluginType->createPluginInstance('user_login', array('title' => 'Please enter your login name and password'));
+    $this->assertIdentical(get_class($plugin), 'Drupal\plugin_test\Plugin\MockUserLoginBlock', 'Correct plugin class instantiated.');
+    $this->assertIdentical($plugin->getTitle(), 'Please enter your login name and password', 'Plugin instance correctly configured.');
+
+    // Ensure a derivative plugin can be instantiated.
+    $plugin = $this->mockBlockPluginType->createPluginInstance('menu:main_menu', array('depth' => 2));
+    $this->assertIdentical($plugin->getContent(), '<ul><li>1<ul><li>1.1</li></ul></li></ul>', 'Derived plugin instance correctly instantiated and configured.');
+
+    // Ensure that attempting to instantiate non-existing plugins throws a
+    // PluginException. Test this for a non-existing base plugin, a non-existing
+    // derivative plugin, and a base plugin that may not be used without
+    // deriving.
+    foreach (array('non_existing', 'menu:non_existing', 'menu') as $invalid_id) {
+      try {
+        $this->mockBlockPluginType->createPluginInstance($invalid_id);
+        $this->fail('Drupal\Component\Plugin\Exception\ExceptionInterface expected');
+      }
+      catch (ExceptionInterface $e) {
+        $this->pass('Drupal\Component\Plugin\Exception\ExceptionInterface expected and caught.');
+      }
+      catch (Exception $e) {
+        $this->fail('An unexpected Exception of type "' . get_class($e) . '" was thrown with message ' . $e->getMessage());
+      }
+    }
+  }
+}
diff --git a/core/modules/system/lib/Drupal/system/Tests/Plugin/PluginTestBase.php b/core/modules/system/lib/Drupal/system/Tests/Plugin/PluginTestBase.php
new file mode 100644
index 0000000..3071471
--- /dev/null
+++ b/core/modules/system/lib/Drupal/system/Tests/Plugin/PluginTestBase.php
@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\system\Tests\Plugin\PluginTestBase
+ */
+
+namespace Drupal\system\Tests\Plugin;
+
+use Symfony\Component\ClassLoader\UniversalClassLoader;
+use Drupal\simpletest\UnitTestBase;
+
+/**
+ * @todo
+ */
+abstract class PluginTestBase extends UnitTestBase {
+  protected $loader;
+
+  public function setUp() {
+    parent::setUp();
+    // We're a unit test using classes... don't let the db registry blow up.
+    spl_autoload_unregister('drupal_autoload_class');
+    spl_autoload_unregister('drupal_autoload_interface');
+  }
+
+  public function tearDown() {
+    // Re-register autoloaders before tearDown begins.
+    spl_autoload_register('drupal_autoload_interface');
+    spl_autoload_register('drupal_autoload_class');
+
+    parent::tearDown();
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockLayoutBlock.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockLayoutBlock.php
new file mode 100644
index 0000000..01a1bed
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockLayoutBlock.php
@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\plugin_test\Plugin\MockLayoutBlock.
+ */
+
+namespace Drupal\plugin_test\Plugin;
+
+use Drupal\Component\Plugin\PluginAbstract;
+
+/**
+ * Mock implementation of a layout block plugin used by Plugin API unit tests.
+ *
+ * No implementation here as there are no tests for this yet.
+ *
+ * @see Drupal\plugin_test\Plugin\Type\TestPluginType
+ * @see Drupal\plugin_test\Plugin\MockUserLoginBlock
+ * @see Drupal\plugin_test\Plugin\MockMenuBlock
+ */
+class MockLayoutBlock extends PluginAbstract {
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockLayoutBlockDeriver.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockLayoutBlockDeriver.php
new file mode 100644
index 0000000..38db626
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockLayoutBlockDeriver.php
@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\plugin_test\Plugin\MockLayoutBlockDeriver.
+ */
+
+namespace Drupal\plugin_test\Plugin;
+
+use Drupal\Component\Plugin\Derivative\DerivativeInterface;
+
+/**
+ * Mock implementation of DerivativeInterface for the mock layout block plugin.
+ *
+ * @see Drupal\plugin_test\Plugin\Type\TestPluginType
+ */
+class MockLayoutBlockDeriver implements DerivativeInterface {
+
+  /**
+   * Implements DerivativeInterface::getDerivativeDefinition().
+   */
+  public function getDerivativeDefinition($derivative_id, array $base_plugin_definition) {
+    $derivatives = $this->getDerivativeDefinitions($base_plugin_definition);
+    if (isset($derivatives[$derivative_id])) {
+      return $derivatives[$derivative_id];
+    }
+  }
+
+  /**
+   * Implements DerivativeInterface::getDerivativeDefinitions().
+   */
+  public function getDerivativeDefinitions(array $base_plugin_definition) {
+    // This isn't strictly necessary, but it helps reduce clutter in
+    // DerivativePluginTest::testDerivativeDecorator()'s $expected variable.
+    // Since derivative definitions don't need further deriving, we remove this
+    // key from the returned definitions.
+    unset($base_plugin_definition['derivative']);
+
+    $derivatives = array(
+      // Adding a NULL key signifies that the base plugin may also be used in
+      // addition to the derivatives. In this case, we allow the administrator
+      // to add a generic layout block to the page.
+      NULL => $base_plugin_definition,
+
+      // We also allow them to add a customized one. Here, we just mock the
+      // customized one, but in a real implementation, this would be fetched
+      // from some config() object.
+      'foo' => array(
+        'label' => 'Layout Foo',
+      ) + $base_plugin_definition,
+    );
+
+    return $derivatives;
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockMenuBlock.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockMenuBlock.php
new file mode 100644
index 0000000..b414006
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockMenuBlock.php
@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\plugin_test\Plugin\MockMenuBlock.
+ */
+
+namespace Drupal\plugin_test\Plugin;
+
+use Drupal\Component\Plugin\PluginAbstract;
+
+/**
+ * Mock implementation of a menu block plugin used by Plugin API unit tests.
+ *
+ * @see Drupal\plugin_test\Plugin\Type\TestPluginType
+ */
+class MockMenuBlock extends PluginAbstract {
+
+  /**
+   * The title to display when rendering this block instance.
+   *
+   * @var string
+   */
+  protected $title;
+
+  /**
+   * The number of menu levels deep to render.
+   *
+   * @var integer
+   */
+  protected $depth;
+
+  public function __construct($title = '', $depth = 0) {
+    $this->title = $title;
+    $this->depth = $depth;
+  }
+
+  /**
+   * Returns the content to display.
+   */
+  public function getContent() {
+    // Since this is a mock object, we just return some HTML of the desired
+    // nesting level. For depth=2, this returns:
+    // '<ul><li>1<ul><li>1.1</li></ul></li></ul>'.
+    $content = '';
+    for ($i=0; $i < $this->depth; $i++) {
+      $content .= '<ul><li>' . implode('.', array_fill(0, $i+1, '1'));
+    }
+    for ($i=0; $i < $this->depth; $i++) {
+      $content .= '</li></ul>';
+    }
+    return $content;
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockMenuBlockDeriver.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockMenuBlockDeriver.php
new file mode 100644
index 0000000..b2f44c8
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockMenuBlockDeriver.php
@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\plugin_test\Plugin\MockMenuBlockDeriver.
+ */
+
+namespace Drupal\plugin_test\Plugin;
+
+use Drupal\Component\Plugin\Derivative\DerivativeInterface;
+
+/**
+ * Mock implementation of DerivativeInterface for the mock menu block plugin.
+ *
+ * @see Drupal\plugin_test\Plugin\Type\TestPluginType
+ */
+class MockMenuBlockDeriver implements DerivativeInterface {
+
+  /**
+   * Implements DerivativeInterface::getDerivativeDefinition().
+   */
+  public function getDerivativeDefinition($derivative_id, array $base_plugin_definition) {
+    $derivatives = $this->getDerivativeDefinitions($base_plugin_definition);
+    if (isset($derivatives[$derivative_id])) {
+      return $derivatives[$derivative_id];
+    }
+  }
+
+  /**
+   * Implements DerivativeInterface::getDerivativeDefinitions().
+   */
+  public function getDerivativeDefinitions(array $base_plugin_definition) {
+    // This isn't strictly necessary, but it helps reduce clutter in
+    // DerivativePluginTest::testDerivativeDecorator()'s $expected variable.
+    // Since derivative definitions don't need further deriving, we remove this
+    // key from the returned definitions.
+    unset($base_plugin_definition['derivative']);
+
+    // Here, we create some mock menu block definitions for menus that might
+    // exist in a typical Drupal site. In a real implementation, we would query
+    // Drupal's configuration to find out which menus actually exist.
+    $derivatives = array(
+      'main_menu' => array(
+        'label' => 'Main menu',
+      ) + $base_plugin_definition,
+      'navigation' => array(
+        'label' => 'Navigation',
+      ) + $base_plugin_definition,
+    );
+
+    return $derivatives;
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockUserLoginBlock.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockUserLoginBlock.php
new file mode 100644
index 0000000..b61ba2a
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/MockUserLoginBlock.php
@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\plugin_test\Plugin\MockUserLoginBlock.
+ */
+
+namespace Drupal\plugin_test\Plugin;
+
+use Drupal\Component\Plugin\PluginAbstract;
+
+/**
+ * Mock implementation of a login block plugin used by Plugin API unit tests.
+ *
+ * @see Drupal\plugin_test\Plugin\Type\TestPluginType
+ */
+class MockUserLoginBlock extends PluginAbstract {
+
+  /**
+   * The title to display when rendering this block instance.
+   *
+   * @var string
+   */
+  protected $title;
+
+  public function __construct($configuration) {
+    $this->title = $configuration['title'];
+  }
+
+  public function getTitle() {
+    return $this->title;
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/Type/MockBlockPluginType.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/Type/MockBlockPluginType.php
new file mode 100644
index 0000000..351f85c
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/Type/MockBlockPluginType.php
@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\plugin_test\Plugin\Type\MockBlockPluginType.
+ */
+
+namespace Drupal\plugin_test\Plugin\Type;
+
+use Drupal\Component\Plugin\PluginType;
+use Drupal\Component\Plugin\Discovery\StaticDiscovery;
+use Drupal\Component\Plugin\Discovery\DerivativeDiscoveryDecorator;
+use Drupal\Component\Plugin\Factory\ReflectionFactory;
+
+/**
+ * Defines a mock block plugin type used by Plugin API derivative unit tests.
+ */
+class MockBlockPluginType extends PluginType {
+  public function __construct() {
+
+    // Create the object that can be used to return definitions for all the
+    // plugins available for this type. Most real plugin types use a richer
+    // discovery implementation, but StaticDiscovery lets us add some simple
+    // mock plugins for unit testing.
+    $this->discovery = new StaticDiscovery();
+
+    // Derivative plugins are plugins that are derived from a base plugin
+    // definition and some site configuration (examples below). To allow for
+    // such plugins, we add the DerivativeDiscoveryDecorator to our discovery
+    // object.
+    $this->discovery = new DerivativeDiscoveryDecorator($this->discovery);
+
+    // The plugin definitions that follow are based on work that is in progress
+    // for the Drupal 8 Blocks and Layouts initiative
+    // (http://groups.drupal.org/node/213563). As stated above, we set
+    // definitions here, because this is for unit testing. Real plugin types use
+    // a discovery implementation that allows for any module to add new plugins
+    // to the system.
+
+    // A simple plugin: the user login block.
+    $this->discovery->setPluginDefinition('user_login', array(
+      'label' => 'User login',
+      'class' => 'Drupal\plugin_test\Plugin\MockUserLoginBlock',
+    ));
+
+    // A plugin that requires derivatives: the menu block plugin. We do not want
+    // a generic "Menu" block showing up in the Block administration UI.
+    // Instead, we want a block for each menu, but the number of menus in the
+    // system and each one's title is user configurable. The
+    // MockMenuBlockDeriver class ensures that only derivatives, and not the
+    // base plugin, are available to the system.
+    $this->discovery->setPluginDefinition('menu', array(
+      'class' => 'Drupal\plugin_test\Plugin\MockMenuBlock',
+      'derivative' => 'Drupal\plugin_test\Plugin\MockMenuBlockDeriver',
+    ));
+
+    // A block plugin that can optionally be derived: the layout block plugin.
+    // A layout is a special kind of block into which other blocks can be
+    // placed. We want both a generic "Layout" block available in the Block
+    // administration UI as well as additional user-created custom layouts. The
+    // MockLayoutBlockDeriver class ensures that both the base plugin and the
+    // derivatives are available to the system.
+    $this->discovery->setPluginDefinition('layout', array(
+      'label' => 'Layout',
+      'class' => 'Drupal\plugin_test\Plugin\MockLayoutBlock',
+      'derivative' => 'Drupal\plugin_test\Plugin\MockLayoutBlockDeriver',
+    ));
+
+    // In addition to finding all of the plugins available for a type, a plugin
+    // type must also be able to create instances of that plugin. For example, a
+    // specific instance of a "Main menu" menu block, configured to show just
+    // the top-level of links. To handle plugin instantiation, plugin types can
+    // use one of the factory classes included with the plugin system, or create
+    // their own. ReflectionFactory is a general purpose, flexible factory
+    // suitable for many kinds of plugin types. Factories need access to the
+    // plugin definitions (e.g., since that's where the plugin's class is
+    // specified), so we provide it the discovery object.
+    $this->factory = new ReflectionFactory($this->discovery);
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/Type/TestPluginType.php b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/Type/TestPluginType.php
new file mode 100644
index 0000000..d877e45
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/lib/Drupal/plugin_test/Plugin/Type/TestPluginType.php
@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * @file
+ * Definition of Drupal\plugin_test\Plugin\Type\TestPluginType.
+ */
+
+namespace Drupal\plugin_test\Plugin\Type;
+
+use Drupal\Component\Plugin\PluginType;
+use Drupal\Component\Plugin\Discovery\StaticDiscovery;
+use Drupal\Component\Plugin\Discovery\DerivativeDiscoveryDecorator;
+use Drupal\Component\Plugin\Factory\DefaultFactory;
+
+/**
+ * Defines a basic mock plugin type used by Plugin API unit tests.
+ */
+class TestPluginType extends PluginType {
+  public function __construct() {
+
+    // Create the object that can be used to return definitions for all the
+    // plugins available for this type. Most real plugin types use a richer
+    // discovery implementation, but StaticDiscovery lets us add some simple
+    // mock plugins for unit testing.
+    $this->discovery = new StaticDiscovery();
+
+    // A simple plugin: a mock user login block.
+    $this->discovery->setPluginDefinition('user_login', array(
+      'label' => 'User login',
+      'class' => 'Drupal\plugin_test\Plugin\MockUserLoginBlock',
+    ));
+
+    // In addition to finding all of the plugins available for a type, a plugin
+    // type must also be able to create instances of that plugin. For example, a
+    // specific instance of a "User login" block, configured with a custom
+    // title. To handle plugin instantiation, plugin types can use one of the
+    // factory classes included with the plugin system, or create their own.
+    // DefaultFactory is a simple, general purpose factory suitable for
+    // many kinds of plugin types. Factories need access to the plugin
+    // definitions (e.g., since that's where the plugin's class is specified),
+    // so we provide it the discovery object.
+    $this->factory = new DefaultFactory($this->discovery);
+  }
+}
diff --git a/core/modules/system/tests/modules/plugin_test/plugin_test.info b/core/modules/system/tests/modules/plugin_test/plugin_test.info
new file mode 100644
index 0000000..406e02f
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/plugin_test.info
@@ -0,0 +1,6 @@
+name = "Plugin Test Support"
+description = "Test that plugins can provide plugins and provide namespace discovery for plugin test implementations."
+package = Testing
+version = VERSION
+core = 8.x
+hidden = TRUE
diff --git a/core/modules/system/tests/modules/plugin_test/plugin_test.module b/core/modules/system/tests/modules/plugin_test/plugin_test.module
new file mode 100644
index 0000000..dc6986d
--- /dev/null
+++ b/core/modules/system/tests/modules/plugin_test/plugin_test.module
@@ -0,0 +1,6 @@
+<?php
+
+/**
+ * @file
+ * Helper module for the plugin tests.
+ */