Release 1.90.6

This simulates what fprintd does

.git-blame-ignore-revs

@@ -0,0 +1,10 @@
+# The commits that did automated reformatting. You can ignore them
+# during git-blame with `--ignore-rev` or `--ignore-revs-file`.
+#
+#   $ git config --add 'blame.ignoreRevsFile' '.git-blame-ignore-revs'
+#
+
+d1fb1e26f3b79e54febc94496c1184763cf2af3d
+e4f9935706be4c0e3253afe251c182019ff7ccef
+65e602d8c72baa7020efb62d10bf28e621feb05d
+4115ae7ced77d392ee11ea55212206d9404356f0

NEWS

@@ -1,6 +1,24 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+2020-12-01: v1.90.6 release
+
+This release is primarily a bugfix release for some older issues.
+
+The major change is that fp_print_deserialize will now correctly return a
+sunken reference rather than a floating one. Most API users will have
+assumed this was true, and issues could happen at a later point.
+If any API user worked around this libfprint bug, they will now leak the
+returned print.
+
+Highlights:
+ * Object reference management fixes for FpPrint and identify
+ * Fixed issues that caused problem on non-x86 machines (#236)
+ * Fix building with older GLib versions
+ * synaptics: Support PID 00e7
+ * goodix: Fix issue with long USB packages
+
+
 2020-12-01: v1.90.5 release
 
 The 1.90.4 release caused a major regression, as it included a USB hub in

doc/libfprint-2-sections.txt

@@ -91,8 +91,6 @@ FP_TYPE_PRINT
 FpFinger
 FpPrint
 fp_print_new
-fp_print_new_from_data
-fp_print_to_data
 fp_print_get_driver
 fp_print_get_device_id
 fp_print_get_device_stored

libfprint/drivers/goodixmoc/goodix.c

@@ -350,9 +350,9 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
               gxfp_cmd_response_t *resp,
               GError              *error)
 {
+  g_autoptr(GPtrArray) templates = NULL;
   FpDevice *device = FP_DEVICE (self);
   FpPrint *print = NULL;
-  GPtrArray *templates = NULL;
   gint cnt = 0;
   gboolean find = false;
 
@@ -365,15 +365,14 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
     {
       if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
         {
-
-          templates = g_ptr_array_new_with_free_func (g_object_unref);
+          templates = g_ptr_array_sized_new (1);
           fpi_device_get_verify_data (device, &print);
-          g_ptr_array_add (templates, g_object_ref_sink (print));
-
+          g_ptr_array_add (templates, print);
         }
       else
         {
           fpi_device_get_identify_data (device, &templates);
+          g_ptr_array_ref (templates);
         }
       for (cnt = 0; cnt < templates->len; cnt++)
         {

libfprint/drivers/goodixmoc/goodix_proto.c

@@ -229,7 +229,7 @@ gx_proto_parse_header (
 
   memcpy (pheader, buffer, sizeof (pack_header));
 
-  pheader->len = GUINT16_FROM_LE (*(buffer + 4));
+  pheader->len = GUINT16_FROM_LE ( *(uint16_t *) (buffer + 4));
   pheader->len -= PACKAGE_CRC_SIZE;
 
   return 0;

libfprint/drivers/synaptics/synaptics.c

@@ -35,6 +35,7 @@ static const FpIdEntry id_table[] = {
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xFC,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC2,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE7,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 

libfprint/fp-device.c

@@ -193,7 +193,7 @@ fp_device_get_property (GObject    *object,
       break;
 
     case PROP_FINGER_STATUS:
-      g_value_set_enum (value, priv->finger_status);
+      g_value_set_flags (value, priv->finger_status);
       break;
 
     case PROP_DRIVER:
@@ -545,7 +545,7 @@ fp_device_get_finger_status (FpDevice *device)
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
 
-  g_return_val_if_fail (FP_IS_DEVICE (device), FP_SCAN_TYPE_SWIPE);
+  g_return_val_if_fail (FP_IS_DEVICE (device), FP_FINGER_STATUS_NONE);
 
   return priv->finger_status;
 }
@@ -1018,6 +1018,7 @@ fp_device_identify (FpDevice           *device,
   g_autoptr(GTask) task = NULL;
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
   FpMatchData *data;
+  int i;
 
   task = g_task_new (device, cancellable, callback, user_data);
   if (g_task_return_error_if_cancelled (task))
@@ -1042,7 +1043,13 @@ fp_device_identify (FpDevice           *device,
   maybe_cancel_on_cancelled (device, cancellable);
 
   data = g_new0 (FpMatchData, 1);
-  data->gallery = g_ptr_array_ref (prints);
+  /* We cannot store the gallery directly, because the ptr array may not own
+   * a reference to each print. Also, the caller could in principle modify the
+   * GPtrArray afterwards.
+   */
+  data->gallery = g_ptr_array_new_full (prints->len, g_object_unref);
+  for (i = 0; i < prints->len; i++)
+    g_ptr_array_add (data->gallery, g_object_ref (g_ptr_array_index (prints, i)));
   data->match_cb = match_cb;
   data->match_data = match_data;
   data->match_destroy = match_destroy;

libfprint/fp-image.c

@@ -281,7 +281,7 @@ fp_image_detect_minutiae_thread_func (GTask        *task,
   gint map_w, map_h;
   gint bw, bh, bd;
   gint r;
-  g_autofree LFSPARMS *lfsparms;
+  g_autofree LFSPARMS *lfsparms = NULL;
 
   /* Normalize the image first */
   if (data->flags & FPI_IMAGE_H_FLIPPED)

libfprint/fp-print.c

@@ -667,36 +667,25 @@ fp_print_serialize (FpPrint *print,
       for (i = 0; i < print->prints->len; i++)
         {
           struct xyt_struct *xyt = g_ptr_array_index (print->prints, i);
-          gint j;
-          gint32 *col = g_new (gint32, xyt->nrows);
 
           g_variant_builder_open (&nested, G_VARIANT_TYPE ("(aiaiai)"));
 
-          for (j = 0; j < xyt->nrows; j++)
-            col[j] = GINT32_TO_LE (xyt->xcol[j]);
           g_variant_builder_add_value (&nested,
                                        g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
-                                                                  col,
+                                                                  xyt->xcol,
                                                                   xyt->nrows,
-                                                                  sizeof (col[0])));
-
-          for (j = 0; j < xyt->nrows; j++)
-            col[j] = GINT32_TO_LE (xyt->ycol[j]);
+                                                                  sizeof (xyt->xcol[0])));
           g_variant_builder_add_value (&nested,
                                        g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
-                                                                  col,
+                                                                  xyt->ycol,
                                                                   xyt->nrows,
-                                                                  sizeof (col[0])));
-
-          for (j = 0; j < xyt->nrows; j++)
-            col[j] = GINT32_TO_LE (xyt->thetacol[j]);
+                                                                  sizeof (xyt->ycol[0])));
           g_variant_builder_add_value (&nested,
                                        g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
-                                                                  col,
+                                                                  xyt->thetacol,
                                                                   xyt->nrows,
-                                                                  sizeof (col[0])));
+                                                                  sizeof (xyt->thetacol[0])));
           g_variant_builder_close (&nested);
-          g_free (col);
         }
 
       g_variant_builder_close (&nested);
