diff --git a/src/assertions.rst b/src/assertions.rst
index 86e0d00d..0c759ec7 100644
--- a/src/assertions.rst
+++ b/src/assertions.rst
@@ -2452,14 +2452,14 @@ assertThat()
 ############
 
 Des assertions plus complexes peuvent être formulées en utilisant les
-classes ``PHPUnit_Framework_Constraint``. Elles peuvent être
+classes ``PHPUnit\Framework\Constraint``. Elles peuvent être
 évaluées avec la méthode ``assertThat()``.
 :numref:`appendixes.assertions.assertThat.example` montre comment les contraintes
 ``logicalNot()`` et ``equalTo()``
 peuvent être utilisées pour exprimer la même assertion que
 ``assertNotEquals()``.
 
-``assertThat(mixed $value, PHPUnit_Framework_Constraint $constraint[, $message = ''])``
+``assertThat(mixed $value, PHPUnit\Framework\Constraint $constraint[, $message = ''])``
 
 Signale une erreur identifiée par ``$message``si ``$value`` ne correspond pas à ``$constraint``.
 
@@ -2488,7 +2488,7 @@ Signale une erreur identifiée par ``$message``si ``$value`` ne correspond pas 
     ?>
 
 :numref:`appendixes.assertions.assertThat.tables.constraints` montre les
-classes ``PHPUnit_Framework_Constraint`` disponibles.
+classes ``PHPUnit\Framework\Constraint`` disponibles.
 
 .. rst-class:: table
 .. list-table:: Contraintes
@@ -2497,71 +2497,71 @@ classes ``PHPUnit_Framework_Constraint`` disponibles.
 
     * - Contrainte
       - Signification
-    * - ``PHPUnit_Framework_Constraint_Attribute attribute(PHPUnit_Framework_Constraint $constraint, $attributeName)``
+    * - ``PHPUnit\Framework\Constraint\Attribute attribute(PHPUnit\Framework\Constraint $constraint, $attributeName)``
       - Contrainte qui applique une autre contrainte à un attribut d'une classe ou d'un objet.
-    * - ``PHPUnit_Framework_Constraint_IsAnything anything()``
+    * - ``PHPUnit\Framework\Constraint\IsAnything anything()``
       - Contrainte qui accepte toute valeur d'entrée.
-    * - ``PHPUnit_Framework_Constraint_ArrayHasKey arrayHasKey(mixed $key)``
+    * - ``PHPUnit\Framework\Constraint\ArrayHasKey arrayHasKey(mixed $key)``
       - Contrainte qui valide que le tableau évalué a une clé donnée.
-    * - ``PHPUnit_Framework_Constraint_TraversableContains contains(mixed $value)``
+    * - ``PHPUnit\Framework\Constraint\TraversableContains contains(mixed $value)``
       - Contrainte qui valide que le ``tableau`` ou l'objet qui implémente l'interface ``Iterator`` évalué contient une valeur donnée.
-    * - ``PHPUnit_Framework_Constraint_TraversableContainsOnly containsOnly(string $type)``
+    * - ``PHPUnit\Framework\Constraint\TraversableContainsOnly containsOnly(string $type)``
       - Contrainte qui valide que le ``tableau`` ou l'objet qui implémente l'interface ``Iterator`` évalué ne contient que des valeurs d'un type donné.
-    * - ``PHPUnit_Framework_Constraint_TraversableContainsOnly containsOnlyInstancesOf(string $classname)``
+    * - ``PHPUnit\Framework\Constraint\TraversableContainsOnly containsOnlyInstancesOf(string $classname)``
       - Contrainte qui valide que le ``tableau`` ou l'objet qui implémente l'interface ``Iterator`` évalué ne contient que des instances d'une classe donnée.
-    * - ``PHPUnit_Framework_Constraint_IsEqual equalTo($value, $delta = 0, $maxDepth = 10)``
+    * - ``PHPUnit\Framework\Constraint\IsEqual equalTo($value, $delta = 0, $maxDepth = 10)``
       - Contrainte qui vérifie si une valeur est égale à une autre.
-    * - ``PHPUnit_Framework_Constraint_Attribute attributeEqualTo($attributeName, $value, $delta = 0, $maxDepth = 10)``
+    * - ``PHPUnit\Framework\Constraint\Attribute attributeEqualTo($attributeName, $value, $delta = 0, $maxDepth = 10)``
       - Contrainte qui vérifie si une valeur est égale à un attribut d'une classe ou d'un objet.
-    * - ``PHPUnit_Framework_Constraint_DirectoryExists directoryExists()``
+    * - ``PHPUnit\Framework\Constraint\DirectoryExists directoryExists()``
       - Contrainte qui vérifie si le répertoire évalué existe.
-    * - ``PHPUnit_Framework_Constraint_FileExists fileExists()``
+    * - ``PHPUnit\Framework\Constraint\FileExists fileExists()``
       - Contrainte qui vérifie si le fichier (name) évalué existe.
