diff --git a/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleController.php b/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleController.php
index 58f9987..1fda6b9 100644
--- a/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleController.php
+++ b/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleController.php
@@ -57,12 +57,13 @@ class DBTNGExampleController {
         t('Surname'),
         t('Age'),
       );
-      $output .= theme('table', array(
-        'header' => $header,
-        'rows' => $rows,
-        'attributes' => array(
-          'id' => 'dbtng-example-advanced-list',
-         ),
+      $output .= theme('table',
+        array(
+          'header' => $header,
+          'rows' => $rows,
+          'attributes' => array(
+            'id' => 'dbtng-example-advanced-list',
+          ),
         )
       );
     }
diff --git a/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleStorage.php b/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleStorage.php
index 10487f8..0b2b527 100644
--- a/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleStorage.php
+++ b/dbtng_example/lib/Drupal/dbtng_example/DBTNGExampleStorage.php
@@ -71,7 +71,7 @@ class DBTNGExampleStorage {
   /**
    * Delete an entry from the database.
    *
-   * @param $entry
+   * @param array $entry
    *   An array containing at least the person identifier 'pid' element of the
    *   entry to delete.
    *
diff --git a/js_example/lib/Drupal/js_example/Controller/JsExampleController.php b/js_example/lib/Drupal/js_example/Controller/JsExampleController.php
index 359870e..2c3653c 100755
--- a/js_example/lib/Drupal/js_example/Controller/JsExampleController.php
+++ b/js_example/lib/Drupal/js_example/Controller/JsExampleController.php
@@ -49,7 +49,7 @@ INFOMARKUP
     $build = array();
     // Main container DIV.
     $build['content'] = array(
-      '#markup' => '<div id="js-weights"></div>'
+      '#markup' => '<div id="js-weights"></div>',
     );
     // Attach a CSS file to show which line is output by which script.
     $build['#attached']['css'] = array(drupal_get_path('module', 'js_example') .
diff --git a/page_example/lib/Drupal/page_example/Tests/PageExampleTest.php b/page_example/lib/Drupal/page_example/Tests/PageExampleTest.php
index 5686f55..173b6d9 100644
--- a/page_example/lib/Drupal/page_example/Tests/PageExampleTest.php
+++ b/page_example/lib/Drupal/page_example/Tests/PageExampleTest.php
@@ -51,7 +51,7 @@ class PageExampleTest extends WebTestBase {
    * @param string $url
    *   URL to verify.
    */
-  function pageExampleVerifyNoAccess($url) {
+  public function pageExampleVerifyNoAccess($url) {
     // Test that page returns 403 Access Denied.
     $this->drupalGet($url);
     $this->assertResponse(403);
diff --git a/phpunit_example/tests/Drupal/phpunit_example/Tests/AddClassTest.php b/phpunit_example/tests/Drupal/phpunit_example/Tests/AddClassTest.php
new file mode 100644
index 0000000..7d7c5a3
--- /dev/null
+++ b/phpunit_example/tests/Drupal/phpunit_example/Tests/AddClassTest.php
@@ -0,0 +1,188 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\phpunit_example\Tests\AddClassTest
+ */
+
+namespace Drupal\phpunit_example\Tests;
+
+use Drupal\Tests\UnitTestCase;
+
+use Drupal\phpunit_example\AddClass;
+
+/**
+ * A PHPUnit example test case against an example class.
+ *
+ * This test case demonstrates the following PHPUnit annotations:
+ * - dataProvider
+ * - expectedException
+ *
+ * PHPUnit looks for classes with names ending in 'Test'. Then it
+ * looks to see whether that class is a subclass of
+ * \PHPUnit_Framework_TestCase. Drupal supplies us with
+ * Drupal\Tests\UnitTestCase, which is a subclass of
+ * \PHPUnit_Framework_TestCase. So yay, PHPUnit will find this class.
+ *
+ * In unit testing, there should be as few dependencies as possible.
+ * We want the smallest number of moving parts to be interacting in
+ * our test, or we won't be sure where the errors are, or whether our
+ * tests passed by accident.
+ *
+ * So with that in mind, it's up to us to build out whatever
+ * dependencies we need. In the case of AddClass, our needs are meager;
+ * we only want an instance of AddClass so we can test its add() method.
+ *
+ * @ingroup phpunit_example
+ * @group phpunit_example
+ */
+class AddClassTest extends UnitTestCase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'AddClass Unit Test',
+      'description' => 'Show some simple unit tests',
+      'group' => 'Examples',
+    );
+  }
+
+  /**
+   * Very simple test of AddClass::add().
+   *
+   * This is a very simple unit test of a single method. It has
+   * a single assertion, and that assertion is probably going to
+   * pass. It ignores most of the problems that could arise in the
+   * method under test, so therefore: It is not a very good test.
+   */
+  public function testAdd() {
+    $sut = new AddClass();
+    $this->assertEquals($sut->add(2, 3), 5);
+  }
+
+  /**
+   * Test AddClass::add() with a data provider method.
+   *
+   * This method is very similar to testAdd(), but uses a data provider method
+   * to test with a wider range of data.
+   *
+   * You can tell PHPUnit which method is the data provider using the
+   * '@dataProvider' annotation.
+   *
+   * The data provider method just returns a big array of arrays of arguments.
+   * That is, for each time you want this test method run, the data provider
+   * should create an array of arguments for this method. In this case, it's
+   * $expected, $a, and $b. So one set of arguments would look a bit like this
+   * pseudocode:
+   *
+   * @code
+   * array( valueForExpected, valueForA, valueForB )
+   * @endcode
+   *
+   * It would then wrap this up in a higher-level array, so that PHPUnit can
+   * loop through them, like this pseudocode:
+   *
+   * @code
+   * return array( array(first, set), array (next, set) );
+   * @endcode
+   *
+   * This test has a better methodology than testAdd(), because it can easily
+   * be adapted by other developers, and because it tries more than one data
+   * set. This test is much better than testAdd(), although it still only
+   * tests 'good' data. When combined with testAddWithBadDataProvider(),
+   * we get a better picture of the behavior of the method under test.
+   *
+   * @dataProvider addDataProvider
+   *
+   * @see AddClassTest::addDataProvider()
+   */
+  public function testAddWithDataProvider($expected, $a, $b) {
+    $sut = new AddClass();
+    $this->assertEquals($expected, $sut->add($a, $b));
+  }
+
+  /**
+   * Test AddClass::add() with data that should throw an exception.
+   *
+   * This method is similar to testAddWithDataProvider(), but the data
+   * provider gives us data that should throw an exception.
+   *
+   * This test uses the '@expectedException' annotation to tell PHPUnit that
+   * a thrown exception should pass the test. You specify a
+   * fully-qualified exception class name. If you specify \Exception, PHPUnit
+   * will pass any exception, whereas a more specific subclass of \Exception
+   * will require that exception type to be thrown.
+   *
+   * Alternately, you can use try and catch blocks with assertions in order
+   * to test exceptions. We won't demonstrate that here; it's a much better
+   * idea to test your exceptions with @expectedException.
+   *
+   * @dataProvider addBadDataProvider
+   * @expectedException \InvalidArgumentException
+   *
+   * @see AddClassTest::addBadDataProvider()
+   */
+  public function testAddWithBadDataProvider($a, $b) {
+    $sut = new AddClass();
+    $sut->add($a, $b);
+  }
+
+  /**
+   * Data provider for testAddWithDataProvider().
+   *
+   * Data provider methods take no arguments and return an array of data
+   * to use for tests. Each element of the array is another array, which
+   * corresponds to the arguments in the test method's signature.
+   *
+   * Note also that PHPUnit tries to run tests using methods that begin
+   * with 'test'. This means that data provider method names should not
+   * begin with 'test'. Also, by convention, they should end with
+   * 'DataProvider'.
+   *
+   * @see AddClassTest::testAddWithDataProvider()
+   */
+  public function addDataProvider() {
+    return array(
+      // array($a, $b, $expected)
+      array(5, 2, 3),
+      array(50, 20, 30),
+    );
+  }
+
+  /**
+   * Data provider for testAddWithBadDataProvider().
+   *
+   * Since AddClass::add() can throw exceptions, it's time
+   * to give it some data that will cause these exceptions.
+   *
+   * add() should throw exceptions if either of it's arguments are
+   * not numeric, and we will generate some test data to prove that
+   * this is what it actually does.
+   *
+   * @see AddClassTest::testAddWithBadDataProvider()
+   */
+  public function addBadDataProvider() {
+    $badData = array();
+    // Set up an array with data that should cause add()
+    // to throw an exception.
+    $badDataTypes = array('string', FALSE, array('foo'), new \stdClass());
+    // Create some data where both $a and $b are bad types.
+    foreach ($badDataTypes as $badDatumA) {
+      foreach ($badDataTypes as $badDatumB) {
+        $badData[] = array($badDatumA, $badDatumB);
+      }
+    }
+    // Create some data where $a is good and $b is bad.
+    foreach ($badDataTypes as $badDatumB) {
+      $badData[] = array(1, $badDatumB);
+    }
+    // Create some data where $b is good and $a is bad.
+    foreach ($badDataTypes as $badDatumA) {
+      $badData[] = array($badDatumA, 1);
+    }
+    return $badData;
+  }
+
+}
diff --git a/phpunit_example/tests/Drupal/phpunit_example/Tests/DisplayManagerTest.php b/phpunit_example/tests/Drupal/phpunit_example/Tests/DisplayManagerTest.php
new file mode 100644
index 0000000..6830aca
--- /dev/null
+++ b/phpunit_example/tests/Drupal/phpunit_example/Tests/DisplayManagerTest.php
@@ -0,0 +1,73 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\phpunit_example\Tests\DisplayManagerTest
+ */
+
+namespace Drupal\phpunit_example\Tests;
+
+use Drupal\Tests\UnitTestCase;
+use Drupal\phpunit_example\DisplayManager;
+use Drupal\phpunit_example\DisplayInfoInterface;
+
+/**
+ * A PHPUnit example test case against an example class.
+ *
+ * @todo: More documentation.
+ *
+ * @ingroup phpunit_example
+ * @group phpunit_example
+ */
+class DisplayManagerTest extends UnitTestCase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'DisplayManager Unit Test',
+      'description' => 'Demonstrate unit testing with test doubles.',
+      'group' => 'Examples',
+    );
+  }
+
+  /**
+   * Test for DisplayManager's DisplayableItemInterface handling.
+   *
+   * This method sets up a mock DisplayableItemInterface object
+   * and then feeds it to a DisplayManager object to test
+   * the behavior of DisplayManager.
+   *
+   * See the inline comments for a thorough walk-through.
+   */
+  public function testSimpleMockDisplayManager() {
+    // Setting up:
+    // Get a mock object belonging to our desired interface.
+    // Note that we have to fully qualify the domain name
+    // for PHPUnit's benefit.
+    $mock = $this->getMock('Drupal\phpunit_example\DisplayInfoInterface');
+    // Here we're illustrating that the mock object belongs to
+    // our interface.
+    $this->assertTrue($mock instanceof DisplayInfoInterface);
+    // 'Program' our mock object to return a value for getDisplayName().
+    // expects($this->any()) tells the mock to return this value any time
+    // the method is called.
+    $mock->expects($this->any())
+        ->method('getDisplayName')
+        ->will($this->returnValue('the display name'));
+
+    // Create a DisplayManager, the class we're actually testing here.
+    $dm = new DisplayManager();
+    // Give it the mocked info object.
+    $dm->addDisplayableItem($mock);
+    // Assert that our DisplayManager has exactly one display object (our mock).
+    $this->assertEquals(1, $dm->countDisplayableItems());
+    // Assert that the DisplayManager can find our mocked info object.
+    $this->assertSame($mock, $dm->item('the display name'));
+    // Assert that the DisplayManager can't find an info object
+    // that it shouldn't have.
+    $this->assertNull($dm->item('nonexistant'));
+  }
+
+}
diff --git a/phpunit_example/tests/Drupal/phpunit_example/Tests/Double_DisplayManagerTest.php b/phpunit_example/tests/Drupal/phpunit_example/Tests/Double_DisplayManagerTest.php
deleted file mode 100644
index 17ca734..0000000
--- a/phpunit_example/tests/Drupal/phpunit_example/Tests/Double_DisplayManagerTest.php
+++ /dev/null
@@ -1,73 +0,0 @@
-<?php
-
-/**
- * @file
- * Contains Drupal\phpunit_example\Tests\Double_DisplayManagerTest
- */
-
-namespace Drupal\phpunit_example\Tests;
-
-use Drupal\Tests\UnitTestCase;
-use Drupal\phpunit_example\DisplayManager;
-use Drupal\phpunit_example\DisplayInfoInterface;
-
-/**
- * A PHPUnit example test case against an example class.
- *
- * @todo: More documentation.
- *
- * @ingroup phpunit_example
- * @group phpunit_example
- */
-class Double_DisplayManagerTest extends UnitTestCase {
-
-  /**
-   * {@inheritdoc}
-   */
-  public static function getInfo() {
-    return array(
-      'name' => 'DisplayManager Unit Test',
-      'description' => 'Demonstrate unit testing with test doubles.',
-      'group' => 'Examples',
-    );
-  }
-
-  /**
-   * Test for DisplayManager's DisplayableItemInterface handling.
-   *
-   * This method sets up a mock DisplayableItemInterface object
-   * and then feeds it to a DisplayManager object to test
-   * the behavior of DisplayManager.
-   *
-   * See the inline comments for a thorough walk-through.
-   */
-  public function testSimpleMockDisplayManager() {
-    // Setting up:
-    // Get a mock object belonging to our desired interface.
-    // Note that we have to fully qualify the domain name
-    // for PHPUnit's benefit.
-    $mock = $this->getMock('Drupal\phpunit_example\DisplayInfoInterface');
-    // Here we're illustrating that the mock object belongs to
-    // our interface.
-    $this->assertTrue($mock instanceof DisplayInfoInterface);
-    // 'Program' our mock object to return a value for getDisplayName().
-    // expects($this->any()) tells the mock to return this value any time
-    // the method is called.
-    $mock->expects($this->any())
-        ->method('getDisplayName')
-        ->will($this->returnValue('the display name'));
-
-    // Create a DisplayManager, the class we're actually testing here.
-    $dm = new DisplayManager();
-    // Give it the mocked info object.
-    $dm->addDisplayableItem($mock);
-    // Assert that our DisplayManager has exactly one display object (our mock).
-    $this->assertEquals(1, $dm->countDisplayableItems());
-    // Assert that the DisplayManager can find our mocked info object.
-    $this->assertSame($mock, $dm->item('the display name'));
-    // Assert that the DisplayManager can't find an info object
-    // that it shouldn't have.
-    $this->assertNull($dm->item('nonexistant'));
-  }
-
-}
diff --git a/phpunit_example/tests/Drupal/phpunit_example/Tests/ProtectedPrivatesTest.php b/phpunit_example/tests/Drupal/phpunit_example/Tests/ProtectedPrivatesTest.php
new file mode 100644
index 0000000..73774f2
--- /dev/null
+++ b/phpunit_example/tests/Drupal/phpunit_example/Tests/ProtectedPrivatesTest.php
@@ -0,0 +1,161 @@
+<?php
+
+/**
+ * @file
+ * Contains Drupal\phpunit_example\Tests\ProtectedPrivatesTest
+ */
+
+namespace Drupal\phpunit_example\Tests;
+
+use Drupal\Tests\UnitTestCase;
+
+use Drupal\phpunit_example\ProtectedPrivates;
+
+use Drupal\phpunit_example\Tests\Subclasses\ProtectedPrivatesSubclass;
+
+/**
+ * A PHPUnit example test case against an example class.
+ *
+ * This test case demonstrates the following unit testing patterns and topics:
+ * - Using reflection to test private class methods.
+ * - Using subclassing to test protected class methods.
+ *
+ * If you are reading this and don't understand the basics of unit testing,
+ * start reading AddClassTest instead.
+ *
+ * This test class uses reflection and subclassing to work around method
+ * access problems. Since, by design, a private method is inaccessible,
+ * we have to use reflection to gain access to the method for our own
+ * purposes.
+ *
+ * The getAccessibleMethod() method demonstrates a way to do this.
+ *
+ * Once we've set the method to be accessible, we can use it as if
+ * it were public.
+ *
+ * The same technique can be used for protected methods. However, there
+ * might be times when it makes more sense to subclass the class under
+ * test, and just make a public accessor method that way. So we
+ * demonstrate that here in testProtectedAdd().
+ *
+ * @ingroup phpunit_example
+ * @group phpunit_example
+ */
+class ProtectedPrivatesTest extends UnitTestCase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'ProtectedPrivates Unit Test',
+      'description' => 'Demonstrate unit testing of restricted methods.',
+      'group' => 'Examples',
+    );
+  }
+
+  /**
+   * Get an accessible method using reflection.
+   */
+  public function getAccessibleMethod($className, $methodName) {
+    $class = new \ReflectionClass($className);
+    $method = $class->getMethod($methodName);
+    $method->setAccessible(TRUE);
+    return $method;
+  }
+
+  /**
+   * Good data provider.
+   */
+  public function addDataProvider() {
+    return array(
+      array(5, 2, 3),
+    );
+  }
+
+  /**
+   * Test ProtectedPrivate::privateAdd().
+   *
+   * We want to test a private method on a class. This is problematic
+   * because, by design, we don't have access to this method. However,
+   * we do have a tool available to help us out with this problem:
+   * We can override the accessibility of a method using reflection.
+   *
+   * @dataProvider addDataProvider
+   */
+  public function testPrivateAdd($expected, $a, $b) {
+    // Get a reflected, accessible version of the privateAdd() method.
+    $privateMethod = $this->getAccessibleMethod(
+      'Drupal\phpunit_example\ProtectedPrivates',
+      'privateAdd'
+    );
+    // Create a new ProtectedPrivates object.
+    $pp = new ProtectedPrivates();
+    // Use the reflection to invoke on the object.
+    $sum = $privateMethod->invokeArgs($pp, array($a, $b));
+    // Make an assertion.
+    $this->assertEquals($expected, $sum);
+  }
+
+  /**
+   * Bad data provider.
+   */
+  public function addBadDataProvider() {
+    return array(
+      array('string', array()),
+    );
+  }
+
+  /**
+   * Test ProtectedPrivate::privateAdd() with bad data.
+   *
+   * This is essentially the same test as testPrivateAdd(), but using
+   * non-numeric data. This lets us test the exception-throwing ability
+   * of this private method.
+   *
+   * @expectedException \InvalidArgumentException
+   * @dataProvider addBadDataProvider
+   */
+  public function testPrivateAddBadData($a, $b) {
+    // Get a reflected, accessible version of the privateAdd() method.
+    $privateMethod = $this->getAccessibleMethod(
+      'Drupal\phpunit_example\ProtectedPrivates',
+      'privateAdd');
+    // Create a new ProtectedPrivates object.
+    $pp = new ProtectedPrivates();
+    // Use the reflection to invoke on the object.
+    // This should throw an exception.
+    $privateMethod->invokeArgs($pp, array($a, $b));
+  }
+
+  /**
+   * Test ProtectedPrivates::protectedAdd() using a stub class.
+   *
+   * We could use the same reflection technique to test protected
+   * methods, just like we did with private ones.
+   *
+   * But sometimes it might make more sense to use a stub class
+   * which will have access to the protected method. That's what
+   * we'll demonstrate here.
+   *
+   * @dataProvider addDataProvider
+   */
+  public function testProtectedAdd($expected, $a, $b) {
+    $stub = new ProtectedPrivatesSubclass();
+    $this->assertEquals($expected, $stub->sub_protectedAdd($a, $b));
+  }
+
+  /**
+   * Test ProtectedPrivates::protectedAdd() with bad data using a stub class.
+   *
+   * This test is similar to testProtectedAdd(), but expects an exception.
+   *
+   * @expectedException \InvalidArgumentException
+   * @dataProvider addBadDataProvider
+   */
+  public function testProtectedAddBadData($a, $b) {
+    $stub = new ProtectedPrivatesSubclass();
+    $stub->sub_protectedAdd($a, $b);
+  }
+
+}
diff --git a/phpunit_example/tests/Drupal/phpunit_example/Tests/ProviderException_AddClassTest.php b/phpunit_example/tests/Drupal/phpunit_example/Tests/ProviderException_AddClassTest.php
deleted file mode 100644
index 10c4ea0..0000000
--- a/phpunit_example/tests/Drupal/phpunit_example/Tests/ProviderException_AddClassTest.php
+++ /dev/null
@@ -1,188 +0,0 @@
-<?php
-
-/**
- * @file
- * Contains Drupal\phpunit_example\Tests\ProviderException_AddClassTest
- */
-
-namespace Drupal\phpunit_example\Tests;
-
-use Drupal\Tests\UnitTestCase;
-
-use Drupal\phpunit_example\AddClass;
-
-/**
- * A PHPUnit example test case against an example class.
- *
- * This test case demonstrates the following PHPUnit annotations:
- * - dataProvider
- * - expectedException
- *
- * PHPUnit looks for classes with names ending in 'Test'. Then it
- * looks to see whether that class is a subclass of
- * \PHPUnit_Framework_TestCase. Drupal supplies us with
- * Drupal\Tests\UnitTestCase, which is a subclass of
- * \PHPUnit_Framework_TestCase. So yay, PHPUnit will find this class.
- *
- * In unit testing, there should be as few dependencies as possible.
- * We want the smallest number of moving parts to be interacting in
- * our test, or we won't be sure where the errors are, or whether our
- * tests passed by accident.
- *
- * So with that in mind, it's up to us to build out whatever
- * dependencies we need. In the case of AddClass, our needs are meager;
- * we only want an instance of AddClass so we can test its add() method.
- *
- * @ingroup phpunit_example
- * @group phpunit_example
- */
-class ProviderException_AddClassTest extends UnitTestCase {
-
-  /**
-   * {@inheritdoc}
-   */
-  public static function getInfo() {
-    return array(
-      'name' => 'AddClass Unit Test',
-      'description' => 'Show some simple unit tests',
-      'group' => 'Examples',
-    );
-  }
-
-  /**
-   * Very simple test of AddClass::add().
-   *
-   * This is a very simple unit test of a single method. It has
-   * a single assertion, and that assertion is probably going to
-   * pass. It ignores most of the problems that could arise in the
-   * method under test, so therefore: It is not a very good test.
-   */
-  public function testAdd() {
-    $sut = new AddClass();
-    $this->assertEquals($sut->add(2, 3), 5);
-  }
-
-  /**
-   * Test AddClass::add() with a data provider method.
-   *
-   * This method is very similar to testAdd(), but uses a data provider method
-   * to test with a wider range of data.
-   *
-   * You can tell PHPUnit which method is the data provider using the
-   * '@dataProvider' annotation.
-   *
-   * The data provider method just returns a big array of arrays of arguments.
-   * That is, for each time you want this test method run, the data provider
-   * should create an array of arguments for this method. In this case, it's
-   * $expected, $a, and $b. So one set of arguments would look a bit like this
-   * pseudocode:
-   *
-   * @code
-   * array( valueForExpected, valueForA, valueForB )
-   * @endcode
-   *
-   * It would then wrap this up in a higher-level array, so that PHPUnit can
-   * loop through them, like this pseudocode:
-   *
-   * @code
-   * return array( array(first, set), array (next, set) );
-   * @endcode
-   *
-   * This test has a better methodology than testAdd(), because it can easily
-   * be adapted by other developers, and because it tries more than one data
-   * set. This test is much better than testAdd(), although it still only
-   * tests 'good' data. When combined with testAddWithBadDataProvider(),
-   * we get a better picture of the behavior of the method under test.
-   *
-   * @dataProvider addDataProvider
-   *
-   * @see AddClassTest::addDataProvider()
-   */
-  public function testAddWithDataProvider($expected, $a, $b) {
-    $sut = new AddClass();
-    $this->assertEquals($expected, $sut->add($a, $b));
-  }
-
-  /**
-   * Test AddClass::add() with data that should throw an exception.
-   *
-   * This method is similar to testAddWithDataProvider(), but the data
-   * provider gives us data that should throw an exception.
-   *
-   * This test uses the '@expectedException' annotation to tell PHPUnit that
-   * a thrown exception should pass the test. You specify a
-   * fully-qualified exception class name. If you specify \Exception, PHPUnit
-   * will pass any exception, whereas a more specific subclass of \Exception
-   * will require that exception type to be thrown.
-   *
-   * Alternately, you can use try and catch blocks with assertions in order
-   * to test exceptions. We won't demonstrate that here; it's a much better
-   * idea to test your exceptions with @expectedException.
-   *
-   * @dataProvider addBadDataProvider
-   * @expectedException \InvalidArgumentException
-   *
-   * @see AddClassTest::addBadDataProvider()
-   */
-  public function testAddWithBadDataProvider($a, $b) {
-    $sut = new AddClass();
-    $sut->add($a, $b);
-  }
-
-  /**
-   * Data provider for testAddWithDataProvider().
-   *
-   * Data provider methods take no arguments and return an array of data
-   * to use for tests. Each element of the array is another array, which
-   * corresponds to the arguments in the test method's signature.
-   *
-   * Note also that PHPUnit tries to run tests using methods that begin
-   * with 'test'. This means that data provider method names should not
-   * begin with 'test'. Also, by convention, they should end with
-   * 'DataProvider'.
-   *
-   * @see AddClassTest::testAddWithDataProvider()
-   */
-  public function addDataProvider() {
-    return array(
-      // array($a, $b, $expected)
-      array(5, 2, 3),
-      array(50, 20, 30),
-    );
-  }
-
-  /**
-   * Data provider for testAddWithBadDataProvider().
-   *
-   * Since AddClass::add() can throw exceptions, it's time
-   * to give it some data that will cause these exceptions.
-   *
-   * add() should throw exceptions if either of it's arguments are
-   * not numeric, and we will generate some test data to prove that
-   * this is what it actually does.
-   *
-   * @see AddClassTest::testAddWithBadDataProvider()
-   */
-  public function addBadDataProvider() {
-    $badData = array();
-    // Set up an array with data that should cause add()
-    // to throw an exception.
-    $badDataTypes = array('string', FALSE, array('foo'), new \stdClass());
-    // Create some data where both $a and $b are bad types.
-    foreach ($badDataTypes as $badDatumA) {
-      foreach ($badDataTypes as $badDatumB) {
-        $badData[] = array($badDatumA, $badDatumB);
-      }
-    }
-    // Create some data where $a is good and $b is bad.
-    foreach($badDataTypes as $badDatumB) {
-      $badData[] = array(1, $badDatumB);
-    }
-    // Create some data where $b is good and $a is bad.
-    foreach($badDataTypes as $badDatumA) {
-      $badData[] = array($badDatumA, 1);
-    }
-    return $badData;
-  }
-
-}
diff --git a/phpunit_example/tests/Drupal/phpunit_example/Tests/Reflection_ProtectedPrivatesTest.php b/phpunit_example/tests/Drupal/phpunit_example/Tests/Reflection_ProtectedPrivatesTest.php
deleted file mode 100644
index 179b669..0000000
--- a/phpunit_example/tests/Drupal/phpunit_example/Tests/Reflection_ProtectedPrivatesTest.php
+++ /dev/null
@@ -1,161 +0,0 @@
-<?php
-
-/**
- * @file
- * Contains Drupal\phpunit_example\Tests\Reflection_ProtectedPrivatesTest
- */
-
-namespace Drupal\phpunit_example\Tests;
-
-use Drupal\Tests\UnitTestCase;
-
-use Drupal\phpunit_example\ProtectedPrivates;
-
-use Drupal\phpunit_example\Tests\Subclasses\ProtectedPrivatesSubclass;
-
-/**
- * A PHPUnit example test case against an example class.
- *
- * This test case demonstrates the following unit testing patterns and topics:
- * - Using reflection to test private class methods.
- * - Using subclassing to test protected class methods.
- *
- * If you are reading this and don't understand the basics of unit testing,
- * start reading AddClassTest instead.
- *
- * This test class uses reflection and subclassing to work around method
- * access problems. Since, by design, a private method is inaccessible,
- * we have to use reflection to gain access to the method for our own
- * purposes.
- *
- * The getAccessibleMethod() method demonstrates a way to do this.
- *
- * Once we've set the method to be accessible, we can use it as if
- * it were public.
- *
- * The same technique can be used for protected methods. However, there
- * might be times when it makes more sense to subclass the class under
- * test, and just make a public accessor method that way. So we
- * demonstrate that here in testProtectedAdd().
- *
- * @ingroup phpunit_example
- * @group phpunit_example
- */
-class Reflection_ProtectedPrivatesTest extends UnitTestCase {
-
-  /**
-   * {@inheritdoc}
-   */
-  public static function getInfo() {
-    return array(
-      'name' => 'ProtectedPrivates Unit Test',
-      'description' => 'Demonstrate unit testing of restricted methods.',
-      'group' => 'Examples',
-    );
-  }
-
-  /**
-   * Get an accessible method using reflection.
-   */
-  public function getAccessibleMethod($className, $methodName) {
-    $class = new \ReflectionClass($className);
-    $method = $class->getMethod($methodName);
-    $method->setAccessible(true);
-    return $method;
-  }
-
-  /**
-   * Good data provider.
-   */
-  public function addDataProvider() {
-    return array (
-      array (5, 2, 3),
-    );
-  }
-
-  /**
-   * Test ProtectedPrivate::privateAdd().
-   *
-   * We want to test a private method on a class. This is problematic
-   * because, by design, we don't have access to this method. However,
-   * we do have a tool available to help us out with this problem:
-   * We can override the accessibility of a method using reflection.
-   *
-   * @dataProvider addDataProvider
-   */
-  public function testPrivateAdd($expected, $a, $b) {
-    // Get a reflected, accessible version of the privateAdd() method.
-    $privateMethod = $this->getAccessibleMethod(
-      'Drupal\phpunit_example\ProtectedPrivates',
-      'privateAdd'
-    );
-    // Create a new ProtectedPrivates object.
-    $pp = new ProtectedPrivates();
-    // Use the reflection to invoke on the object.
-    $sum = $privateMethod->invokeArgs($pp, array($a, $b));
-    // Make an assertion.
-    $this->assertEquals($expected, $sum);
-  }
-
-  /**
-   * Bad data provider.
-   */
-  public function addBadDataProvider() {
-    return array (
-      array ('string', array()),
-    );
-  }
-
-  /**
-   * Test ProtectedPrivate::privateAdd() with bad data.
-   *
-   * This is essentially the same test as testPrivateAdd(), but using
-   * non-numeric data. This lets us test the exception-throwing ability
-   * of this private method.
-   *
-   * @expectedException \InvalidArgumentException
-   * @dataProvider addBadDataProvider
-   */
-  public function testPrivateAddBadData($a, $b) {
-    // Get a reflected, accessible version of the privateAdd() method.
-    $privateMethod = $this->getAccessibleMethod(
-      'Drupal\phpunit_example\ProtectedPrivates',
-      'privateAdd');
-    // Create a new ProtectedPrivates object.
-    $pp = new ProtectedPrivates();
-    // Use the reflection to invoke on the object.
-    // This should throw an exception.
-    $privateMethod->invokeArgs($pp, array($a, $b));
-  }
-
-  /**
-   * Test ProtectedPrivates::protectedAdd() using a stub class.
-   *
-   * We could use the same reflection technique to test protected
-   * methods, just like we did with private ones.
-   *
-   * But sometimes it might make more sense to use a stub class
-   * which will have access to the protected method. That's what
-   * we'll demonstrate here.
-   *
-   * @dataProvider addDataProvider
-   */
-  public function testProtectedAdd($expected, $a, $b) {
-    $stub = new ProtectedPrivatesSubclass();
-    $this->assertEquals($expected, $stub->sub_protectedAdd($a, $b));
-  }
-
-  /**
-   * Test ProtectedPrivates::protectedAdd() with bad data using a stub class.
-   *
-   * This test is similar to testProtectedAdd(), but expects an exception.
-   *
-   * @expectedException \InvalidArgumentException
-   * @dataProvider addBadDataProvider
-   */
-  public function testProtectedAddBadData($a, $b) {
-    $stub = new ProtectedPrivatesSubclass();
-    $stub->sub_protectedAdd($a, $b);
-  }
-
-}