Merge branch 'gtest'

1 files changed, 248 insertions, 298 deletions

diff --git a/test/sbuild/chroot/directory.cc b/test/sbuild/chroot/directory.cc
index 9f6e4253..fccabb43 100644
--- a/test/sbuild/chroot/directory.cc
+++ b/test/sbuild/chroot/directory.cc
@@ -27,86 +27,40 @@
 #include <algorithm>
 #include <set>
 
-#include <cppunit/extensions/HelperMacros.h>
-
-using namespace CppUnit;
-
 using sbuild::_;
 
-class test_chroot_directory : public test_chroot_base
+class ChrootDirectory : public ChrootBase
 {
-  CPPUNIT_TEST_SUITE(test_chroot_directory);
-  CPPUNIT_TEST(test_directory);
-  CPPUNIT_TEST(test_chroot_type);
-  CPPUNIT_TEST(test_setup_env);
-  CPPUNIT_TEST(test_setup_env_session);
-#ifdef SBUILD_FEATURE_UNION
-  CPPUNIT_TEST(test_setup_env_union);
-  CPPUNIT_TEST(test_setup_env_session_union);
-  CPPUNIT_TEST(test_setup_env_source_union);
-  CPPUNIT_TEST(test_setup_env_session_source_union);
-#endif // SBUILD_FEATURE_UNION
-  CPPUNIT_TEST(test_setup_keyfile);
-  CPPUNIT_TEST(test_setup_keyfile_session);
-  CPPUNIT_TEST(test_setup_keyfile_root_session);
-#ifdef SBUILD_FEATURE_UNION
-  CPPUNIT_TEST(test_setup_keyfile_union);
-  CPPUNIT_TEST(test_setup_keyfile_session_union);
-  CPPUNIT_TEST(test_setup_keyfile_source_union);
-  CPPUNIT_TEST(test_setup_keyfile_session_source_union);
-#endif // SBUILD_FEATURE_UNION
-  CPPUNIT_TEST(test_session_flags);
-  CPPUNIT_TEST(test_print_details);
-  CPPUNIT_TEST(test_print_config);
-  CPPUNIT_TEST(test_run_setup_scripts);
-  CPPUNIT_TEST_SUITE_END();
-
 public:
-  test_chroot_directory():
-    test_chroot_base("directory")
+  ChrootDirectory():
+    ChrootBase("directory")
   {}
 
-  void setUp()
+  void SetUp()
   {
-    test_chroot_base::setUp();
-    CPPUNIT_ASSERT(chroot);
-    CPPUNIT_ASSERT(session);
-    CPPUNIT_ASSERT(!source);
-    CPPUNIT_ASSERT(!session_source);
+    ChrootBase::SetUp();
+    ASSERT_NE(chroot, nullptr);
+    ASSERT_NE(session, nullptr);
+    ASSERT_EQ(source, nullptr);
+    ASSERT_EQ(session_source, nullptr);
 #ifdef SBUILD_FEATURE_UNION
-    CPPUNIT_ASSERT(chroot_union);
-    CPPUNIT_ASSERT(session_union);
-    CPPUNIT_ASSERT(source_union);
-    CPPUNIT_ASSERT(session_source_union);
+    ASSERT_NE(chroot_union, nullptr);
+    ASSERT_NE(session_union, nullptr);
+    ASSERT_NE(source_union, nullptr);
+    ASSERT_NE(session_source_union, nullptr);
 #endif
   }
 
   virtual void setup_chroot_props (sbuild::chroot::chroot::chroot::ptr& chroot)
   {
-    test_chroot_base::setup_chroot_props(chroot);
+    ChrootBase::setup_chroot_props(chroot);
 
     sbuild::chroot::facet::directory::ptr dirfac = chroot->get_facet<sbuild::chroot::facet::directory>();
-    CPPUNIT_ASSERT(dirfac);
+    ASSERT_NE(dirfac, nullptr);
 
     dirfac->set_directory("/srv/chroot/example-chroot");
   }
 
-  void
-  test_directory()
-  {
-    sbuild::chroot::facet::directory::ptr dirfac = chroot->get_facet<sbuild::chroot::facet::directory>();
-    CPPUNIT_ASSERT(dirfac);
-    dirfac->set_directory("/mnt/chroot/example");
-    CPPUNIT_ASSERT(chroot->get_mount_location() == "/mnt/mount-location");
-    CPPUNIT_ASSERT(dirfac->get_directory() == "/mnt/chroot/example");
-    CPPUNIT_ASSERT(chroot->get_path() == "/mnt/mount-location");
-  }
-
-  void test_chroot_type()
-  {
-    CPPUNIT_ASSERT(chroot->get_chroot_type() == "directory");
-  }
-
   void setup_env_gen(sbuild::environment& expected)
   {
     setup_env_chroot(expected);
@@ -116,279 +70,275 @@ public:
     expected.add("CHROOT_DIRECTORY",      "/srv/chroot/example-chroot");
     expected.add("CHROOT_PATH",           "/mnt/mount-location");
   }
+};
 