@@ -819,6 +808,7 @@ fp_print_deserialize (const guchar *data,
                              "device-id", device_id,
                              "device-stored", device_stored,
                              NULL);
+      g_object_ref_sink (result);
       fpi_print_set_type (result, FPI_PRINT_NBIS);
       for (i = 0; i < g_variant_n_children (prints); i++)
         {
@@ -868,6 +858,7 @@ fp_print_deserialize (const guchar *data,
                              "device-stored", device_stored,
                              "fpi-data", fp_data,
                              NULL);
+      g_object_ref_sink (result);
     }
   else
     {
@@ -886,8 +877,7 @@ fp_print_deserialize (const guchar *data,
   return g_steal_pointer (&result);
 
 invalid_format:
-  *error = g_error_new_literal (G_IO_ERROR,
-                                G_IO_ERROR_INVALID_DATA,
-                                "Data could not be parsed");
-  return FALSE;
+  g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
+               "Data could not be parsed");
+  return NULL;
 }

libfprint/fp-print.h

@@ -80,11 +80,6 @@ typedef enum {
 
 FpPrint *fp_print_new (FpDevice *device);
 
-FpPrint *fp_print_new_from_data (guchar *data,
-                                 gsize   length);
-gboolean fp_print_to_data (guchar **data,
-                           gsize    length);
-
 const gchar *fp_print_get_driver (FpPrint *print);
 const gchar *fp_print_get_device_id (FpPrint *print);
 FpImage     *fp_print_get_image (FpPrint *print);

libfprint/fpi-compat.h

@@ -23,6 +23,7 @@
 #if !GLIB_CHECK_VERSION (2, 57, 0)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GTypeClass, g_type_class_unref);
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GEnumClass, g_type_class_unref);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GFlagsClass, g_type_class_unref);
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GParamSpec, g_param_spec_unref);
 #else
 /* Re-define G_SOURCE_FUNC as we are technically not allowed to use it with

libfprint/fpi-device.c

@@ -1157,7 +1157,7 @@ fpi_device_identify_complete (FpDevice *device,
         }
       else
         {
-          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_INT, GINT_TO_POINTER (TRUE));
+          fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_BOOL, GUINT_TO_POINTER (TRUE));
         }
     }
   else

meson.build

@@ -1,5 +1,5 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.90.5',
+    version: '1.90.6',
     license: 'LGPLv2.1+',
     default_options: [
         'buildtype=debugoptimized',

tests/goodixmoc/custom.py

@@ -22,6 +22,13 @@ template = FPrint.Print.new(d)
 def enroll_progress(*args):
     print('enroll progress: ' + str(args))
 
+def identify_done(dev, res):
+    global identified
+    identified = True
+    identify_match, identify_print = dev.identify_finish(res)
+    print('indentification_done: ', identify_match, identify_print)
+    assert identify_match.equal(identify_print)
+
 # List, enroll, list, verify, identify, delete
 print("enrolling")
 p = d.enroll_sync(template, None, enroll_progress, None)
@@ -35,15 +42,27 @@ assert stored[0].equal(p)
 print("verifying")
 verify_res, verify_print = d.verify_sync(p)
 print("verify done")
+del p
 assert verify_res == True
-print("identifying")
-identify_match, identify_print = d.identify_sync(stored)
-print("identify done")
-assert identify_match.equal(identify_print)
+
+identified = False
+deserialized_prints = []
+for p in stored:
+    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
+    assert deserialized_prints[-1].equal(p)
+del stored
+
+print('async identifying')
+d.identify(deserialized_prints, callback=identify_done)
+del deserialized_prints
+
+while not identified:
+    ctx.iteration(True)
 
 print("deleting")
 d.delete_print_sync(p)
 print("delete done")
+
 d.close_sync()
 
 del d

tests/test-fpi-device.c

@@ -89,6 +89,29 @@ auto_reset_device_class_cleanup (FpAutoResetClass *dev_class)
 }
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpAutoResetClass, auto_reset_device_class_cleanup)
 
+
+static void
+assert_equal_galleries (GPtrArray *g1,
+                        GPtrArray *g2)
+{
+  unsigned i;
+
+  g_assert ((g1 && g2) || (!g1 || !g1));
+
+  if (g1 == g2)
+    return;
+
+  g_assert_cmpuint (g1->len, ==, g2->len);
+
+  for (i = 0; i < g1->len; i++)
+    {
+      FpPrint *print = g_ptr_array_index (g1, i);
+
+      g_assert_true (g_ptr_array_find_with_equal_func (g2, print, (GEqualFunc)
+                                                       fp_print_equal, NULL));
+    }
+}
+
 static void
 on_device_notify (FpDevice *device, GParamSpec *spec, gpointer user_data)
 {
@@ -98,6 +121,43 @@ on_device_notify (FpDevice *device, GParamSpec *spec, gpointer user_data)
   fake_dev->user_data = g_param_spec_ref (spec);
 }
 
+static FpPrint *
+make_fake_print (FpDevice *device,
+                 GVariant *print_data)
+{
+  FpPrint *enrolled_print = fp_print_new (device);
+
+  fpi_print_set_type (enrolled_print, FPI_PRINT_RAW);
+
+  if (!print_data)
+    print_data = g_variant_new_string ("Test print private data");
+  g_object_set (G_OBJECT (enrolled_print), "fpi-data", print_data, NULL);
+
+  return enrolled_print;
+}
+
+static FpPrint *
+make_fake_print_reffed (FpDevice *device,
+                        GVariant *print_data)
+{
+  return g_object_ref_sink (make_fake_print (device, print_data));
+}
+
+static GPtrArray *
+make_fake_prints_gallery (FpDevice *device,
+                          size_t    size)
+{
+  GPtrArray *array;
+  size_t i;
+
+  array = g_ptr_array_new_full (size, g_object_unref);
+
+  for (i = 0; i < size; i++)
+    g_ptr_array_add (array, make_fake_print_reffed (device, g_variant_new_uint64 (i)));
+
+  return array;
+}
+
 /* Tests */
 
 static void