-    * - ``PHPUnit_Framework_Constraint_IsReadable isReadable()``
+    * - ``PHPUnit\Framework\Constraint\IsReadable isReadable()``
       - Contrainte qui vérifie si le fichier (name) évalué est accessible en écriture.
-    * - ``PHPUnit_Framework_Constraint_IsWritable isWritable()``
+    * - ``PHPUnit\Framework\Constraint\IsWritable isWritable()``
       - Contrainte qui vérifie si le fichier (name) évalué est accessible en écriture.
-    * - ``PHPUnit_Framework_Constraint_GreaterThan greaterThan(mixed $value)``
+    * - ``PHPUnit\Framework\Constraint\GreaterThan greaterThan(mixed $value)``
       - Contrainte qui valide que la valeur évaluée est supérieure à une valeur donnée.
-    * - ``PHPUnit_Framework_Constraint_Or greaterThanOrEqual(mixed $value)``
+    * - ``PHPUnit\Framework\Constraint\Or greaterThanOrEqual(mixed $value)``
       - Contrainte qui valide que la valeur évaluée est supérieure ou égale à une valeur donnée.
-    * - ``PHPUnit_Framework_Constraint_ClassHasAttribute classHasAttribute(string $attributeName)``
+    * - ``PHPUnit\Framework\Constraint\ClassHasAttribute classHasAttribute(string $attributeName)``
       - La contrainte qui valide que la classe évaluée possède un attribut donné.
-    * - ``PHPUnit_Framework_Constraint_ClassHasStaticAttribute classHasStaticAttribute(string $attributeName)``
+    * - ``PHPUnit\Framework\Constraint\ClassHasStaticAttribute classHasStaticAttribute(string $attributeName)``
       - La contrainte qui valide que la classe évaluée possède un attribut statique donné.
-    * - ``PHPUnit_Framework_Constraint_ObjectHasAttribute hasAttribute(string $attributeName)``
+    * - ``PHPUnit\Framework\Constraint\ObjectHasAttribute hasAttribute(string $attributeName)``
       - La contrainte qui valide que l'objet évalué possède un attribut donné.
-    * - ``PHPUnit_Framework_Constraint_IsIdentical identicalTo(mixed $value)``
+    * - ``PHPUnit\Framework\Constraint\IsIdentical identicalTo(mixed $value)``
       - Contrainte qui valide qu'une valeur est identique à une autre.
-    * - ``PHPUnit_Framework_Constraint_IsFalse isFalse()``
+    * - ``PHPUnit\Framework\Constraint\IsFalse isFalse()``
       - Contrainte qui valide qu'une valeur évaluée est ``false``.
-    * - ``PHPUnit_Framework_Constraint_IsInstanceOf isInstanceOf(string $className)``
+    * - ``PHPUnit\Framework\Constraint\IsInstanceOf isInstanceOf(string $className)``
       - La contrainte qui VALIDE que l'objet évalué est une instance d'une classe donnée.
-    * - ``PHPUnit_Framework_Constraint_IsNull isNull()``
+    * - ``PHPUnit\Framework\Constraint\IsNull isNull()``
       - Contrainte qui valide qu'une valeur évaluée est ``null``.
-    * - ``PHPUnit_Framework_Constraint_IsTrue isTrue()``
+    * - ``PHPUnit\Framework\Constraint\IsTrue isTrue()``
       - Contrainte qui valide qu'une valeur évaluée est ``true``.
-    * - ``PHPUnit_Framework_Constraint_IsType isType(string $type)``
+    * - ``PHPUnit\Framework\Constraint\IsType isType(string $type)``
       - Contrainte qui valide que la valeur évaluée est d'un type spécifié.
-    * - ``PHPUnit_Framework_Constraint_LessThan lessThan(mixed $value)``
+    * - ``PHPUnit\Framework\Constraint\LessThan lessThan(mixed $value)``
       - Constraint that asserts that the value it is evaluated for is smaller than a given value.
-    * - ``PHPUnit_Framework_Constraint_Or lessThanOrEqual(mixed $value)``
+    * - ``PHPUnit\Framework\Constraint\Or lessThanOrEqual(mixed $value)``
       - Contrainte qui valide que la valeur évaluée est inférieure ou égale à une valeur donnée.
     * - ``logicalAnd()``
       - ET logique (AND).
-    * - ``logicalNot(PHPUnit_Framework_Constraint $constraint)``
+    * - ``logicalNot(PHPUnit\Framework\Constraint $constraint)``
       - NON logique (NOT).
     * - ``logicalOr()``
       - OU logique (OR).
     * - ``logicalXor()``
       - OU exclusif logique (XOR).
-    * - ``PHPUnit_Framework_Constraint_PCREMatch matchesRegularExpression(string $pattern)``
+    * - ``PHPUnit\Framework\Constraint\PCREMatch matchesRegularExpression(string $pattern)``
       - Contrainte qui valide que la chaine évaluée correspond à une expression régulière.