-  void test_setup_env()
-  {
-    sbuild::environment expected;
-    setup_env_gen(expected);
+TEST_F(ChrootDirectory, Directory)
+{
+  sbuild::chroot::facet::directory::ptr dirfac = chroot->get_facet<sbuild::chroot::facet::directory>();
+  ASSERT_NE(dirfac, nullptr);
+  dirfac->set_directory("/mnt/chroot/example");
+  ASSERT_EQ(chroot->get_mount_location(), "/mnt/mount-location");
+  ASSERT_EQ(dirfac->get_directory(), "/mnt/chroot/example");
+  ASSERT_EQ(chroot->get_path(), "/mnt/mount-location");
+}
+
+TEST_F(ChrootDirectory, Type)
+{
+  ASSERT_EQ(chroot->get_chroot_type(), "directory");
+}
+
+TEST_F(ChrootDirectory, SetupEnv)
+{
+  sbuild::environment expected;
+  setup_env_gen(expected);
 
-    expected.add("CHROOT_SESSION_CLONE",  "false");
-    expected.add("CHROOT_SESSION_CREATE", "true");
-    expected.add("CHROOT_SESSION_PURGE",  "false");
+  expected.add("CHROOT_SESSION_CLONE",  "false");
+  expected.add("CHROOT_SESSION_CREATE", "true");
+  expected.add("CHROOT_SESSION_PURGE",  "false");
 #ifdef SBUILD_FEATURE_UNION
-    expected.add("CHROOT_UNION_TYPE",     "none");
+  expected.add("CHROOT_UNION_TYPE",     "none");
 #endif // SBUILD_FEATURE_UNION
 
-    test_chroot_base::test_setup_env(chroot, expected);
-  }
+  ChrootBase::test_setup_env(chroot, expected);
+}
 
-  void test_setup_env_session()
-  {
-    sbuild::environment expected;
-    setup_env_gen(expected);
-
-    expected.add("SESSION_ID",            "test-session-name");
-    expected.add("CHROOT_ALIAS",          "test-session-name");
-    expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(session chroot)"));
-    expected.add("CHROOT_SESSION_CLONE",  "false");
-    expected.add("CHROOT_SESSION_CREATE", "false");
-    expected.add("CHROOT_SESSION_PURGE",  "false");
+TEST_F(ChrootDirectory, SetupEnvSession)
+{
+  sbuild::environment expected;
+  setup_env_gen(expected);
+
+  expected.add("SESSION_ID",            "test-session-name");
+  expected.add("CHROOT_ALIAS",          "test-session-name");
+  expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(session chroot)"));
+  expected.add("CHROOT_SESSION_CLONE",  "false");
+  expected.add("CHROOT_SESSION_CREATE", "false");
+  expected.add("CHROOT_SESSION_PURGE",  "false");
 #ifdef SBUILD_FEATURE_UNION
-    expected.add("CHROOT_UNION_TYPE",     "none");
+  expected.add("CHROOT_UNION_TYPE",     "none");
 #endif // SBUILD_FEATURE_UNION
 
-    test_chroot_base::test_setup_env(session, expected);
-  }
+  ChrootBase::test_setup_env(session, expected);
+}
 
 #ifdef SBUILD_FEATURE_UNION