@@ -205,11 +265,16 @@ test_driver_finger_status_inactive (void)
 {
   g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+  FpFingerStatusFlags finger_status;
 
   g_signal_connect (device, "notify::finger-status", G_CALLBACK (on_device_notify), NULL);
 
   g_assert_false (fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE));
   g_assert_cmpuint (fp_device_get_finger_status (device), ==, FP_FINGER_STATUS_NONE);
+
+  g_object_get (fake_dev, "finger-status", &finger_status, NULL);
+  g_assert_cmpuint (finger_status, ==, FP_FINGER_STATUS_NONE);
+
   g_assert (fake_dev->last_called_function != on_device_notify);
   g_assert_null (g_steal_pointer (&fake_dev->user_data));
 }
@@ -220,12 +285,16 @@ test_driver_finger_status_needed (void)
   g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   g_autoptr(GParamSpec) pspec = NULL;
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+  FpFingerStatusFlags finger_status;
 
   g_signal_connect (device, "notify::finger-status", G_CALLBACK (on_device_notify), NULL);
 
   g_assert_true (fpi_device_report_finger_status (device, FP_FINGER_STATUS_NEEDED));
   g_assert_cmpuint (fp_device_get_finger_status (device), ==, FP_FINGER_STATUS_NEEDED);
 
+  g_object_get (fake_dev, "finger-status", &finger_status, NULL);
+  g_assert_cmpuint (finger_status, ==, FP_FINGER_STATUS_NEEDED);
+
   g_assert (fake_dev->last_called_function == on_device_notify);
   pspec = g_steal_pointer (&fake_dev->user_data);
   g_assert_cmpstr (pspec->name, ==, "finger-status");
@@ -242,12 +311,16 @@ test_driver_finger_status_present (void)
   g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   g_autoptr(GParamSpec) pspec = NULL;
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+  FpFingerStatusFlags finger_status;
 
   g_signal_connect (device, "notify::finger-status", G_CALLBACK (on_device_notify), NULL);
 
   g_assert_true (fpi_device_report_finger_status (device, FP_FINGER_STATUS_PRESENT));
   g_assert_cmpuint (fp_device_get_finger_status (device), ==, FP_FINGER_STATUS_PRESENT);
 
