1 files changed, 216 insertions, 248 deletions

diff --git a/test/sbuild/chroot/block-device.cc b/test/sbuild/chroot/block-device.cc
index 19ac7b06..ac4e95f5 100644
--- a/test/sbuild/chroot/block-device.cc
+++ b/test/sbuild/chroot/block-device.cc
@@ -28,95 +28,43 @@
 
 #include <test/sbuild/chroot/chroot.h>
 
-#include <cppunit/extensions/HelperMacros.h>
-
-using namespace CppUnit;
-
 using sbuild::_;
 
-class test_chroot_block_device : public test_chroot_base
+class ChrootBlockDevice : public ChrootBase
 {
-  CPPUNIT_TEST_SUITE(test_chroot_block_device);
-  CPPUNIT_TEST(test_device);
-  CPPUNIT_TEST(test_mount_options);
-  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);
-#endif // SBUILD_FEATURE_UNION
-  CPPUNIT_TEST(test_setup_keyfile);
-  CPPUNIT_TEST(test_setup_keyfile_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);
-#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_block_device():
-    test_chroot_base("block-device")
+  ChrootBlockDevice():
+    ChrootBase("block-device")
   {}
 
-  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 // SBUILD_FEATURE_UNION
   }
 
   virtual void setup_chroot_props (sbuild::chroot::chroot::ptr& chroot)
   {
-    test_chroot_base::setup_chroot_props(chroot);
+    ChrootBase::setup_chroot_props(chroot);
 
     chroot->get_facet_strict<sbuild::chroot::facet::block_device>()->set_device("/dev/testdev");
 
     sbuild::chroot::facet::mountable::ptr pmnt(chroot->get_facet<sbuild::chroot::facet::mountable>());
-    CPPUNIT_ASSERT(pmnt);
+    ASSERT_NE(pmnt, nullptr);
 
     pmnt->set_mount_options("-t jfs -o quota,rw");
     pmnt->set_location("/squeeze");
   }
 
-  void
-  test_device()
-  {
-    chroot->get_facet_strict<sbuild::chroot::facet::block_device>()->set_device("/dev/some/device");
-    CPPUNIT_ASSERT(chroot->get_facet_strict<sbuild::chroot::facet::block_device>()->get_device() == "/dev/some/device");
-  }
-
-  void
-  test_mount_options()
-  {
-    sbuild::chroot::facet::mountable::ptr pmnt(chroot->get_facet<sbuild::chroot::facet::mountable>());
-    CPPUNIT_ASSERT(pmnt);
-
-    pmnt->set_mount_options("-o opt1,opt2");
-    CPPUNIT_ASSERT(pmnt->get_mount_options() == "-o opt1,opt2");
-    pmnt->set_location("/squeeze");
-    CPPUNIT_ASSERT(pmnt->get_location() == "/squeeze");
-  }
-
-  void test_chroot_type()
-  {
-    CPPUNIT_ASSERT(chroot->get_chroot_type() == "block-device");
-  }
-
   void setup_env_gen(sbuild::environment& expected)
   {
     setup_env_chroot(expected);
@@ -129,216 +77,236 @@ public:
     expected.add("CHROOT_MOUNT_OPTIONS",  "-t jfs -o quota,rw");
   }
 
-  void test_setup_env()
+  void setup_keyfile_block(sbuild::keyfile &expected, std::string group)
   {
-    sbuild::environment expected;
-    setup_env_gen(expected);
+    expected.set_value(group, "type", "block-device");
+    expected.set_value(group, "device", "/dev/testdev");
+    expected.set_value(group, "location", "/squeeze");
+    expected.set_value(group, "mount-options", "-t jfs -o quota,rw");
+  }
+};
+
+TEST_F(ChrootBlockDevice, Device)
+{
+  chroot->get_facet_strict<sbuild::chroot::facet::block_device>()->set_device("/dev/some/device");
+  ASSERT_EQ(chroot->get_facet_strict<sbuild::chroot::facet::block_device>()->get_device(),
+            "/dev/some/device");
+}
+
+TEST_F(ChrootBlockDevice, MountOptions)
+{
+  sbuild::chroot::facet::mountable::ptr pmnt(chroot->get_facet<sbuild::chroot::facet::mountable>());
+  ASSERT_NE(pmnt, nullptr);
+
+  pmnt->set_mount_options("-o opt1,opt2");
+  ASSERT_EQ(pmnt->get_mount_options(), "-o opt1,opt2");
+  pmnt->set_location("/squeeze");
+  ASSERT_EQ(pmnt->get_location(), "/squeeze");
+}
+
+TEST_F(ChrootBlockDevice, Type)
+{
+  ASSERT_EQ(chroot->get_chroot_type(), "block-device");
+}
+
+TEST_F(ChrootBlockDevice, 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");
-    expected.add("CHROOT_MOUNT_DEVICE",   "/dev/testdev");
+TEST_F(ChrootBlockDevice, 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");
+  expected.add("CHROOT_MOUNT_DEVICE",   "/dev/testdev");
 #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_MOUNT_DEVICE",   "/dev/testdev");
-    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);
+TEST_F(ChrootBlockDevice, SetupEnvUnion)
+{
+  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");
+
+  ChrootBase::test_setup_env(chroot_union, expected);
+}
+
+TEST_F(ChrootBlockDevice, SetupEnvSessionUnion)
+{
+  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_MOUNT_DEVICE",   "/dev/testdev");
+  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(ChrootBlockDevice, SetupEnvSourceUnion)
+{
+  sbuild::environment expected;
+  setup_env_gen(expected);
 
-    expected.add("CHROOT_NAME",           "test-name");
-    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("CHROOT_NAME",           "test-name");
+  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);
-  }
+  ChrootBase::test_setup_env(source_union, expected);
+}
 #endif // SBUILD_FEATURE_UNION
 