-  void test_setup_env_union()
-  {
-    sbuild::environment expected;
-    setup_env_gen(expected);
-
-    expected.add("CHROOT_SESSION_CLONE",  "true");
-    expected.add("CHROOT_SESSION_CREATE", "true");
-    expected.add("CHROOT_SESSION_PURGE",  "false");
-    expected.add("CHROOT_UNION_TYPE",     "aufs");
-    expected.add("CHROOT_UNION_MOUNT_OPTIONS",      "union-mount-options");
-    expected.add("CHROOT_UNION_OVERLAY_DIRECTORY",  "/overlay");
-    expected.add("CHROOT_UNION_UNDERLAY_DIRECTORY", "/underlay");
-
-    test_chroot_base::test_setup_env(chroot_union, expected);
-  }
-
-  void test_setup_env_session_union()
-  {
-    sbuild::environment expected;
-    setup_env_gen(expected);
-
-    expected.add("SESSION_ID",            "test-union-session-name");
-    expected.add("CHROOT_ALIAS",          "test-union-session-name");
-    expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(session chroot)"));
-    expected.add("CHROOT_SESSION_CLONE",  "false");
-    expected.add("CHROOT_SESSION_CREATE", "false");
-    expected.add("CHROOT_SESSION_PURGE",  "true");
-    expected.add("CHROOT_UNION_TYPE",     "aufs");
-    expected.add("CHROOT_UNION_MOUNT_OPTIONS",      "union-mount-options");
-    expected.add("CHROOT_UNION_OVERLAY_DIRECTORY",  "/overlay/test-union-session-name");
-    expected.add("CHROOT_UNION_UNDERLAY_DIRECTORY", "/underlay/test-union-session-name");
-
-    test_chroot_base::test_setup_env(session_union, expected);
-  }
-
-  void test_setup_env_source_union()
-  {
-    sbuild::environment expected;
-    setup_env_gen(expected);
-
-    expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(source chroot)"));
-    expected.add("CHROOT_SESSION_CLONE",  "false");
-    expected.add("CHROOT_SESSION_CREATE", "true");
-    expected.add("CHROOT_SESSION_PURGE",  "false");
-
-    test_chroot_base::test_setup_env(source_union, expected);
-  }
+TEST_F(ChrootDirectory, SetupEnvUnion)
+{
+  sbuild::environment expected;
+  setup_env_gen(expected);
+
+  expected.add("SESSION_ID",            "test-union-session-name");
+  expected.add("CHROOT_ALIAS",          "test-union-session-name");
+  expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(session chroot)"));
+  expected.add("CHROOT_SESSION_CLONE",  "false");
+  expected.add("CHROOT_SESSION_CREATE", "false");
+  expected.add("CHROOT_SESSION_PURGE",  "true");
+  expected.add("CHROOT_UNION_TYPE",     "aufs");
+  expected.add("CHROOT_UNION_MOUNT_OPTIONS",      "union-mount-options");
+  expected.add("CHROOT_UNION_OVERLAY_DIRECTORY",  "/overlay/test-union-session-name");
+  expected.add("CHROOT_UNION_UNDERLAY_DIRECTORY", "/underlay/test-union-session-name");
+
+  ChrootBase::test_setup_env(session_union, expected);
+}
+
+TEST_F(ChrootDirectory, SetupEnvSourceUnion)
+{
+  sbuild::environment expected;
+  setup_env_gen(expected);
 
-  void test_setup_env_session_source_union()
-  {
-    sbuild::environment expected;
-    setup_env_gen(expected);
+  expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(source chroot)"));
+  expected.add("CHROOT_SESSION_CLONE",  "false");
+  expected.add("CHROOT_SESSION_CREATE", "true");
+  expected.add("CHROOT_SESSION_PURGE",  "false");
 
-    expected.add("SESSION_ID",            "test-session-name");
-    expected.add("CHROOT_ALIAS",          "test-session-name");
-    expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(source chroot) (session chroot)"));
-    expected.add("CHROOT_SESSION_CLONE",  "false");
-    expected.add("CHROOT_SESSION_CREATE", "false");
-    expected.add("CHROOT_SESSION_PURGE",  "false");
+  ChrootBase::test_setup_env(source_union, expected);
+}
 
-    test_chroot_base::test_setup_env(session_source_union, expected);
-  }
+TEST_F(ChrootDirectory, SetupEnvSessionSourceUnion)
+{
+  sbuild::environment expected;
+  setup_env_gen(expected);
+
+  expected.add("SESSION_ID",            "test-session-name");
+  expected.add("CHROOT_ALIAS",          "test-session-name");
+  expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(source chroot) (session chroot)"));
+  expected.add("CHROOT_SESSION_CLONE",  "false");
+  expected.add("CHROOT_SESSION_CREATE", "false");
+  expected.add("CHROOT_SESSION_PURGE",  "false");
+
+  ChrootBase::test_setup_env(session_source_union, expected);
+}
 #endif // SBUILD_FEATURE_UNION
 