+  g_object_get (fake_dev, "finger-status", &finger_status, NULL);
+  g_assert_cmpuint (finger_status, ==, FP_FINGER_STATUS_PRESENT);
+
   g_assert (fake_dev->last_called_function == on_device_notify);
   pspec = g_steal_pointer (&fake_dev->user_data);
   g_assert_cmpstr (pspec->name, ==, "finger-status");
@@ -534,12 +607,12 @@ test_driver_open (void)
 
   g_assert (fake_dev->last_called_function != dev_class->probe);
 
-  fp_device_open_sync (device, NULL, &error);
+  g_assert_true (fp_device_open_sync (device, NULL, &error));
   g_assert (fake_dev->last_called_function == dev_class->open);
   g_assert_no_error (error);
   g_assert_true (fp_device_is_open (device));
 
-  fp_device_close_sync (FP_DEVICE (device), NULL, &error);
+  g_assert_true (fp_device_close_sync (FP_DEVICE (device), NULL, &error));
   g_assert_no_error (error);
 }
 
@@ -552,7 +625,7 @@ test_driver_open_error (void)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
-  fp_device_open_sync (device, NULL, &error);
+  g_assert_false (fp_device_open_sync (device, NULL, &error));
   g_assert (fake_dev->last_called_function == dev_class->open);
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
   g_assert_false (fp_device_is_open (device));
@@ -567,7 +640,7 @@ test_driver_close (void)
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  fp_device_close_sync (device, NULL, &error);
+  g_assert_true (fp_device_close_sync (device, NULL, &error));
   g_assert (fake_dev->last_called_function == dev_class->close);
 
   g_assert_no_error (error);
@@ -583,7 +656,7 @@ test_driver_close_error (void)
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
-  fp_device_close_sync (device, NULL, &error);
+  g_assert_false (fp_device_close_sync (device, NULL, &error));
 
   g_assert (fake_dev->last_called_function == dev_class->close);
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
@@ -670,7 +743,7 @@ test_driver_enroll_error_no_print (void)
                          "*Driver passed an error but also provided a print, returning error*");
 
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
-  fake_dev->ret_print = fp_print_new (device);
+  fake_dev->ret_print = make_fake_print_reffed (device, NULL);
   g_object_add_weak_pointer (G_OBJECT (fake_dev->ret_print),
                              (gpointer) (&fake_dev->ret_print));
   out_print =
@@ -761,7 +834,8 @@ test_driver_enroll_progress_vfunc (FpDevice *device)
 
   expected_data->completed_stages =
     g_random_int_range (fp_device_get_nr_enroll_stages (device), G_MAXINT32);
-  expected_data->print = fp_print_new (device);
+  expected_data->print = make_fake_print_reffed (device,
+                                                 g_variant_new_int32 (expected_data->completed_stages));
   expected_data->error = NULL;
 
   error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
@@ -819,10 +893,11 @@ test_driver_enroll_progress (void)
 
 typedef struct
 {
-  gboolean called;
-  FpPrint *match;
-  FpPrint *print;
-  GError  *error;
+  gboolean   called;
+  FpPrint   *match;
+  FpPrint   *print;
+  GPtrArray *gallery;
+  GError    *error;
 } MatchCbData;
 
 static void
@@ -865,6 +940,14 @@ test_driver_match_cb (FpDevice *device,
 
   if (match)
     g_assert_no_error (error);
+
+  /* Compar gallery if this is an identify operation */
+  if (data->gallery)
+    {
+      FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+      g_assert_false (fake_dev->action_data == data->gallery);
+      assert_equal_galleries (fake_dev->action_data, data->gallery);
+    }
 }
 
 static void
@@ -872,7 +955,7 @@ test_driver_verify (void)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(FpPrint) enrolled_print = g_object_ref_sink (fp_print_new (device));
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
   g_autoptr(FpPrint) out_print = NULL;
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
@@ -880,9 +963,9 @@ test_driver_verify (void)
   gboolean match;
 
   fake_dev->ret_result = FPI_MATCH_SUCCESS;
-  fp_device_verify_sync (device, enrolled_print, NULL,
-                         test_driver_match_cb, match_data,
-                         &match, &out_print, &error);
+  g_assert_true (fp_device_verify_sync (device, enrolled_print, NULL,
+                                        test_driver_match_cb, match_data,
+                                        &match, &out_print, &error));
 
   g_assert (fake_dev->last_called_function == dev_class->verify);
   g_assert (fake_dev->action_data == enrolled_print);
@@ -902,17 +985,18 @@ test_driver_verify_fail (void)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(FpPrint) enrolled_print = g_object_ref_sink (fp_print_new (device));
+  g_autoptr(FpPrint) enrolled_print = NULL;
   g_autoptr(FpPrint) out_print = NULL;
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   gboolean match;
 
+  enrolled_print = make_fake_print_reffed (device, g_variant_new_uint64 (3));
   fake_dev->ret_result = FPI_MATCH_FAIL;
-  fp_device_verify_sync (device, enrolled_print, NULL,
-                         test_driver_match_cb, match_data,
-                         &match, &out_print, &error);
+  g_assert_true (fp_device_verify_sync (device, enrolled_print, NULL,
+                                        test_driver_match_cb, match_data,
+                                        &match, &out_print, &error));
 
   g_assert (fake_dev->last_called_function == dev_class->verify);
   g_assert_no_error (error);