-  void setup_keyfile_block(sbuild::keyfile &expected, std::string group)
-  {
-    expected.set_value(group, "type", "block-device");
-    expected.set_value(group, "device", "/dev/testdev");
-    expected.set_value(group, "location", "/squeeze");
-    expected.set_value(group, "mount-options", "-t jfs -o quota,rw");
-  }
-
-  void test_setup_keyfile()
-  {
-    sbuild::keyfile expected;
-    std::string group = chroot->get_name();
-    setup_keyfile_chroot(expected, group);
-    setup_keyfile_block(expected, group);
+TEST_F(ChrootBlockDevice, SetupKeyfile)
+{
+  sbuild::keyfile expected;
+  std::string group = chroot->get_name();
+  setup_keyfile_chroot(expected, group);
+  setup_keyfile_block(expected, group);
 #ifdef SBUILD_FEATURE_UNION
-    setup_keyfile_union_unconfigured(expected, group);
+  setup_keyfile_union_unconfigured(expected, group);
 #endif
-    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);
-    setup_keyfile_block(expected, group);
-    expected.set_value(group, "name", "test-session-name");
-    expected.set_value(group, "selected-name", "test-session-name");
-    expected.set_value(group, "mount-device", "/dev/testdev");
-    expected.set_value(group, "mount-location", "/mnt/mount-location");
-    setup_keyfile_session_clone(expected, group);
+TEST_F(ChrootBlockDevice, SetupKeyfileSession)
+{
+  sbuild::keyfile expected;
+  const std::string group(session->get_name());
+  setup_keyfile_session(expected, group);
+  setup_keyfile_block(expected, group);
+  expected.set_value(group, "name", "test-session-name");
+  expected.set_value(group, "selected-name", "test-session-name");
+  expected.set_value(group, "mount-device", "/dev/testdev");
+  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
 
-    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_union_configured(expected, group);
-    setup_keyfile_chroot(expected, group);
-    setup_keyfile_source(expected, group);
-    setup_keyfile_block(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);
-    setup_keyfile_block(expected, group);
-    expected.set_value(group, "name", "test-union-session-name");
-    expected.set_value(group, "selected-name", "test-union-session-name");
-    expected.set_value(group, "mount-device", "/dev/testdev");
-    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);
-    setup_keyfile_block(expected, group);
-    expected.set_value(group, "description", chroot->get_description() + ' ' + _("(source chroot)"));
-
-    test_chroot_base::test_setup_keyfile
-      (source_union, expected, group);
-  }
+TEST_F(ChrootBlockDevice, SetupKeyfileUnion)
+{
+  sbuild::keyfile expected;
+  const std::string group(chroot_union->get_name());
+  setup_keyfile_union_configured(expected, group);
+  setup_keyfile_chroot(expected, group);
+  setup_keyfile_source(expected, group);
+  setup_keyfile_block(expected, group);
+
+  ChrootBase::test_setup_keyfile
+    (chroot_union, expected, group);
+}
+
+TEST_F(ChrootBlockDevice, SetupKeyfileSessionUnion)
+{
+  sbuild::keyfile expected;
+  const std::string group(session_union->get_name());
+  setup_keyfile_session(expected, group);
+  setup_keyfile_block(expected, group);
+  expected.set_value(group, "name", "test-union-session-name");
+  expected.set_value(group, "selected-name", "test-union-session-name");
+  expected.set_value(group, "mount-device", "/dev/testdev");
+  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(ChrootBlockDevice, SetupKeyfileSourceUnion)
+{
+  sbuild::keyfile expected;
+  const std::string group(source_union->get_name());
+  setup_keyfile_chroot(expected, group);
+  setup_keyfile_source_clone(expected, group);
+  setup_keyfile_block(expected, group);
+  expected.set_value(group, "description", chroot->get_description() + ' ' + _("(source chroot)"));
+
+  ChrootBase::test_setup_keyfile
+    (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(ChrootBlockDevice, 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(ChrootBlockDevice, PrintDetails)
+{
+  std::ostringstream os;
+  os << chroot;
+  // TODO: Compare output.
+  ASSERT_FALSE(os.str().empty());
+}
 
-CPPUNIT_TEST_SUITE_REGISTRATION(test_chroot_block_device);
+TEST_F(ChrootBlockDevice, PrintConfig)
+{
+  std::ostringstream os;
+  sbuild::keyfile config;
+  config << chroot;
+  os << sbuild::keyfile_writer(config);
+  // TODO: Compare output.
+  ASSERT_FALSE(os.str().empty());
+}
+
+TEST_F(ChrootBlockDevice, RunSetupScripts)
+{
+  ASSERT_TRUE(chroot->get_run_setup_scripts());
+}