-  void test_setup_keyfile()
-  {
-    sbuild::keyfile expected;
-    const std::string group(chroot->get_name());
-    setup_keyfile_chroot(expected, group);
-    expected.set_value(group, "type", "directory");
-    expected.set_value(group, "directory", "/srv/chroot/example-chroot");
+TEST_F(ChrootDirectory, SetupKeyfile)
+{
+  sbuild::keyfile expected;
+  const std::string group(chroot->get_name());
+  setup_keyfile_chroot(expected, group);
+  expected.set_value(group, "type", "directory");
+  expected.set_value(group, "directory", "/srv/chroot/example-chroot");
 #ifdef SBUILD_FEATURE_UNION
-    setup_keyfile_union_unconfigured(expected, group);
+  setup_keyfile_union_unconfigured(expected, group);
 #endif // SBUILD_FEATURE_UNION
 
-    test_chroot_base::test_setup_keyfile
-      (chroot, expected, group);
-  }
+  ChrootBase::test_setup_keyfile
+    (chroot, expected, group);
+}
 
-  void test_setup_keyfile_session()
-  {
-    sbuild::keyfile expected;
-    const std::string group(session->get_name());
-    setup_keyfile_session(expected, group);
-    expected.set_value(group, "type", "directory");
-    expected.set_value(group, "name", "test-session-name");
-    expected.set_value(group, "selected-name", "test-session-name");
-    expected.set_value(group, "directory", "/srv/chroot/example-chroot");
-    expected.set_value(group, "mount-location", "/mnt/mount-location");
-    setup_keyfile_session_clone(expected, group);
+TEST_F(ChrootDirectory, SetupKeyfileSession)
+{
+  sbuild::keyfile expected;
+  const std::string group(session->get_name());
+  setup_keyfile_session(expected, group);
+  expected.set_value(group, "type", "directory");
+  expected.set_value(group, "name", "test-session-name");
+  expected.set_value(group, "selected-name", "test-session-name");
+  expected.set_value(group, "directory", "/srv/chroot/example-chroot");
+  expected.set_value(group, "mount-location", "/mnt/mount-location");
+  setup_keyfile_session_clone(expected, group);
 #ifdef SBUILD_FEATURE_UNION
-    setup_keyfile_union_unconfigured(expected, group);
+  setup_keyfile_union_unconfigured(expected, group);
 #endif // SBUILD_FEATURE_UNION
 
-    test_chroot_base::test_setup_keyfile
-      (session, expected, group);
-  }
+  ChrootBase::test_setup_keyfile
+    (session, expected, group);
+}
 
-  // Note, this test is unique to the directory chroot but is
-  // applicable to all.
-  void test_setup_keyfile_root_session()
-  {
-    // Create session owned by user in root-users.
-    this->session = this->chroot->clone_session("test-session-name",
-                                                "test-session-name",
-                                                "user3",
-                                                true);
-    if (this->session)
-      {
-        CPPUNIT_ASSERT(this->session->get_facet<sbuild::chroot::facet::session>());
-      }
-
-    sbuild::keyfile expected;
-    const std::string group(session->get_name());
-    setup_keyfile_session(expected, group);
-    expected.set_value(group, "users", "");
-    expected.set_value(group, "root-users", "user3");
-    expected.set_value(group, "type", "directory");
-    expected.set_value(group, "name", "test-session-name");
-    expected.set_value(group, "selected-name", "test-session-name");
-    expected.set_value(group, "directory", "/srv/chroot/example-chroot");
-    expected.set_value(group, "mount-location", "/mnt/mount-location");
-    setup_keyfile_session_clone(expected, group);
+// Note, this test is unique to the directory chroot but is
+// applicable to all.
+TEST_F(ChrootDirectory, SetupKeyfileRootSession)
+{
+  // Create session owned by user in root-users.
+  this->session = this->chroot->clone_session("test-session-name",
+                                              "test-session-name",
+                                              "user3",
+                                              true);
+  if (this->session)
+    {
+      ASSERT_NE(this->session->get_facet<sbuild::chroot::facet::session>(), nullptr);
+    }
+
+  sbuild::keyfile expected;
+  const std::string group(session->get_name());
+  setup_keyfile_session(expected, group);
+  expected.set_value(group, "users", "");
+  expected.set_value(group, "root-users", "user3");
+  expected.set_value(group, "type", "directory");
+  expected.set_value(group, "name", "test-session-name");
+  expected.set_value(group, "selected-name", "test-session-name");
+  expected.set_value(group, "directory", "/srv/chroot/example-chroot");
+  expected.set_value(group, "mount-location", "/mnt/mount-location");
+  setup_keyfile_session_clone(expected, group);
 #ifdef SBUILD_FEATURE_UNION
-    setup_keyfile_union_unconfigured(expected, group);
+  setup_keyfile_union_unconfigured(expected, group);
 #endif // SBUILD_FEATURE_UNION
 
-    test_chroot_base::test_setup_keyfile
-      (session, expected, group);
-  }
+  ChrootBase::test_setup_keyfile
+    (session, expected, group);
+}
 
 #ifdef SBUILD_FEATURE_UNION