@@ -931,7 +1015,7 @@ test_driver_verify_retry (void)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(FpPrint) enrolled_print = g_object_ref_sink (fp_print_new (device));
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
   g_autoptr(FpPrint) out_print = NULL;
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
@@ -940,9 +1024,9 @@ test_driver_verify_retry (void)
 
   fake_dev->ret_result = FPI_MATCH_ERROR;
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL);
-  fp_device_verify_sync (device, enrolled_print, NULL,
-                         test_driver_match_cb, match_data,
-                         &match, &out_print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL,
+                                         test_driver_match_cb, match_data,
+                                         &match, &out_print, &error));
 
   g_assert_true (match_data->called);
   g_assert_null (match_data->match);
@@ -959,7 +1043,7 @@ test_driver_verify_error (void)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(FpPrint) enrolled_print = g_object_ref_sink (fp_print_new (device));
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
   g_autoptr(FpPrint) out_print = NULL;
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
@@ -968,9 +1052,9 @@ test_driver_verify_error (void)
 
   fake_dev->ret_result = FPI_MATCH_ERROR;
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
-  fp_device_verify_sync (device, enrolled_print, NULL,
-                         test_driver_match_cb, match_data,
-                         &match, &out_print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL,
+                                         test_driver_match_cb, match_data,
+                                         &match, &out_print, &error));
 
   g_assert_false (match_data->called);
   g_assert_null (match_data->match);
@@ -998,16 +1082,16 @@ test_driver_verify_not_reported (void)
 
   dev_class->verify = fake_device_verify_immediate_complete;
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
-  enrolled_print = g_object_ref_sink (fp_print_new (device));
+  enrolled_print = make_fake_print_reffed (device, NULL);
 
   g_assert_true (fp_device_open_sync (device, NULL, NULL));
 
   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
                          "*reported successful verify complete*not report*result*");
 
-  fp_device_verify_sync (device, enrolled_print, NULL,
-                         NULL, NULL,
-                         NULL, NULL, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL,
+                                         NULL, NULL,
+                                         NULL, NULL, &error));
 
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
 
@@ -1041,7 +1125,7 @@ test_driver_verify_report_no_callback (void)
   dev_class->verify = fake_device_verify_complete_error;
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   fake_dev = FPI_DEVICE_FAKE (device);
-  enrolled_print = g_object_ref_sink (fp_print_new (device));
+  enrolled_print = make_fake_print_reffed (device, NULL);
 
   g_assert_true (fp_device_open_sync (device, NULL, NULL));
 
@@ -1050,9 +1134,9 @@ test_driver_verify_report_no_callback (void)
 
   fake_dev->ret_result = FPI_MATCH_ERROR;
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED);
-  fp_device_verify_sync (device, enrolled_print, NULL,
-                         test_driver_match_cb, match_data,
-                         &match, &print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL,
+                                         test_driver_match_cb, match_data,
+                                         &match, &print, &error));
 
   g_test_assert_expected_messages ();
 
@@ -1081,7 +1165,7 @@ test_driver_verify_complete_retry (void)
   dev_class->verify = fake_device_verify_complete_error;
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   fake_dev = FPI_DEVICE_FAKE (device);
-  enrolled_print = g_object_ref_sink (fp_print_new (device));
+  enrolled_print = make_fake_print_reffed (device, NULL);
 
   g_assert_true (fp_device_open_sync (device, NULL, NULL));
 
@@ -1091,8 +1175,8 @@ test_driver_verify_complete_retry (void)
   test_driver_match_data_clear (match_data);
   fake_dev->ret_result = FPI_MATCH_FAIL;
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_SHORT);
-  fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
-                         match_data, &match, &print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
+                                         match_data, &match, &print, &error));
   g_test_assert_expected_messages ();
 
   g_assert_true (error == g_steal_pointer (&fake_dev->ret_error));
@@ -1113,8 +1197,8 @@ test_driver_verify_complete_retry (void)
   fake_dev->ret_result = FPI_MATCH_FAIL;
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_SHORT);
   fake_dev->user_data = g_error_copy (fake_dev->ret_error);
-  fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
-                         match_data, &match, &print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
+                                         match_data, &match, &print, &error));
 
   g_test_assert_expected_messages ();
   g_assert_true (error != g_steal_pointer (&fake_dev->ret_error));
@@ -1135,8 +1219,8 @@ test_driver_verify_complete_retry (void)
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_SHORT);
   fake_dev->user_data = g_error_copy (fake_dev->ret_error);
 
-  fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
-                         match_data, &match, &print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
+                                         match_data, &match, &print, &error));
   g_test_assert_expected_messages ();
 
   g_assert_true (error != g_steal_pointer (&fake_dev->ret_error));
@@ -1155,8 +1239,8 @@ test_driver_verify_complete_retry (void)
   test_driver_match_data_clear (match_data);
   fake_dev->ret_result = FPI_MATCH_ERROR;
 
-  fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
-                         match_data, &match, &print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
+                                         match_data, &match, &print, &error));
   g_test_assert_expected_messages ();
 
   g_assert_true (error != g_steal_pointer (&fake_dev->ret_error));
