diff --git a/contrib/kyua/cli/cmd_test.cpp b/contrib/kyua/cli/cmd_test.cpp
--- a/contrib/kyua/cli/cmd_test.cpp
+++ b/contrib/kyua/cli/cmd_test.cpp
@@ -64,11 +64,8 @@
     bool _parallel;
 
 public:
-    /// The amount of positive test results found so far.
-    unsigned long good_count;
-
-    /// The amount of negative test results found so far.
-    unsigned long bad_count;
+    /// The amount of test results per type.
+    unsigned long type_count[model::test_result_type_count];
 
     /// Constructor for the hooks.
     ///
@@ -76,10 +73,10 @@
     /// \param parallel_ True if we are executing more than one test at once.
     print_hooks(cmdline::ui* ui_, const bool parallel_) :
         _ui(ui_),
-        _parallel(parallel_),
-        good_count(0),
-        bad_count(0)
+        _parallel(parallel_)
     {
+        for (size_t i = 0; i < model::test_result_type_count; i++)
+            type_count[i] = 0;
     }
 
     /// Called when the processing of a test case begins.
@@ -116,10 +113,8 @@
         }
         _ui->out(F("%s  [%s]") % cli::format_result(result) %
             cli::format_delta(duration));
-        if (result.good())
-            good_count++;
-        else
-            bad_count++;
+
+        type_count[result.type()]++;
     }
 };
 
@@ -159,8 +154,21 @@
         kyuafile_path(cmdline), build_root_path(cmdline), results.second,
         parse_filters(cmdline.arguments()), user_config, hooks);
 
+    unsigned long total = 0;
+    unsigned long good = 0;
+    unsigned long bad = 0;
+    for (size_t i = 0; i < model::test_result_type_count; i++) {
+        const auto count = hooks.type_count[i];
+        total += count;
+        const auto type = model::test_result_types[i];
+        if (type.is_run && type.is_good)
+            good += count;
+        if (!type.is_good)
+            bad += count;
+    }
+
     int exit_code;
-    if (hooks.good_count > 0 || hooks.bad_count > 0) {
+    if (total > 0) {
         ui->out("");
         if (!results.first.empty()) {
             ui->out(F("Results file id is %s") % results.first);
@@ -168,10 +176,18 @@
         ui->out(F("Results saved to %s") % results.second);
         ui->out("");
 
-        ui->out(F("%s/%s passed (%s failed)") % hooks.good_count %
-                (hooks.good_count + hooks.bad_count) % hooks.bad_count);
+        ui->out(F("%s/%s passed (") % good % total, false);
+        for (size_t i = 0; i < model::test_result_type_count; i++) {
+            const auto type = model::test_result_types[i];
+            if (!type.is_run || !type.is_good) {
+                if (i > 0)
+                    ui->out(", ", false);
+                ui->out(F("%s %s") % hooks.type_count[i] % type.name, false);
+            }
+        }
+        ui->out(")");
 
-        exit_code = (hooks.bad_count == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+        exit_code = (bad == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
     } else {
         // TODO(jmmv): Delete created empty file; it's useless!
         if (!results.first.empty()) {
diff --git a/contrib/kyua/model/test_result.hpp b/contrib/kyua/model/test_result.hpp
--- a/contrib/kyua/model/test_result.hpp
+++ b/contrib/kyua/model/test_result.hpp
@@ -40,6 +40,23 @@
 namespace model {
 
 
+/// Total number of test result types.
+const size_t test_result_type_count = 5;
+
+
+/// Test result type metadata.
+struct test_result_type_desc {
+    enum test_result_type id;
+    std::string name;
+    bool is_run;
+    bool is_good;
+};
+
+
+/// Description of each test result type.
+extern const struct test_result_type_desc test_result_types[];
+
+
 /// Representation of a single test result.
 ///
 /// A test result is a simple pair of (type, reason).  The type indicates the
diff --git a/contrib/kyua/model/test_result.cpp b/contrib/kyua/model/test_result.cpp
--- a/contrib/kyua/model/test_result.cpp
+++ b/contrib/kyua/model/test_result.cpp
@@ -35,6 +35,15 @@
 namespace text = utils::text;
 
 
+const struct model::test_result_type_desc model::test_result_types[] = {
+    { test_result_broken,           "broken",  true,  false, },
+    { test_result_expected_failure, "xfail",   true,  true,  },
+    { test_result_failed,           "failed",  true,  false, },
+    { test_result_passed,           "passed",  true,  true,  },
+    { test_result_skipped,          "skipped", false, true,  },
+};
+
+
 /// Constructs a base result.
 ///
 /// \param type_ The type of the result.
@@ -74,17 +83,7 @@
 bool
 model::test_result::good(void) const
 {
-    switch (_type) {
-    case test_result_expected_failure:
-    case test_result_passed:
-    case test_result_skipped:
-        return true;
-
-    case test_result_broken:
-    case test_result_failed:
-        return false;
-    }
-    UNREACHABLE;
+    return test_result_types[_type].is_good;
 }