-    * - ``PHPUnit_Framework_Constraint_StringContains stringContains(string $string, bool $case)``
+    * - ``PHPUnit\Framework\Constraint\StringContains stringContains(string $string, bool $case)``
       - Contrainte qui valide que la chaine évaluée contient une chaine donnée.
-    * - ``PHPUnit_Framework_Constraint_StringEndsWith stringEndsWith(string $suffix)``
+    * - ``PHPUnit\Framework\Constraint\StringEndsWith stringEndsWith(string $suffix)``
       - Contrainte qui valide que la chaine évaluée termine par un suffixe donné.
-    * - ``PHPUnit_Framework_Constraint_StringStartsWith stringStartsWith(string $prefix)``
+    * - ``PHPUnit\Framework\Constraint\StringStartsWith stringStartsWith(string $prefix)``
       - Contrainte qui valide que la chaine évaluée commence par un préfixe donné.
 
 .. _appendixes.assertions.assertTrue:
diff --git a/src/code-coverage-analysis.rst b/src/code-coverage-analysis.rst
index 57962cd3..babb91b0 100644
--- a/src/code-coverage-analysis.rst
+++ b/src/code-coverage-analysis.rst
@@ -283,9 +283,9 @@ ne générez une couverture de code avec des tests unitaires.
     :name: code-coverage-analysis.specifying-covered-methods.examples.GuestbookIntegrationTest.php
 
     <?php
-    use PHPUnit\Framework\TestCase;
+    use PHPUnit\DbUnit\TestCase
 