@@ -1174,12 +1258,12 @@ test_driver_verify_complete_retry (void)
   test_driver_match_data_clear (match_data);
   fake_dev->ret_result = FPI_MATCH_ERROR;
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_SHORT);
-  fake_dev->ret_print = fp_print_new (device);
+  fake_dev->ret_print = make_fake_print (device, NULL);
   g_object_add_weak_pointer (G_OBJECT (fake_dev->ret_print),
                              (gpointer) (&fake_dev->ret_print));
 
-  fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
-                         match_data, &match, &print, &error);
+  g_assert_false (fp_device_verify_sync (device, enrolled_print, NULL, test_driver_match_cb,
+                                         match_data, &match, &print, &error));
   g_test_assert_expected_messages ();
 
   g_assert_error (error, FP_DEVICE_RETRY, FP_DEVICE_RETRY_TOO_SHORT);
@@ -1228,25 +1312,23 @@ test_driver_identify (void)
   g_autoptr(FpPrint) print = NULL;
   g_autoptr(FpPrint) matched_print = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(GPtrArray) prints = make_fake_prints_gallery (device, 500);
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *expected_matched;
-  unsigned int i;
-
-  for (i = 0; i < 500; ++i)
-    g_ptr_array_add (prints, g_object_ref_sink (fp_print_new (device)));
 
   expected_matched = g_ptr_array_index (prints, g_random_int_range (0, 499));
   fp_print_set_description (expected_matched, "fake-verified");
 
   g_assert_true (fp_device_supports_identify (device));
 
-  fake_dev->ret_print = fp_print_new (device);
-  fp_device_identify_sync (device, prints, NULL,
-                           test_driver_match_cb, match_data,
-                           &matched_print, &print, &error);
+  match_data->gallery = prints;
+
+  fake_dev->ret_print = make_fake_print (device, NULL);
+  g_assert_true (fp_device_identify_sync (device, prints, NULL,
+                                          test_driver_match_cb, match_data,
+                                          &matched_print, &print, &error));
 
   g_assert_true (match_data->called);
   g_assert_nonnull (match_data->match);
@@ -1254,7 +1336,6 @@ test_driver_identify (void)
   g_assert_true (match_data->print == print);
 
   g_assert (fake_dev->last_called_function == dev_class->identify);
-  g_assert (fake_dev->action_data == prints);
   g_assert_no_error (error);
 
   g_assert (print != NULL && print == fake_dev->ret_print);
@@ -1268,21 +1349,17 @@ test_driver_identify_fail (void)
   g_autoptr(FpPrint) print = NULL;
   g_autoptr(FpPrint) matched_print = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(GPtrArray) prints = make_fake_prints_gallery (device, 500);
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
-  unsigned int i;
-
-  for (i = 0; i < 500; ++i)
-    g_ptr_array_add (prints, g_object_ref_sink (fp_print_new (device)));
 
   g_assert_true (fp_device_supports_identify (device));
 
-  fake_dev->ret_print = fp_print_new (device);
-  fp_device_identify_sync (device, prints, NULL,
-                           test_driver_match_cb, match_data,
-                           &matched_print, &print, &error);
+  fake_dev->ret_print = make_fake_print (device, NULL);
+  g_assert_true (fp_device_identify_sync (device, prints, NULL,
+                                          test_driver_match_cb, match_data,
+                                          &matched_print, &print, &error));
 
   g_assert_true (match_data->called);
   g_assert_null (match_data->match);
@@ -1304,15 +1381,11 @@ test_driver_identify_retry (void)
   g_autoptr(FpPrint) print = NULL;
   g_autoptr(FpPrint) matched_print = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(GPtrArray) prints = make_fake_prints_gallery (device, 500);
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *expected_matched;
-  unsigned int i;
-
-  for (i = 0; i < 500; ++i)
-    g_ptr_array_add (prints, g_object_ref_sink (fp_print_new (device)));
 
   expected_matched = g_ptr_array_index (prints, g_random_int_range (0, 499));
   fp_print_set_description (expected_matched, "fake-verified");
@@ -1320,9 +1393,9 @@ test_driver_identify_retry (void)
   g_assert_true (fp_device_supports_identify (device));
 
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL);
-  fp_device_identify_sync (device, prints, NULL,
-                           test_driver_match_cb, match_data,
-                           &matched_print, &print, &error);
+  g_assert_false (fp_device_identify_sync (device, prints, NULL,
+                                           test_driver_match_cb, match_data,
+                                           &matched_print, &print, &error));
 
   g_assert_true (match_data->called);
   g_assert_null (match_data->match);
@@ -1342,15 +1415,11 @@ test_driver_identify_error (void)
   g_autoptr(FpPrint) print = NULL;
   g_autoptr(FpPrint) matched_print = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(GPtrArray) prints = make_fake_prints_gallery (device, 500);
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   FpPrint *expected_matched;
-  unsigned int i;
-
-  for (i = 0; i < 500; ++i)
-    g_ptr_array_add (prints, g_object_ref_sink (fp_print_new (device)));
 
   expected_matched = g_ptr_array_index (prints, g_random_int_range (0, 499));
   fp_print_set_description (expected_matched, "fake-verified");