-  void test_setup_keyfile_union()
-  {
-    sbuild::keyfile expected;
-    const std::string group(chroot_union->get_name());
-    setup_keyfile_chroot(expected, group);
-    setup_keyfile_source(expected, group);
-    expected.set_value(group, "type", "directory");
-    expected.set_value(group, "directory", "/srv/chroot/example-chroot");
-    setup_keyfile_union_configured(expected, group);
-
-    test_chroot_base::test_setup_keyfile
-      (chroot_union, expected, group);
-  }
-
-  void test_setup_keyfile_session_union()
-  {
-    sbuild::keyfile expected;
-    const std::string group(session_union->get_name());
-    setup_keyfile_session(expected, group);
-    expected.set_value(group, "type", "directory");
-    expected.set_value(group, "name", "test-union-session-name");
-    expected.set_value(group, "selected-name", "test-union-session-name");
-    expected.set_value(group, "directory", "/srv/chroot/example-chroot");
-    expected.set_value(group, "mount-location", "/mnt/mount-location");
-    setup_keyfile_session_clone(expected, group);
-    setup_keyfile_union_session(expected, group);
-
-    test_chroot_base::test_setup_keyfile
-      (session_union, expected, group);
-  }
-
-  void test_setup_keyfile_source_union()
-  {
-    sbuild::keyfile expected;
-    const std::string group(source_union->get_name());
-    setup_keyfile_chroot(expected, group);
-    setup_keyfile_source_clone(expected, group);
-    expected.set_value(group, "type", "directory");
-    expected.set_value(group, "description", chroot->get_description() + ' ' + _("(source chroot)"));
-    expected.set_value(group, "directory", "/srv/chroot/example-chroot");
-
-    test_chroot_base::test_setup_keyfile
-      (source_union, expected, group);
-  }
-
-  void test_setup_keyfile_session_source_union()
-  {
-    sbuild::keyfile expected;
-    const std::string group(source_union->get_name());
-    setup_keyfile_chroot(expected, group);
-    setup_keyfile_source_clone(expected, group);
-    expected.set_value(group, "type", "directory");
-    expected.set_value(group, "description", chroot->get_description() + ' ' + _("(source chroot)"));
-    expected.set_value(group, "directory", "/srv/chroot/example-chroot");
-    expected.set_value(group, "mount-location", "/mnt/mount-location");
-    setup_keyfile_session_source_clone(expected, group);
-
-    test_chroot_base::test_setup_keyfile
-      (session_source_union, expected, group);
-  }
+TEST_F(ChrootDirectory, SetupKeyfileUnion)
+{
+  sbuild::keyfile expected;
+  const std::string group(chroot_union->get_name());
+  setup_keyfile_chroot(expected, group);
+  setup_keyfile_source(expected, group);
+  expected.set_value(group, "type", "directory");
+  expected.set_value(group, "directory", "/srv/chroot/example-chroot");
+  setup_keyfile_union_configured(expected, group);
+
+  ChrootBase::test_setup_keyfile
+    (chroot_union, expected, group);
+}
+
+TEST_F(ChrootDirectory, SetupKeyfileSessionUnion)
+{
+  sbuild::keyfile expected;
+  const std::string group(session_union->get_name());
+  setup_keyfile_session(expected, group);
+  expected.set_value(group, "type", "directory");
+  expected.set_value(group, "name", "test-union-session-name");
+  expected.set_value(group, "selected-name", "test-union-session-name");
+  expected.set_value(group, "directory", "/srv/chroot/example-chroot");
+  expected.set_value(group, "mount-location", "/mnt/mount-location");
+  setup_keyfile_session_clone(expected, group);
+  setup_keyfile_union_session(expected, group);
+
+  ChrootBase::test_setup_keyfile
+    (session_union, expected, group);
+}
+
+TEST_F(ChrootDirectory, SetupKeyfileSourceUnion)
+{
+  sbuild::keyfile expected;
+  const std::string group(source_union->get_name());
+  setup_keyfile_chroot(expected, group);
+  setup_keyfile_source_clone(expected, group);
+  expected.set_value(group, "type", "directory");
+  expected.set_value(group, "description", chroot->get_description() + ' ' + _("(source chroot)"));
+  expected.set_value(group, "directory", "/srv/chroot/example-chroot");
+
+  ChrootBase::test_setup_keyfile
+    (source_union, expected, group);
+}
+
+TEST_F(ChrootDirectory, SetupKeyfileSessionSourceUnion)
+{
+  sbuild::keyfile expected;
+  const std::string group(source_union->get_name());
+  setup_keyfile_chroot(expected, group);
+  setup_keyfile_source_clone(expected, group);
+  expected.set_value(group, "type", "directory");
+  expected.set_value(group, "description", chroot->get_description() + ' ' + _("(source chroot)"));
+  expected.set_value(group, "directory", "/srv/chroot/example-chroot");
+  expected.set_value(group, "mount-location", "/mnt/mount-location");
+  setup_keyfile_session_source_clone(expected, group);
+
+  ChrootBase::test_setup_keyfile
+    (session_source_union, expected, group);
+}
 #endif // SBUILD_FEATURE_UNION
 