-    class GuestbookIntegrationTest extends PHPUnit_Extensions_Database_TestCase
+    class GuestbookIntegrationTest extends TestCase
     {
         /**
          * @coversNothing
diff --git a/src/configuration.rst b/src/configuration.rst
index 47ff262f..78c8831d 100644
--- a/src/configuration.rst
+++ b/src/configuration.rst
@@ -29,7 +29,7 @@ utilisés pour configurer les fonctionnalités du coeur de PHPUnit.
              convertWarningsToExceptions="true"
              forceCoversAnnotation="false"
              mapTestClassNameToCoveredClassName="false"
-             printerClass="PHPUnit_TextUI_ResultPrinter"
+             printerClass="PHPUnit\TextUI\ResultPrinter"
              <!--printerFile="/path/to/ResultPrinter.php"-->
              processIsolation="false"
              stopOnError="false"
@@ -37,7 +37,7 @@ utilisés pour configurer les fonctionnalités du coeur de PHPUnit.
              stopOnIncomplete="false"
              stopOnSkipped="false"
              stopOnRisky="false"
-             testSuiteLoaderClass="PHPUnit_Runner_StandardTestSuiteLoader"
+             testSuiteLoaderClass="PHPUnit\Runner\StandardTestSuiteLoader"
              <!--testSuiteLoaderFile="/path/to/StandardTestSuiteLoader.php"-->
              timeoutForSmallTests="1"
              timeoutForMediumTests="10"
diff --git a/src/database.rst b/src/database.rst
index 45f31ce3..9967a317 100644
--- a/src/database.rst
+++ b/src/database.rst
@@ -114,7 +114,8 @@ données utilisées pour chaque test et que vous essayez de tester le plus de co
 des tests qui ne font pas appel à une base de données, vous pouvez facilement rester très en dessous
 d'une minute, même pour de grandes séries de tests.
 
-La suite de test du `projet Doctrine 2 <http://www.doctrine-project.org>`_, par exemple, possède actuellement une suite de tests d'environ 1000 tests
+La suite de test du
+`projet Doctrine 2 <http://www.doctrine-project.org>`_, par exemple, possède actuellement une suite de tests d'environ 1000 tests
 dont presque la moitié accède à la base de données et continue à s'exécuter en 15
 secondes sur une base de données MySQL sur un ordinateur de
 bureau standard.
@@ -227,7 +228,7 @@ abstrait différent qui nécessite que vous implémentiez deux méthodes abstrai
         use TestCaseTrait;
 
         /**
-         * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection
+         * @return PHPUnit\DbUnit\Database\Connection
          */
         public function getConnection()
         {
@@ -236,7 +237,7 @@ abstrait différent qui nécessite que vous implémentiez deux méthodes abstrai
         }
 
         /**
-         * @return PHPUnit_Extensions_Database_DataSet_IDataSet
+         * @return PHPUnit\DbUnit\DataSet\IDataSet
          */
         public function getDataSet()
         {
@@ -262,7 +263,7 @@ et nous l'avons passé à la méthode ``createDefaultDBConnection``
 qui encapsule l'instance PDO et le second paramètre (le
 nom de la base de données) dans une couche d'abstraction très simple pour connexion
 aux bases de données du type
-``PHPUnit_Extensions_Database_DB_IDatabaseConnection``.
+``PHPUnit\DbUnit\Database\Connection``.
 
 La section “Utiliser l'API la connexion de base de données“ explicite l'API
 de cette interface et comment en faire le meilleur usage.
@@ -277,8 +278,8 @@ l'état initial de la base de données avant que chaque test ne soit
 exécuté. L'état de la base de données est abstrait par les
 concepts DataSet et DataTable, tous les deux représentés par les
 interfaces
-``PHPUnit_Extensions_Database_DataSet_IDataSet`` et
-``PHPUnit_Extensions_Database_DataSet_IDataTable``.
+``HPUnit\DbUnit\DataSet\IDataSet`` et
+``PHPUnit\DbUnit\DataSet\IDataTable``.
 La prochaine section décrira en détail comment ces concepts fonctionnent
 et quels sont les avantages à les utiliser lors des tests de base de données.
 
@@ -344,7 +345,7 @@ d'indiquer des données de fixture différentes pour chaque cas de test :
         // only instantiate pdo once for test clean-up/fixture load
         static private $pdo = null;
 
-        // only instantiate PHPUnit_Extensions_Database_DB_IDatabaseConnection once per test
+        // only instantiate PHPUnit\DbUnit\Database\Connection once per test
         private $conn = null;
 
         final public function getConnection()
@@ -396,7 +397,7 @@ Nous pouvons maintenant modifier notre cas de test pour qu'il ressemble à ça :
         // only instantiate pdo once for test clean-up/fixture load
         static private $pdo = null;
 
-        // only instantiate PHPUnit_Extensions_Database_DB_IDatabaseConnection once per test
+        // only instantiate PHPUnit\DbUnit\Database\Connection once per test
         private $conn = null;
 
         final public function getConnection()
@@ -876,7 +877,13 @@ L'implémentation de ce DataSet tableau est simple et
 .. code-block:: php
 
     <?php
-    class MyApp_DbUnit_ArrayDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet
+
+    use PHPUnit\DbUnit\DataSet\AbstractDataSet;
+    use PHPUnit\DbUnit\DataSet\DefaultTableMetaData
+    use PHPUnit\DbUnit\DataSet\DefaultTable
+    use PHPUnit\DbUnit\DataSet\DefaultTableIterator
+
+    class MyApp_DbUnit_ArrayDataSet extends AbstractDataSet
     {
         /**
          * @var array
@@ -894,8 +901,8 @@ L'implémentation de ce DataSet tableau est simple et
                     $columns = array_keys($rows[0]);
                 }
 
-                $metaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData($tableName, $columns);
-                $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($metaData);
+                $metaData = new DefaultTableMetaData($tableName, $columns);
+                $table = new DefaultTable($metaData);
 
                 foreach ($rows AS $row) {
                     $table->addRow($row);
@@ -906,7 +913,7 @@ L'implémentation de ce DataSet tableau est simple et
 
         protected function createIterator($reverse = false)
         {
-            return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse);
+            return new DefaultTableIterator($this->tables, $reverse);
         }
 
         public function getTable($tableName)
@@ -932,7 +939,7 @@ qui contiennent le contenu constaté de la base de données. C'est là que le Da
 .. code-block:: php
 
     <?php
-    $ds = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection());
+    $ds = new PHPUnit\DbUnit\DataSet\QueryDataSet($this->getConnection());
     $ds->addTable('guestbook');
     ?>
 
@@ -942,7 +949,7 @@ la table de données avec la requête suivante :
 .. code-block:: php
 
     <?php
-    $ds = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection());
+    $ds = new PHPUnit\DbUnit\DataSet\QueryDataSet($this->getConnection());
     $ds->addTable('guestbook', 'SELECT * FROM guestbook');
     ?>
 
@@ -953,7 +960,7 @@ ajoutant des clauses ``ORDER BY``:
 .. code-block:: php
 
     <?php
-    $ds = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection());
+    $ds = new PHPUnit\DbUnit\DataSet\QueryDataSet($this->getConnection());
     $ds->addTable('guestbook', 'SELECT id, content FROM guestbook ORDER BY created DESC');
     ?>
 
@@ -986,7 +993,7 @@ la méthode ``testFilteredGuestbook()``.
         use TestCaseTrait;
 
         /**
-         * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection
+         * @return PHPUnit\DbUnit\Database\Connection
          */
         public function getConnection()
         {
@@ -1049,7 +1056,7 @@ Nous encapsulons le DataSet au format XML à plat dans le DataSet de remplacemen
         public function getDataSet()
         {
             $ds = $this->createFlatXmlDataSet('myFlatXmlFixture.xml');
-            $rds = new PHPUnit_Extensions_Database_DataSet_ReplacementDataSet($ds);
+            $rds = new PHPUnit\DbUnit\DataSet\ReplacementDataSet($ds);
             $rds->addFullReplacement('##NULL##', null);
             return $rds;
         }
@@ -1081,7 +1088,7 @@ particulièrement commode en combinaison avec le DataSet de base de données pou
             $tableNames = ['guestbook'];
             $dataSet = $this->getConnection()->createDataSet();
 
-            $filterDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet);
+            $filterDataSet = new PHPUnit\DbUnit\DataSet\DataSetFilter($dataSet);
             $filterDataSet->addIncludeTables(['guestbook']);
             $filterDataSet->setIncludeColumnsForTable('guestbook', ['id', 'content']);
             // ..
@@ -1092,7 +1099,7 @@ particulièrement commode en combinaison avec le DataSet de base de données pou
             $tableNames = ['guestbook'];
             $dataSet = $this->getConnection()->createDataSet();
 
-            $filterDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet);
+            $filterDataSet = new PHPUnit\DbUnit\DataSet\DataSetFilter($dataSet);
             $filterDataSet->addExcludeTables(['foo', 'bar', 'baz']); // only keep the guestbook table!
             $filterDataSet->setExcludeColumnsForTable('guestbook', ['user', 'created']);
             // ..
@@ -1104,8 +1111,7 @@ particulièrement commode en combinaison avec le DataSet de base de données pou
 
     Vous ne pouvez pas utiliser en même temps le filtrage de colonne d'inclusion
     et d'exclusion sur la même table, seulement sur des tables différentes.
-    De plus, il est seulement possible d'appliquer soit une liste blanche,
-    soit une liste noire aux tables, mais pas les deux à la fois.
+    De plus, il est seulement possible d'appliquer soit une liste blanche, soit une liste noire aux tables, mais pas les deux à la fois.
 
 .. _database.composite-dataset:
 
@@ -1151,7 +1157,7 @@ En utiliser le DataSet composite, nous pouvons agréger les deux fichiers de fix
             $ds1 = $this->createFlatXmlDataSet('fixture1.xml');
             $ds2 = $this->createFlatXmlDataSet('fixture2.xml');
 
-            $compositeDs = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet();
+            $compositeDs = new PHPUnit\DbUnit\DataSet\CompositeDataSet();
             $compositeDs->addDataSet($ds1);
             $compositeDs->addDataSet($ds2);
 
@@ -1183,12 +1189,14 @@ si vous ne projetez pas d'implémenter votre propre DataSet ou DataTable.
 .. code-block:: php
 
     <?php
-    interface PHPUnit_Extensions_Database_DataSet_IDataSet extends IteratorAggregate
+    namespace PHPUnit\DbUnit\DataSet;
+
+    interface IDataSet extends IteratorAggregate
     {
         public function getTableNames();
         public function getTableMetaData($tableName);
         public function getTable($tableName);
-        public function assertEquals(PHPUnit_Extensions_Database_DataSet_IDataSet $other);
+        public function assertEquals(IDataSet $other);
 
         public function getReverseIterator();
     }
@@ -1214,13 +1222,15 @@ Une table est également représentée par l'interface suivante :
 .. code-block:: php
 
     <?php
-    interface PHPUnit_Extensions_Database_DataSet_ITable
+    namespace PHPUnit\DbUnit\DataSet;
+
+    interface ITable
     {
         public function getTableMetaData();
         public function getRowCount();
         public function getValue($row, $column);
         public function getRow($row);
-        public function assertEquals(PHPUnit_Extensions_Database_DataSet_ITable $other);
+        public function assertEquals(ITable $other);
     }
     ?>
 
@@ -1230,7 +1240,7 @@ les différentes assertions de l'extension Base de données expliquées
 dans le chapitre suivant. La méthode
 ``getTableMetaData()`` doit retourner
 une implémentation de l'interface
-``PHPUnit_Extensions_Database_DataSet_ITableMetaData``
+``PHPUnit\DbUnit\DataSet\ITableMetaData``
 qui décrit la structure de la table. Elle contient des
 informations sur:
 
@@ -1263,7 +1273,9 @@ qui doit être retournée par la méthode
 .. code-block:: php
 
     <?php
-    interface PHPUnit_Extensions_Database_DB_IDatabaseConnection
+    namespace PHPUnit\DbUnit\Database;
+
+    interface Connection
     {
         public function createDataSet(Array $tableNames = NULL);
         public function createQueryTable($resultName, $sql);
@@ -1543,6 +1555,7 @@ basé sur un fichier. Il y a deux façons différentes de faire des assertions d
        <?php
        use PHPUnit\Framework\TestCase;
        use PHPUnit\DbUnit\TestCaseTrait;
+       use PHPUnit\DbUnit\DataSet\QueryDataSet;
 
        class DataSetAssertionsTest extends TestCase
        {
@@ -1550,7 +1563,7 @@ basé sur un fichier. Il y a deux façons différentes de faire des assertions d
 
            public function testManualDataSetAssertion()
            {
-               $dataSet = new PHPUnit_Extensions_Database_DataSet_QueryDataSet();
+               $dataSet = new QueryDataSet();
                $dataSet->addTable('guestbook', 'SELECT id, content, user FROM guestbook'); // additional tables
                $expectedDataSet = $this->createFlatXmlDataSet('guestbook.xml');
 
diff --git a/src/extending-phpunit.rst b/src/extending-phpunit.rst
index cd40fec8..5348436e 100644
--- a/src/extending-phpunit.rst
+++ b/src/extending-phpunit.rst
@@ -34,13 +34,15 @@ de suivre la façon dont PHPUnit implémente ses propres assertions. Comme vous
 ``assertThat()`` pour évaluation.
 
 .. code-block:: php
-    :caption: Les méthodes assertTrue() et isTrue() de la classe PHPUnit_Framework_Assert
+    :caption: Les méthodes assertTrue() et isTrue() de la classe PHPUnit\Framework\Assert
     :name: extending-phpunit.examples.Assert.php
 
     <?php
+    namespace PHPUnit\Framework;
+
     use PHPUnit\Framework\TestCase;
 
-    abstract class PHPUnit_Framework_Assert
+    abstract class Assert
     {
         // ...
 
@@ -49,7 +51,7 @@ de suivre la façon dont PHPUnit implémente ses propres assertions. Comme vous
          *
          * @param  boolean $condition
          * @param  string  $message
-         * @throws PHPUnit_Framework_AssertionFailedError
+         * @throws PHPUnit\Framework\AssertionFailedError
          */
         public static function assertTrue($condition, $message = '')
         {
@@ -59,32 +61,34 @@ de suivre la façon dont PHPUnit implémente ses propres assertions. Comme vous
         // ...
 
         /**
-         * Returns a PHPUnit_Framework_Constraint_IsTrue matcher object.
+         * Returns a PHPUnit\Framework\Constraint\IsTrue matcher object.
          *
-         * @return PHPUnit_Framework_Constraint_IsTrue
+         * @return PHPUnit\Framework\Constraint\IsTrue
          * @since  Method available since Release 3.3.0
          */
         public static function isTrue()
         {
-            return new PHPUnit_Framework_Constraint_IsTrue;
+            return new PHPUnit\Framework\Constraint\IsTrue;
         }
 
         // ...
     }?>
 
 :numref:`extending-phpunit.examples.IsTrue.php` montre comment
-``PHPUnit_Framework_Constraint_IsTrue`` étend la classe
+``PHPUnit\Framework\Constraint\IsTrue`` étend la classe
 abstraite de base pour des objets matcher (ou des contraintes),
-``PHPUnit_Framework_Constraint``.
+``PHPUnit\Framework\Constraint``.
 
 .. code-block:: php
     :caption: La classe PHPUnit_Framework_Constraint_IsTrue
     :name: extending-phpunit.examples.IsTrue.php
 
     <?php
-    use PHPUnit\Framework\TestCase;
+    namespace PHPUnit\Framework\Constraint;
+
+    use PHPUnit\Framework\Constraint;
 
-    class PHPUnit_Framework_Constraint_IsTrue extends PHPUnit_Framework_Constraint
+    class IsTrue extends Constraint
     {
         /**
          * Evaluates the constraint for parameter $other. Returns true if the
@@ -111,7 +115,7 @@ abstraite de base pour des objets matcher (ou des contraintes),
 
 L'effort d'implémentation des méthodes ``assertTrue()`` et
 ``isTrue()`` ainsi que la classe
-``PHPUnit_Framework_Constraint_IsTrue`` tire bénéfice du fait que
+``PHPUnit\Framework\Constraint\IsTrue`` tire bénéfice du fait que
 ``assertThat()`` prend automatiquement soin d'évaluer l'assertion et
 les tâches de suivi comme le décompte à des fins de statistique.
 Plus encore, la méthode ``isTrue()`` peut être utilisée comme un matcher
@@ -136,47 +140,47 @@ montre une implémentation simple de l'interface
 
     class SimpleTestListener implements TestListener
     {
-        public function addError(PHPUnit_Framework_Test $test, Exception $e, $time)
+        public function addError(PHPUnit\Framework\Test $test, Exception $e, $time)
         {
             printf("Error while running test '%s'.\n", $test->getName());
         }
 
-        public function addFailure(PHPUnit_Framework_Test $test, PHPUnit_Framework_AssertionFailedError $e, $time)
+        public function addFailure(PHPUnit\Framework\Test $test, PHPUnit_Framework_AssertionFailedError $e, $time)
         {
             printf("Test '%s' failed.\n", $test->getName());
         }
 
-        public function addIncompleteTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+        public function addIncompleteTest(PHPUnit\Framework\Test $test, Exception $e, $time)
         {
             printf("Test '%s' is incomplete.\n", $test->getName());
         }
 
-        public function addRiskyTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+        public function addRiskyTest(PHPUnit\Framework\Test $test, Exception $e, $time)
         {
             printf("Test '%s' is deemed risky.\n", $test->getName());
         }
 
-        public function addSkippedTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+        public function addSkippedTest(PHPUnit\Framework\Test $test, Exception $e, $time)
         {
             printf("Test '%s' has been skipped.\n", $test->getName());
         }
 
-        public function startTest(PHPUnit_Framework_Test $test)
+        public function startTest(PHPUnit\Framework\Test $test)
         {
             printf("Test '%s' started.\n", $test->getName());
         }
 
-        public function endTest(PHPUnit_Framework_Test $test, $time)
+        public function endTest(PHPUnit\Framework\Test $test, $time)
         {
             printf("Test '%s' ended.\n", $test->getName());
         }
 
-        public function startTestSuite(PHPUnit_Framework_TestSuite $suite)
+        public function startTestSuite(PHPUnit\Framework\TestSuite $suite)
         {
             printf("TestSuite '%s' started.\n", $suite->getName());
         }
 
-        public function endTestSuite(PHPUnit_Framework_TestSuite $suite)
+        public function endTestSuite(PHPUnit\Framework\TestSuite $suite)
         {
             printf("TestSuite '%s' ended.\n", $suite->getName());
         }
@@ -185,7 +189,7 @@ montre une implémentation simple de l'interface
 
 :numref:`extending-phpunit.examples.BaseTestListener.php`
 montre comment étendre la classe abstraite
-``PHPUnit_Framework_BaseTestListener``, qui permet de spécifier uniquement les méthodes d'interface
+``PHPUnit\Framework\BaseTestListener``, qui permet de spécifier uniquement les méthodes d'interface
 qui sont intéressantes pour votre cas d'utilisation, tout en fournissant des implémentations vides pour
 tous les autres.
 
@@ -194,11 +198,11 @@ tous les autres.
     :name: extending-phpunit.examples.BaseTestListener.php
 
     <?php
-    use PHPUnit\Framework\TestCase;
+    use PHPUnit\Framework\BaseTestListener;
 
-    class ShortTestListener extends PHPUnit_Framework_BaseTestListener
+    class ShortTestListener extends BaseTestListener
     {
-        public function endTest(PHPUnit_Framework_Test $test, $time)
+        public function endTest(PHPUnit\Framework\Test $test, $time)
         {
             printf("Test '%s' ended.\n", $test->getName());
         }
@@ -241,7 +245,7 @@ qui illustre comment écrire vos propres décorateurs de tests.
     {
         private $timesRepeat = 1;
 
-        public function __construct(PHPUnit_Framework_Test $test, $timesRepeat = 1)
+        public function __construct(PHPUnit\Framework\Test $test, $timesRepeat = 1)
         {
             parent::__construct($test);
 
@@ -273,12 +277,12 @@ qui illustre comment écrire vos propres décorateurs de tests.
 
 .. _extending-phpunit.PHPUnit_Framework_Test:
 
-Implémenter PHPUnit_Framework_Test
+Implémenter HPUnit\Framework\Test
 ##################################
 
-L'interface ``PHPUnit_Framework_Test`` est restreinte et
+L'interface ``HPUnit\Framework\Test`` est restreinte et
 facile à implémenter. Vous pouvez écrire une implémentation de
-``PHPUnit_Framework_Test`` qui est plus simple que
+``HPUnit\Framework\Test`` qui est plus simple que
 ``PHPUnit\Framework\TestCase`` et qui exécute
 *des tests dirigés par les données*, par exemple.
 
@@ -295,7 +299,7 @@ et la seconde valeur celle constatée.
     <?php
     use PHPUnit\Framework\TestCase;
 
-    class DataDrivenTest implements PHPUnit_Framework_Test
+    class DataDrivenTest implements HPUnit\Framework\Test
     {
         private $lines;
 
@@ -309,10 +313,10 @@ et la seconde valeur celle constatée.
             return 1;
         }
 
-        public function run(PHPUnit_Framework_TestResult $result = null)
+        public function run(PHPUnit\Framework\TestResult $result = null)
         {
             if ($result === null) {
-                $result = new PHPUnit_Framework_TestResult;
+                $result = new PHPUnit\Framework\TestResult;
             }
 
             foreach ($this->lines as $line) {
@@ -323,7 +327,7 @@ et la seconde valeur celle constatée.
                 list($expected, $actual) = explode(';', $line);
 
                 try {
-                    PHPUnit_Framework_Assert::assertEquals(
+                    PHPUnit\Framework\Assert::assertEquals(
                       trim($expected), trim($actual)
                     );
                 }
@@ -350,7 +354,7 @@ et la seconde valeur celle constatée.
     }
 
     $test = new DataDrivenTest('data_file.csv');
-    $result = PHPUnit_TextUI_TestRunner::run($test);
+    $result = PHPUnit\TextUI\TestRunner::run($test);
     ?>
 
 .. code-block:: bash
diff --git a/src/incomplete-and-skipped-tests.rst b/src/incomplete-and-skipped-tests.rst
index 4a3a8ce5..71f2e66d 100644
--- a/src/incomplete-and-skipped-tests.rst
+++ b/src/incomplete-and-skipped-tests.rst
@@ -33,17 +33,17 @@ comme étant réussi.
 Si nous pensons à un test réussi comme à un feu vert et à un échec de test
 comme à un feu rouge, nous avons besoin d'un feu orange additionnel pour signaler
 un test comme étant incomplet ou pas encore implémenté.
-``PHPUnit_Framework_IncompleteTest`` est une interface de marquage
+``PHPUnit\Framework\IncompleteTest`` est une interface de marquage
 pour signaler une exception qui est levée par une méthode de test comme résultat
 d'un test incomplet ou pas encore implémenté.
-``PHPUnit_Framework_IncompleteTestError`` est l'implémentation
+``PHPUnit\Framework\IncompleteTestError`` est l'implémentation
 standard de cette interface.
 
 :numref:`incomplete-and-skipped-tests.incomplete-tests.examples.SampleTest.php`
 montre une classe de cas de tests, ``SampleTest``, qui contient une unique méthode de
 test, ``testSomething()``. En appelant la méthode pratique
 ``markTestIncomplete()`` (qui lève automatiquement
-une exception ``PHPUnit_Framework_IncompleteTestError``)
+une exception ``PHPUnit\Framework\IncompleteTestError``)
 dans la méthode de test, nous marquons le test comme étant incomplet.
 
 .. code-block:: php
diff --git a/src/logging.rst b/src/logging.rst
index 223105f6..6145eb71 100644
--- a/src/logging.rst
+++ b/src/logging.rst
@@ -66,7 +66,7 @@ montre comment les échecs et les erreurs sont signalés.
                   line="6"
                   assertions="1"
                   time="0.011456">
-          <failure type="PHPUnit_Framework_ExpectationFailedException">
+          <failure type="PHPUnit\Framework\ExpectationFailedException">
     testFailure(FailureErrorTest)
     Failed asserting that &lt;integer:2&gt; matches expected value &lt;integer:1&gt;.
 
diff --git a/src/test-doubles.rst b/src/test-doubles.rst
index 79f29877..92051a6f 100644
--- a/src/test-doubles.rst
+++ b/src/test-doubles.rst
@@ -705,17 +705,17 @@ d'invocations.
 
     * - Matcher
       - Signification
-    * - ``PHPUnit_Framework_MockObject_Matcher_AnyInvokedCount any()``
+    * - ``PHPUnit\Framework\MockObject\Matcher\AnyInvokedCount any()``
       - Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est exécutée zéro ou davantage de fois.
-    * - ``PHPUnit_Framework_MockObject_Matcher_InvokedCount never()``
+    * - ``PHPUnit\Framework\MockObject\Matcher\InvokedCount never()``
       - Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué n'est jamais exécutée.
-    * - ``PHPUnit_Framework_MockObject_Matcher_InvokedAtLeastOnce atLeastOnce()``
+    * - ``PHPUnit\Framework\MockObject\Matcher\InvokedAtLeastOnce atLeastOnce()``
       - Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est exécutée au moins une fois.
-    * - ``PHPUnit_Framework_MockObject_Matcher_InvokedCount once()``
+    * - ``PHPUnit\Framework\MockObject\Matcher\InvokedCount once()``
       - Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est exécutée exactement une fois.
-    * - ``PHPUnit_Framework_MockObject_Matcher_InvokedCount exactly(int $count)``
+    * - ``PHPUnit\Framework\MockObject\Matcher\InvokedCount exactly(int $count)``
       - Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est exécutée exactement ``$count`` fois.
-    * - ``PHPUnit_Framework_MockObject_Matcher_InvokedAtIndex at(int $index)``
+    * - ``PHPUnit\Framework\MockObject\Matcher\InvokedAtIndex at(int $index)``
       - Retourne un matcher qui correspond quand la méthode pour laquelle il est évalué est invoquée pour l'``$index`` spécifié.
 
 .. admonition:: Note
diff --git a/src/textui.rst b/src/textui.rst
index 296acb04..575e014d 100644
--- a/src/textui.rst
+++ b/src/textui.rst
@@ -176,9 +176,9 @@ dans le code suivant :
     ``UnitTest`` doit soit être une classe qui hérite
     de ``PHPUnit\Framework\TestCase`` soit une classe qui
     fournit une méthode ``public static suite()`` retournant
-    un objet ``PHPUnit_Framework_Test``, par exemple
+    un objet ``PHPUnit\Framework\Test``, par exemple
     une instance de la classe
-    ``PHPUnit_Framework_TestSuite``.
+    ``PHPUnit\Framework\TestSuite``.
 
 ``phpunit UnitTest UnitTest.php``
 
@@ -443,7 +443,7 @@ dans le code suivant :
 
 ``--loader``
 
-    Indique l'implémentation de ``PHPUnit_Runner_TestSuiteLoader``
+    Indique l'implémentation de ``PHPUnit\Runner\TestSuiteLoader``
     à utiliser.
 
     Le chargeur standard de suite de tests va chercher les fichiers source
@@ -465,7 +465,7 @@ dans le code suivant :
 ``--printer``
 
     Indique l'afficheur de résultats à utiliser. Cette classe d'afficheur doit
-    hériter de ``PHPUnit_Util_Printer`` et implémenter l'interface
+    hériter de ``PHPUnit\Util\Printer`` et implémenter l'interface
     ``PHPUnit\Framework\TestListener``.
 
 ``--bootstrap``