@@ -1358,9 +1427,9 @@ test_driver_identify_error (void)
   g_assert_true (fp_device_supports_identify (device));
 
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_GENERAL);
-  fp_device_identify_sync (device, prints, NULL,
-                           test_driver_match_cb, match_data,
-                           &matched_print, &print, &error);
+  g_assert_false (fp_device_identify_sync (device, prints, NULL,
+                                           test_driver_match_cb, match_data,
+                                           &matched_print, &print, &error));
 
   g_assert_false (match_data->called);
   g_assert_null (match_data->match);
@@ -1384,24 +1453,21 @@ test_driver_identify_not_reported (void)
 {
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
   g_autoptr(FpAutoCloseDevice) device = NULL;
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(GPtrArray) prints = NULL;
   g_autoptr(GError) error = NULL;
-  unsigned int i;
 
   dev_class->identify = fake_device_identify_immediate_complete;
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
-
-  for (i = 0; i < 500; ++i)
-    g_ptr_array_add (prints, g_object_ref_sink (fp_print_new (device)));
+  prints = make_fake_prints_gallery (device, 500);
 
   g_assert_true (fp_device_open_sync (device, NULL, NULL));
 
   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
                          "*reported successful identify complete*not report*result*");
 
-  fp_device_identify_sync (device, prints, NULL,
-                           NULL, NULL,
-                           NULL, NULL, &error);
+  g_assert_false (fp_device_identify_sync (device, prints, NULL,
+                                           NULL, NULL,
+                                           NULL, NULL, &error));
 
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
 
@@ -1424,21 +1490,18 @@ static void
 test_driver_identify_complete_retry (void)
 {
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(GPtrArray) prints = NULL;
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
   g_autoptr(FpAutoCloseDevice) device = NULL;
   g_autoptr(FpPrint) print = NULL;
   g_autoptr(FpPrint) match = NULL;
   g_autoptr(GError) error = NULL;
   FpiDeviceFake *fake_dev;
-  int i;
 
   dev_class->identify = fake_device_identify_complete_error;
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   fake_dev = FPI_DEVICE_FAKE (device);
-
-  for (i = 0; i < 500; ++i)
-    g_ptr_array_add (prints, g_object_ref_sink (fp_print_new (device)));
+  prints = make_fake_prints_gallery (device, 500);
 
   g_assert_true (fp_device_open_sync (device, NULL, NULL));
 
@@ -1450,8 +1513,9 @@ test_driver_identify_complete_retry (void)
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_SHORT);
   fake_dev->user_data = g_error_copy (fake_dev->ret_error);
 
-  fp_device_identify_sync (device, prints, NULL, test_driver_match_cb, match_data,
-                           &match, &print, &error);
+  g_assert_false (fp_device_identify_sync (device, prints, NULL,
+                                           test_driver_match_cb, match_data,
+                                           &match, &print, &error));
   g_test_assert_expected_messages ();
 
   g_assert_true (error != g_steal_pointer (&fake_dev->ret_error));
@@ -1467,11 +1531,12 @@ test_driver_identify_complete_retry (void)
                          "*Driver reported a match to a print that was not in the gallery*");
 
   test_driver_match_data_clear (match_data);
-  fake_dev->ret_match = fp_print_new (device);
+  fake_dev->ret_match = make_fake_print_reffed (device, NULL);
   g_object_add_weak_pointer (G_OBJECT (fake_dev->ret_match),
                              (gpointer) (&fake_dev->ret_match));
-  fp_device_identify_sync (device, prints, NULL, test_driver_match_cb, match_data,
-                           &match, &print, &error);
+  g_assert_true (fp_device_identify_sync (device, prints, NULL,
+                                          test_driver_match_cb, match_data,
+                                          &match, &print, &error));
   g_test_assert_expected_messages ();
 
   g_object_unref (fake_dev->ret_match);
@@ -1490,11 +1555,12 @@ test_driver_identify_complete_retry (void)
   test_driver_match_data_clear (match_data);
   fake_dev->ret_error = fpi_device_retry_new (FP_DEVICE_RETRY_REMOVE_FINGER);
   fake_dev->ret_match = prints->pdata[0];
-  fake_dev->ret_print = fp_print_new (device);
+  fake_dev->ret_print = make_fake_print (device, NULL);
   g_object_add_weak_pointer (G_OBJECT (fake_dev->ret_print),
                              (gpointer) (&fake_dev->ret_print));
-  fp_device_identify_sync (device, prints, NULL, test_driver_match_cb, match_data,
-                           &match, &print, &error);
+  g_assert_false (fp_device_identify_sync (device, prints, NULL,
+                                           test_driver_match_cb, match_data,
+                                           &match, &print, &error));
   g_test_assert_expected_messages ();
 
   g_assert_error (error, FP_DEVICE_RETRY, FP_DEVICE_RETRY_REMOVE_FINGER);