-  void test_session_flags()
-  {
-    CPPUNIT_ASSERT(chroot->get_session_flags() ==
-                   sbuild::chroot::facet::facet::SESSION_CREATE);
+TEST_F(ChrootDirectory, SessionFlags)
+{
+  ASSERT_EQ(chroot->get_session_flags(),
+            sbuild::chroot::facet::facet::SESSION_CREATE);
 
-    CPPUNIT_ASSERT(session->get_session_flags() ==
-                   sbuild::chroot::facet::facet::SESSION_NOFLAGS);
+  ASSERT_EQ(session->get_session_flags(),
+            sbuild::chroot::facet::facet::SESSION_NOFLAGS);
 
 #ifdef SBUILD_FEATURE_UNION
-    CPPUNIT_ASSERT(chroot_union->get_session_flags() ==
-                   (sbuild::chroot::facet::facet::SESSION_CREATE |
-                    sbuild::chroot::facet::facet::SESSION_CLONE));
+  ASSERT_EQ(chroot_union->get_session_flags(),
+            (sbuild::chroot::facet::facet::SESSION_CREATE |
+             sbuild::chroot::facet::facet::SESSION_CLONE));
 
-    CPPUNIT_ASSERT(session_union->get_session_flags() ==
-                   sbuild::chroot::facet::facet::SESSION_PURGE);
+  ASSERT_EQ(session_union->get_session_flags(),
+            sbuild::chroot::facet::facet::SESSION_PURGE);
 
-    CPPUNIT_ASSERT(source_union->get_session_flags() ==
-                   sbuild::chroot::facet::facet::SESSION_CREATE);
+  ASSERT_EQ(source_union->get_session_flags(),
+            sbuild::chroot::facet::facet::SESSION_CREATE);
 #endif // SBUILD_FEATURE_UNION
-  }
+}
 
-  void test_print_details()
-  {
-    std::ostringstream os;
-    os << chroot;
-    // TODO: Compare output.
-    CPPUNIT_ASSERT(!os.str().empty());
-  }
-
-  void test_print_config()
-  {
-    std::ostringstream os;
-    sbuild::keyfile config;
-    config << chroot;
-    os << sbuild::keyfile_writer(config);
-    // TODO: Compare output.
-    CPPUNIT_ASSERT(!os.str().empty());
-  }
-
-  void test_run_setup_scripts()
-  {
-    CPPUNIT_ASSERT(chroot->get_run_setup_scripts());
-  }
-
-};
+TEST_F(ChrootDirectory, PrintDetails)
+{
+  std::ostringstream os;
+  os << chroot;
+  // TODO: Compare output.
+  ASSERT_FALSE(os.str().empty());
+}
 
-CPPUNIT_TEST_SUITE_REGISTRATION(test_chroot_directory);
+TEST_F(ChrootDirectory, PrintConfig)
+{
+  std::ostringstream os;
+  sbuild::keyfile config;
+  config << chroot;
+  os << sbuild::keyfile_writer(config);
+  // TODO: Compare output.
+  ASSERT_FALSE(os.str().empty());
+}
+
+TEST_F(ChrootDirectory, RunSetupScripts)
+{
+  ASSERT_TRUE(chroot->get_run_setup_scripts());
+}