diff --git a/.htaccess b/.htaccess
index af418c4..bf725f2 100644
--- a/.htaccess
+++ b/.htaccess
@@ -28,13 +28,15 @@ DirectoryIndex index.php index.html index.htm
 AddType image/svg+xml svg svgz
 AddEncoding gzip svgz
 
-# Override PHP settings that cannot be changed at runtime. See
+# Most of the following PHP settings cannot be changed at runtime. See
 # sites/default/default.settings.php and
 # Drupal\Core\DrupalKernel::bootEnvironment() for settings that can be
-# changed at runtime.
+# changed at runtime. See sites/example.settings.local.php for more
+# information on assert.active.
 
 # PHP 5, Apache 1 and 2.
 <IfModule mod_php5.c>
+  php_value assert.active                   0
   php_flag session.auto_start               off
   php_value mbstring.http_input             pass
   php_value mbstring.http_output            pass
diff --git a/core/core.api.php b/core/core.api.php
index 63fd607..5410b89 100644
--- a/core/core.api.php
+++ b/core/core.api.php
@@ -57,6 +57,7 @@
  * - @link queue Queue API @endlink
  * - @link typed_data Typed Data @endlink
  * - @link testing Automated tests @endlink
+ * - @link php_assert PHP Runtime Assert Statements @endlink
  * - @link third_party Integrating third-party applications @endlink
  *
  * @section more_info Further information