@@ -1512,7 +1578,7 @@ test_driver_identify_report_no_callback (void)
 {
   g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
   g_autoptr(MatchCbData) match_data = g_new0 (MatchCbData, 1);
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(GPtrArray) prints = NULL;
   g_autoptr(FpAutoCloseDevice) device = NULL;
   G_GNUC_UNUSED g_autoptr(FpPrint) enrolled_print = NULL;
   g_autoptr(FpPrint) print = NULL;
@@ -1523,7 +1589,8 @@ test_driver_identify_report_no_callback (void)
   dev_class->identify = fake_device_identify_complete_error;
   device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
   fake_dev = FPI_DEVICE_FAKE (device);
-  enrolled_print = g_object_ref_sink (fp_print_new (device));
+  prints = make_fake_prints_gallery (device, 0);
+  enrolled_print = make_fake_print_reffed (device, NULL);
 
   g_assert_true (fp_device_open_sync (device, NULL, NULL));
 
@@ -1531,9 +1598,9 @@ test_driver_identify_report_no_callback (void)
                          "*Driver reported a verify error that was not in the retry domain*");
 
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED);
-  fp_device_identify_sync (device, prints, NULL,
-                           test_driver_match_cb, match_data,
-                           &match, &print, &error);
+  g_assert_false (fp_device_identify_sync (device, prints, NULL,
+                                           test_driver_match_cb, match_data,
+                                           &match, &print, &error));
 
   g_test_assert_expected_messages ();
 
@@ -1650,15 +1717,10 @@ test_driver_list (void)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
+  g_autoptr(GPtrArray) prints = make_fake_prints_gallery (device, 500);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
-  unsigned int i;
-
-  for (i = 0; i < 500; ++i)
-    g_ptr_array_add (prints, fp_print_new (device));
-
   fake_dev->ret_list = g_steal_pointer (&prints);
   prints = fp_device_list_prints_sync (device, NULL, &error);
 
@@ -1711,7 +1773,7 @@ test_driver_delete (void)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(FpPrint) enrolled_print = fp_print_new (device);
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   gboolean ret;
@@ -1728,7 +1790,7 @@ test_driver_delete_error (void)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
-  g_autoptr(FpPrint) enrolled_print = fp_print_new (device);
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
   gboolean ret;
@@ -1796,7 +1858,7 @@ test_driver_cancel (void)
   device = auto_close_fake_device_new ();
   fake_dev = FPI_DEVICE_FAKE (device);
   cancellable = g_cancellable_new ();
-  enrolled_print = fp_print_new (device);
+  enrolled_print = make_fake_print_reffed (device, NULL);
 
   fp_device_delete_print (device, enrolled_print, cancellable,
                           on_driver_cancel_delete, &completed);
@@ -1814,11 +1876,11 @@ test_driver_cancel_fail (void)
   g_autoptr(GError) error = NULL;
   g_autoptr(FpAutoCloseDevice) device = auto_close_fake_device_new ();
   g_autoptr(GCancellable) cancellable = g_cancellable_new ();
-  g_autoptr(FpPrint) enrolled_print = fp_print_new (device);
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
 
-  fp_device_delete_print_sync (device, enrolled_print, cancellable, &error);
+  g_assert_true (fp_device_delete_print_sync (device, enrolled_print, cancellable, &error));
   g_assert (fake_dev->last_called_function == dev_class->delete);
   g_cancellable_cancel (cancellable);
 
@@ -1889,7 +1951,7 @@ test_driver_action_get_cancellable_open (void)
   fake_dev = FPI_DEVICE_FAKE (device);
 
   cancellable = g_cancellable_new ();
-  fp_device_open_sync (device, cancellable, NULL);
+  g_assert_true (fp_device_open_sync (device, cancellable, NULL));
 
   g_assert (fake_dev->last_called_function == test_driver_action_get_cancellable_open_vfunc);
 }
@@ -2048,8 +2110,8 @@ static void
 test_driver_action_error_all (void)
 {
   g_autoptr(FpAutoCloseDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
-  g_autoptr(FpPrint) enrolled_print = g_object_ref_sink (fp_print_new (device));
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
+  g_autoptr(GPtrArray) prints = make_fake_prints_gallery (device, 0);
   g_autoptr(GError) error = NULL;
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev;
@@ -2120,8 +2182,8 @@ static void
 test_driver_action_error_fallback_all (void)
 {
   g_autoptr(FpAutoCloseDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
-  g_autoptr(FpPrint) enrolled_print = g_object_ref_sink (fp_print_new (device));
-  g_autoptr(GPtrArray) prints = g_ptr_array_new_with_free_func (g_object_unref);
+  g_autoptr(FpPrint) enrolled_print = make_fake_print_reffed (device, NULL);
+  g_autoptr(GPtrArray) prints = make_fake_prints_gallery (device, 0);
   g_autoptr(GError) error = NULL;
   FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
   FpiDeviceFake *fake_dev;

tests/umockdev-test.py

@@ -87,10 +87,11 @@ try:
     if os.path.exists(os.path.join(ddir, "custom.ioctl")):
         custom()
 
-except:
+except Exception as e:
     # Store created output files for inspection (in the build directory)
     outdir = os.path.join('errors', os.path.basename(ddir))
-    shutil.copytree(tmpdir, outdir)
+    shutil.copytree(tmpdir, outdir, dirs_exist_ok=True)
+    raise e
 
 finally:
     shutil.rmtree(tmpdir)