@@ -983,6 +984,54 @@
  */
 
 /**
+ * @defgroup php_assert PHP Runtime Assert Statements
+ * @{
+ * Use of the assert() statement in Drupal.
+ *
+ * Unit tests also use the term "assertion" to refer to test conditions, so to
+ * avoid confusion the term "runtime assertion" will be used for the assert()
+ * statement throughout the documentation.
+ *
+ * A runtime assertion is a statement that is expected to always be true at
+ * the point in the code it appears at. They are tested using PHP's internal
+ * @link http://www.php.net/assert assert() @endlink statement. If an
+ * assertion is ever FALSE it indicates an error in the code or in module or
+ * theme configuration files. User-provided configuration files should be
+ * verified with standard control structures at all times, not just checked in
+ * development environments with assert() statements on.
+ *
+ * The Drupal project primarly uses runtime assertions to enforce the
+ * expectations of the API by failing when incorrect calls are made by code
+ * under development. While PHP type hinting does this for objects and arrays,
+ * runtime assertions do this for scalars (strings, integers, floats, etc.) and
+ * complex data structures such as cache and render arrays. They are used to
+ * insure that methods return values in the documented datatypes. They also
+ * verify that objects have been properly configured and set up by the service
+ * container. Runtime assertions are checked throughout development. They
+ * supplement unit tests by checking scenarios that do not have unit tests
+ * written for them, and by testing the API calls made by all the code in the
+ * system.
+ *
+ * When using assert() keep the following in mind:
+ * - Runtime assertions are disabled by default in production and enabled in
+ *   development, so they can't be used as control structures. Use exceptions
+ *   for errors that can occur in production no matter how unlikely they are.
+ *   See sites/example.settings.local.php for more information.
+ * - Assert() has functioned in a buggy manner that has been fixed in PHP 7. If
+ *   you do not use a string for the first argument of the statement but
+ *   instead use a function call or expression then that code will be
+ *   evaluated even when runtime assertions are turned off. To avoid this you
+ *   must use a string as the first argument, and assert will pass this string
+ *   to the eval() statement.
+ * - Since runtime assertion strings are parsed by eval() use caution when
+ *   using them to work with data that may be unsanitized.
+ *
+ * See https://www.drupal.org/node/2492225 for more information on runtime
+ * assertions.
+ * @}
+ */
+
+/**
  * @defgroup info_types Information types
  * @{
  * Types of information in Drupal.
diff --git a/core/includes/testing.inc b/core/includes/testing.inc
new file mode 100644
index 0000000..5163182
--- /dev/null
+++ b/core/includes/testing.inc
@@ -0,0 +1,39 @@
+<?php
+/**
+ * @file
+ * Operations necessary to insure a common testing environment.
+ */
+
+/**
+ * Assertions
+ *
+ * The Drupal project primarly uses runtime assertions to enforce the
+ * expectations of the API by failing when incorrect calls are made by code
+ * under development.
+ *
+ * @see http://php.net/assert
+ * @see https://www.drupal.org/node/2492225
+ *
+ * If you are using PHP 7.0 it is strongly recommended that you set
+ * zend.assertions=1 in the PHP.ini file (It cannot be changed from .htaccess
+ * or runtime) on development machines and to 0 in production.
+ *
+ * @see https://wiki.php.net/rfc/expectations
+ *
+ */
+
+// PHP 7, just make sure runtime assertions are on.
+if (version_compare(PHP_VERSION, '7.0.0') >= 0) {
+  ini_set('assert.exception', 1);
+}
+// PHP 5.x, make runtime assertions throw as they would in PHP 7.
+else {
+  class AssertionException extends Exception {}
+  assert_options(ASSERT_ACTIVE, 1);
+  assert_options(ASSERT_CALLBACK, function($file, $line, $code, $message = ''){
+    if (empty($message)) {
+      $message = "Assertion Failure in {$file} at {$line}. Failed asserting {$code}";
+    }
+    throw new AssertionException($message);
+  });
+}
diff --git a/core/lib/Drupal/Component/Assertion/Assertion.php b/core/lib/Drupal/Component/Assertion/Assertion.php
new file mode 100644
index 0000000..85984b6
--- /dev/null
+++ b/core/lib/Drupal/Component/Assertion/Assertion.php
@@ -0,0 +1,411 @@
+<?php
+/**
+ * @file
+ * Contains \Drupal\Component\Assertion\Assertion.
+ */
+
+namespace Drupal\Component\Assertion;
+
+use Traversable;
+
+/**
+ * Collection of methods to assist the assert() statement.
+ *
+ * This is a static function collection for performing complicated runtime
+ * assertions.  All functions in this collection return the truth value of the
+ * assertion that is being made.  Most take a single argument to be examined.
+ *
+ * Example call:
+ * @code
+ *   assert('Drupal\\Component\\Assertion\\Assertion::assertAllStrings($array)');
+ * @endcode
+ *
+ * @ingroup php_assert
+ */
+class Assertion {
+
+  /**
+   * Asserts argument can be traversed with foreach.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed with foreach.
+   */
+  public static function assertTraversable($traversable) {
+    return is_array($traversable) || $traversable instanceof Traversable;
+  }
+
+  /**
+   * Asserts callback returns TRUE for each member of a traversable.
+   *
+   * This is less memory intensive than using array_filter() to build a second
+   * array and then comparing the arrays. Many of the other functions in this
+   * collection alias this function passing a specific callback to make the
+   * code more readable.
+   *
+   * @see http://php.net/manual/language.types.callable.php
+   *
+   * @param callable $callable
+   *   Callback function
+   * @param mixed $traversable
+   *   Variable to be examined.
+   * @return bool
+   *   TRUE if $traversable can be traversed and $callable returns TRUE on
+   *   all members.
+   */
+  public static function assertAllMembersAre($callable, $traversable) {
+    if (static::assertTraversable($traversable)) {
+      foreach ($traversable as $member) {
+        if (!$callable($member)) {
+          return FALSE;
+        }
+      }
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Asserts that all members are strings.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are strings.
+   */
+  public static function assertAllStrings($traversable) {
+    return static::assertAllMembersAre('is_string', $traversable);
+  }
+
+  /**
+   * Asserts all members are strings or objects with magic __toString() method.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are strings.
+   */
+  public static function assertAllStringable($traversable) {
+    if (static::assertTraversable($traversable)) {
+      foreach ($traversable as $member) {
+        if (!(is_string($member) || (is_object($member) && method_exists($member, '__toString')))) {
+          return FALSE;
+        }
+      }
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Asserts that all members are associative arrays.
+   *
+   * What PHP calls arrays are more formally called maps in most other
+   * programming languages. A map is a datatype that associates values to keys.
+   * Maps are sometimes called associative arrays, hence the name of this
+   * method.
+   *
+   * @see http://php.net/manual/language.types.array.php
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are arrays.
+   */
+  public static function assertAllAssociativeArrays($traversable) {
+    return static::assertAllMembersAre('is_array', $traversable);
+  }
+
+  /**
+   * Asserts that the array is strict.
+   *
+   * A 'strict' array is an 0-indexed array in the classic sense found in
+   * programming languages other than PHP.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable is a 0-indexed array.
+   */
+  public static function assertStrictArray($array) {
+    if (!is_array($array)) {
+      return FALSE;
+    }
+    $i = 0;
+
+    foreach (array_keys($array) as $key) {
+      if ($i !== $key) {
+        return FALSE;
+      }
+      $i++;
+    }
+    return TRUE;
+  }
+
+  /**
+   * Asserts all members are strict arrays.
+   *
+   * @see ::assertStrictArray
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are strict arrays.
+   */
+  public static function assertAllStrictArrays($traversable) {
+    return static::assertAllMembersAre([__CLASS__, 'assertStrictArray'], $traversable );
+  }
+
+  /**
+   * Asserts all given keys exist in every member array.
+   *
+   * Drupal has several data structure arrays that require certain keys be set.
+   * You can overload this function to specify a list of required keys. All
+   * of the keys must be set for this method to return TRUE.
+   *
+   * As an example, this assertion tests for the keys of a theme registry.
+   *
+   * @code
+   *   assert('Drupal\\Component\\Assertion\\Assertion::assertAllHaveKey(
+   *     $arrayToTest, "type", "theme path", "function", "template", "variables", "render element", "preprocess functions")');
+   * @endcode
+   *
+   * Note: If a method requires certain keys to be present it will usually be
+   * specific about the data types of those keys and thefore it will be best to
+   * write a specific test for it. Such tests are either bound to the object
+   * that uses them, or are collected into one assertion set for the package.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @param string ...
+   *   Keys to be searched for.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members have all keys.
+   */
+  public static function assertAllHaveKey() {
+    $args = func_get_args();
+    $traversable = array_shift($args);
+
+    if (static::assertTraversable($traversable)) {
+      foreach ($traversable as $member) {
+        foreach ($args as $key) {
+          if (!array_key_exists($key, $member)) {
+            return FALSE;
+          }
+        }
+      }
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Asserts that all members are integer values.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are integers.
+   */
+  public static function assertAllIntegers($traversable) {
+    return static::assertAllMembersAre('is_int', $traversable);
+  }
+
+  /**
+   * Asserts that all members are float values.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are floating point
+   *   numbers.
+   */
+  public static function assertAllFloat($traversable) {
+    return static::assertAllMembersAre('is_float', $traversable);
+  }
+
+  /**
+   * Asserts that all members are callable.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are callable.
+   */
+  public static function assertAllCallable($traversable) {
+    return static::assertAllMembersAre('is_callable', $traversable);
+  }
+
+  /**
+   * Asserts that all members are not empty.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members not empty.
+   */
+  public static function assertAllNotEmpty($traversable) {
+    if (static::assertTraversable($traversable)) {
+      foreach ($traversable as $member) {
+        if (empty($member)) {
+          return FALSE;
+        }
+      }
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Asserts all members are numeric data types or strings castable to such.
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are numeric.
+   */
+  public static function assertAllNumeric($traversable) {
+    return static::assertAllMembersAre('is_numeric', $traversable);
+  }
+
+  /**
+   * Asserts that all members are strings that contain the specified string.
+   *
+   * This runs faster than the regular expression equivalent.
+   *
+   * @param string $pattern
+   *   The needle to find.
+   * @param mixed $traversable
+   *   Variable to examine.
+   * @param bool $case_sensitive
+   *   TRUE to use strstr(), FALSE to use stristr() which is case insensitive.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are strings
+   *   containing $pattern.
+   */
+  public static function assertAllMatch($pattern, $traversable, $case_sensitive = FALSE) {
+    if (static::assertTraversable($traversable)) {
+      if ($case_sensitive) {
+        foreach ($traversable as $member) {
+          if (!(is_string($member) && strstr($member, $pattern))) {
+            return FALSE;
+          }
+        }
+      }
+      else {
+        foreach ($traversable as $member) {
+          if (!(is_string($member) && stristr($member, $pattern))) {
+            return FALSE;
+          }
+        }
+      }
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+
+  /**
+   * Asserts that all members are strings matching a regular expression.
+   *
+   * @param string $pattern
+   *   Regular expression string to find.
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are strings
+   *   matching $pattern.
+   */
+  public static function assertAllRegularExpressionMatch($pattern, $traversable) {
+    if (static::assertTraversable($traversable)) {
+      foreach ($traversable as $member) {
+        if (!is_string($member)) {
+          return FALSE;
+        }
+
+        if (!preg_match($pattern, $member)) {
+          return FALSE;
+        }
+      }
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Asserts that all members are objects.
+   *
+   * When testing if a collection is composed of objects those objects should
+   * be given a common interface to implement and the test should be written to
+   * search for just that interface. While this method will allow tests for
+   * just object status or for multiple classes and interfaces this was done to
+   * allow tests to be written for existing code without altering it. Only use
+   * this method in this manner when testing code from third party vendors.
+   *
+   * Here are some examples:
+   * @code
+   *   // Just test all are objects, like a cache.
+   *   assert('Drupal\\Component\\Assertion\\Assertion::assertAllObjects(
+   *     $collection');
+   *
+   *   // Test if traversable objects (arrays won't pass this)
+   *   assert('Drupal\\Component\\Assertion\\Assertion::assertAllObjects(
+   *     $collection', \'\\Traversable\');
+   *
+   *   // Test for the Foo class or Bar\None interface
+   *   assert('Drupal\\Component\\Assertion\\Assertion::assertAllObjects(
+   *     $collection', \'\\Foo\', \'\\Bar\\None\'');
+   * @endcode
+   *
+   * @param mixed $traversable
+   *   Variable to be examined.
+   *
+   * @param string ...
+   *   Classes and interfaces to test objects against.
+   *
+   * @return bool
+   *   TRUE if $traversable can be traversed and all members are objects with
+   *   at least one of the listed classes or interfaces.
+   */
+  public static function assertAllObjects() {
+    $args = func_get_args();
+    $traversable = array_shift($args);
+
+    if (static::assertTraversable($traversable)) {
+      foreach ($traversable as $member) {
+        if (count($args) > 0) {
+          foreach ($args as $instance) {
+            if ($member instanceof $instance) {
+              // We're continuing to the next member on the outer loop.
+              // @see http://php.net/continue
+              continue 2;
+            }
+          }
+          return FALSE;
+        }
+        elseif (!is_object($member)) {
+          return FALSE;
+        }
+      }
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+}
diff --git a/core/modules/simpletest/simpletest.module b/core/modules/simpletest/simpletest.module
index 8ac63df..6fab9c3 100644
--- a/core/modules/simpletest/simpletest.module
+++ b/core/modules/simpletest/simpletest.module
@@ -13,6 +13,7 @@
  * @file
  * Provides testing functionality.
  */
+require_once DRUPAL_ROOT . '/core/includes/testing.inc';
 
 /**
  * Implements hook_help().
diff --git a/core/tests/Drupal/Tests/AssertionThrowTest.php b/core/tests/Drupal/Tests/AssertionThrowTest.php
new file mode 100644
index 0000000..63537c5
--- /dev/null
+++ b/core/tests/Drupal/Tests/AssertionThrowTest.php
@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\AssertionThrowTest.
+ */
+
+namespace Drupal\Tests;
+
+/**
+ * Tests default assertion handler for AssertionException throws.
+ *
+ * The drupal PHPUnit bootstrap file and simpletest.module file contain an
+ * assert callback handler that causes PHP 5.x to behave in a compatible manner
+ * to PHP 7, throwing an \AssertionException whenever a runtime assertion
+ * fails. This allows tests to be written with the annotation of
+ * "@expectedException AssertionException" and work under both PHP 5.x and 7.
+ *
+ * @see https://phpunit.de/manual/current/en/writing-tests-for-phpunit.html#writing-tests-for-phpunit.exceptions
+ *
+ * @ingroup php_assert
+ */
+class AssertionThrowTest extends UnitTestCase {
+  /**
+   * Tests to see if the caller is converting assert fails.
+   *
+   * PHP 7 will throw AssertionException on its own, PHP 5.x needs the
+   * code in bootstrap.php to function correctly for this to work.
+   *
+   * @expectedException AssertionException
+   */
+  public function testAssertRuntimeFailure() {
+    assert(false);
+    // We shouldn't reach this line.
+    $this->assertTrue(false);
+  }
+
+}
diff --git a/core/tests/Drupal/Tests/Component/Assertion/AssertionTest.php b/core/tests/Drupal/Tests/Component/Assertion/AssertionTest.php
new file mode 100644
index 0000000..e451152
--- /dev/null
+++ b/core/tests/Drupal/Tests/Component/Assertion/AssertionTest.php
@@ -0,0 +1,246 @@
+<?php
+/**
+ * @file
+ * Contains \Drupal\Tests\Component\AssertionTest.
+ */
+
+namespace Drupal\Tests\Component\Assertion;
+
+use ArrayObject;
+use stdClass;
+use PHPUnit_Framework_TestCase;
+use Drupal\Component\Assertion\Assertion;
+
+/**
+ * Test the static Assertion assisting Library.
+ *
+ * @coversDefaultClass \Drupal\Component\Assertion\Assertion
+ *
+ * @group Assertion
+ */
+class AssertionTest extends PHPUnit_Framework_TestCase {
+
+  /**
+   * Tests asserting argument is an array or traversable object.
+   *
+   * @covers ::assertTraversable
+   */
+  public function testAssertTraversable() {
+    $this->assertTrue(Assertion::assertTraversable([]));
+    $this->assertTrue(Assertion::assertTraversable(new ArrayObject()));
+    $this->assertFalse(Assertion::assertTraversable(new stdClass()));
+    $this->assertFalse(Assertion::assertTraversable('foo'));
+  }
+
+  /**
+   * Tests asserting all members are strings.
+   *
+   * @covers ::assertAllStrings
+   */
+  public function testAssertAllStrings() {
+    $this->assertTrue(Assertion::assertAllStrings([]));
+    $this->assertTrue(Assertion::assertAllStrings(['foo', 'bar']));
+    $this->assertFalse(Assertion::assertAllStrings('foo'));
+    $this->assertFalse(Assertion::assertAllStrings(['foo', new StringObject()]));
+  }
+
+  /**
+   * Tests asserting all members are strings or objects with __toString().
+   *
+   * @covers ::assertAllStringable
+   */
+  public function testAssertAllStringable() {
+    $this->assertTrue(Assertion::assertAllStringable([]));
+    $this->assertTrue(Assertion::assertAllStringable(['foo', 'bar']));
+    $this->assertFalse(Assertion::assertAllStringable('foo'));
+    $this->assertTrue(Assertion::assertAllStringable(['foo', new StringObject()]));
+  }
+
+  /**
+   * Tests asserting all members are arrays.
+   *
+   * @covers ::assertAllAssociativeArrays
+   */
+  public function testAssertAllAssociativeArrays() {
+    $this->assertTrue(Assertion::assertAllAssociativeArrays([]));
+    $this->assertTrue(Assertion::assertAllAssociativeArrays([[], []]));
+    $this->assertFalse(Assertion::assertAllAssociativeArrays([[], 'foo']));
+  }
+
+  /**
+   * Tests asserting array is 0-indexed - the strict definition of array.
+   *
+   * @covers ::assertStrictArray
+   */
+  public function testAssertStrictArray() {
+    $this->assertTrue(Assertion::assertStrictArray([]));
+    $this->assertTrue(Assertion::assertStrictArray(['bar', 'foo']));
+    $this->assertFalse(Assertion::assertStrictArray(['foo' => 'bar', 'bar' => 'foo']));
+  }
+
+  /**
+   * Tests asserting all members are strict arrays.
+   *
+   * @covers ::assertAllStrictArrays
+   */
+  public function testAssertAllStrictArrays() {
+    $this->assertTrue(Assertion::assertAllStrictArrays([]));
+    $this->assertTrue(Assertion::assertAllStrictArrays([[], []]));
+    $this->assertFalse(Assertion::assertAllStrictArrays([['foo' => 'bar', 'bar' => 'foo']]));
+  }
+
+  /**
+   * Tests asserting all members have specified keys.
+   *
+   * @covers ::assertAllHaveKey
+   */
+  public function testAssertAllHaveKey() {
+    $this->assertTrue(Assertion::assertAllHaveKey([]));
+    $this->assertTrue(Assertion::assertAllHaveKey([['foo' => 'bar', 'bar' => 'foo']]));
+    $this->assertTrue(Assertion::assertAllHaveKey([['foo' => 'bar', 'bar' => 'foo']], 'foo'));
+    $this->assertTrue(Assertion::assertAllHaveKey([['foo' => 'bar', 'bar' => 'foo']], 'bar', 'foo'));
+    $this->assertFalse(Assertion::assertAllHaveKey([['foo' => 'bar', 'bar' => 'foo']], 'bar', 'foo', 'moo'));
+  }
+
+  /**
+   * Tests asserting all members are integers.
+   *
+   * @covers ::assertAllIntegers
+   */
+  public function testAssertAllIntegers() {
+    $this->assertTrue(Assertion::assertAllIntegers([]));
+    $this->assertTrue(Assertion::assertAllIntegers([1, 2, 3]));
+    $this->assertFalse(Assertion::assertAllIntegers([1, 2, 3.14]));
+    $this->assertFalse(Assertion::assertAllIntegers([1, '2', 3]));
+  }
+
+  /**
+   * Tests asserting all members are floating point variables.
+   *
+   * @covers ::assertAllFloat
+   */
+  public function testAssertAllFloat() {
+    $this->assertTrue(Assertion::assertAllFloat([]));
+    $this->assertTrue(Assertion::assertAllFloat([1.0, 2.1, 3.14]));
+    $this->assertFalse(Assertion::assertAllFloat([1, 2.1, 3.14]));
+    $this->assertFalse(Assertion::assertAllFloat([1.0, '2', 3]));
+    $this->assertFalse(Assertion::assertAllFloat(['Titanic']));
+  }
+
+  /**
+   * Tests asserting all members are callable.
+   *
+   * @covers ::assertAllCallable
+   */
+  public function testAllCallable() {
+    $this->assertTrue(Assertion::assertAllCallable([
+      'strchr',
+      [$this, 'callMe'],
+      [__CLASS__, 'callMeStatic'],
+      function() {
+        return TRUE;
+      }
+    ]));
+
+    $this->assertFalse(Assertion::assertAllCallable([
+      'strchr',
+      [$this, 'callMe'],
+      [__CLASS__, 'callMeStatic'],
+      function() {
+        return TRUE;
+      },
+      "I'm not callable"
+    ]));
+  }
+
+  /**
+   * Tests asserting all members are !empty().
+   *
+   * @covers ::assertAllNotEmpty
+   */
+  public function testAllNotEmpty() {
+    $this->assertTrue(Assertion::assertAllNotEmpty([1, 'two']));
+    $this->assertFalse(Assertion::assertAllNotEmpty(['']));
+  }
+
+  /**
+   * Tests asserting all arguments are numbers or strings castable to numbers.
+   *
+   * @covers ::assertAllNumeric
+   */
+  public function testAssertAllNumeric() {
+    $this->assertTrue(Assertion::assertAllNumeric([1, '2', 3.14]));
+    $this->assertFalse(Assertion::assertAllNumeric([1, 'two', 3.14]));
+  }
+
+  /**
+   * Tests asserting strstr() or stristr() match.
+   *
+   * @covers ::assertAllMatch
+   */
+  public function testAssertAllMatch() {
+    $this->assertTrue(Assertion::assertAllMatch('f', ['fee', 'fi', 'fo']));
+    $this->assertTrue(Assertion::assertAllMatch('F', ['fee', 'fi', 'fo']));
+    $this->assertTrue(Assertion::assertAllMatch('f', ['fee', 'fi', 'fo'], TRUE));
+    $this->assertFalse(Assertion::assertAllMatch('F', ['fee', 'fi', 'fo'], TRUE));
+    $this->assertFalse(Assertion::assertAllMatch('e', ['fee', 'fi', 'fo']));
+    $this->assertFalse(Assertion::assertAllMatch('1', [12]));
+  }
+
+  /**
+   * Tests asserting regular expression match.
+   *
+   * @covers ::assertAllRegularExpressionMatch
+   */
+  public function testAssertAllRegularExpressionMatch() {
+    $this->assertTrue(Assertion::assertAllRegularExpressionMatch('/f/i', ['fee', 'fi', 'fo']));
+    $this->assertTrue(Assertion::assertAllRegularExpressionMatch('/F/i', ['fee', 'fi', 'fo']));
+    $this->assertTrue(Assertion::assertAllRegularExpressionMatch('/f/', ['fee', 'fi', 'fo']));
+    $this->assertFalse(Assertion::assertAllRegularExpressionMatch('/F/', ['fee', 'fi', 'fo']));
+    $this->assertFalse(Assertion::assertAllRegularExpressionMatch('/e/', ['fee', 'fi', 'fo']));
+    $this->assertFalse(Assertion::assertAllRegularExpressionMatch('/1/', [12]));
+  }
+
+  /**
+   * Tests asserting all members are objects.
+   *
+   * @covers ::assertAllObjects
+   */
+  public function testAssertAllObjects() {
+    $this->assertTrue(Assertion::assertAllObjects([new ArrayObject(), new ArrayObject()]));
+    $this->assertFalse(Assertion::assertAllObjects([new ArrayObject(), new ArrayObject(), 'foo']));
+    $this->assertTrue(Assertion::assertAllObjects([new ArrayObject(), new ArrayObject()], '\\Traversable'));
+    $this->assertFalse(Assertion::assertAllObjects([new ArrayObject(), new ArrayObject(), 'foo'], '\\Traversable'));
+    $this->assertFalse(Assertion::assertAllObjects([new ArrayObject(), new StringObject()], '\\Traversable'));
+    $this->assertTrue(Assertion::assertAllObjects([new ArrayObject(), new StringObject()], '\\Traversable', '\\Drupal\\Tests\\Component\\Assertion\\StringObject'));
+    $this->assertFalse(Assertion::assertAllObjects([new ArrayObject(), new StringObject(), new stdClass()], '\\ArrayObject', '\\Drupal\\Tests\\Component\\Assertion\\StringObject'));
+  }
+
+  /**
+   * Test method referenced by ::testAllCallable()
+   */
+  public function callMe() {
+    return TRUE;
+  }
+
+  /**
+   * Test method referenced by ::testAllCallable()
+   */
+  public static function callMeStatic() {
+    return TRUE;
+  }
+
+}
+
+/**
+ * Quick class for testing for objects with __toString.
+ */
+class StringObject {
+  /**
+   * {@inheritdoc}
+   */
+  public function __toString() {
+    return 'foo';
+  }
+
+}
diff --git a/core/tests/bootstrap.php b/core/tests/bootstrap.php
index fd980a4..11d9c00 100644
--- a/core/tests/bootstrap.php
+++ b/core/tests/bootstrap.php
@@ -89,3 +89,7 @@ function drupal_phpunit_register_extension_dirs(Composer\Autoload\ClassLoader $l
 // Set the default timezone. While this doesn't cause any tests to fail, PHP
 // complains if 'date.timezone' is not set in php.ini.
 date_default_timezone_set('UTC');
+
+// Set up runtime assertion handling and any other common test environment
+// concerns.
+require_once __DIR__ . '/../includes/testing.inc';
diff --git a/sites/example.settings.local.php b/sites/example.settings.local.php
index 56fed6f..f603a47 100644
--- a/sites/example.settings.local.php
+++ b/sites/example.settings.local.php
@@ -12,6 +12,11 @@
  */
 
 /**
+ * Set up runtime testing environment.
+ */
+require_once DRUPAL_ROOT . '/core/includes/testing.inc';
+
+/**
  * Enable local development services.
  */
 $settings['container_yamls'][] = DRUPAL_ROOT . '/sites/development.services.yml';