Merge ~paelzer/ubuntu/+source/open-iscsi:lp-1919461-test-python3-compat into ubuntu/+source/open-iscsi:ubuntu/hirsute-devel

[Christian Ehrhardt ]

[Christian Ehrhardt  (paelzer)]

PPA: https://launchpad.net/~ci-train-ppa-service/+archive/ubuntu/4495/
Bileto: https://bileto.ubuntu.com/#/ticket/4495

Tests are all good on all architectures.

01ee4f9... by Christian Ehrhardt  on 2021-03-22

changelog: Add patches from upstream [from Debian 2.1.3-2]

Signed-off-by: Christian Ehrhardt <email address hidden>

[Christian Ehrhardt  (paelzer)]

Hmm, I've just seen open-iscsi in the merge opportunities.
I wonder if we should add this to my upload ...

   * [efb5512] Add patches from upstream:
     Fix memory leak in iscsiadm, Fix iscsiadm segfault when exiting, and
     Fix iscsistart login issue when target is delayed. The last one should
     fix #980085. (Closes: #980085)

I think we should, .... adding ...
Uploaded 2.1.3-1ubuntu5~ppa3 to the PPA and pushed to the MP

[Dimitri John Ledkov (xnox)]

I would not have bothered with keeping python2 compat, and simply did python3-only. Even to the point of SRUing python3 autopkgtest back.

I.e. no fallbacks to old python api, no imports from __future__.

But I guess it does help with testing to ensure that 2&3 still work on i.e. focal.

[Utkarsh Gupta (utkarsh)]

* Changelog:
  - [√] changelog entry correct version and targeted codename
  - [?] changelog entries correct

I get:
W: libopeniscsiusr0.2.0: debian-changelog-line-too-long line 8
...maybe move the link to the next line?

Another minor/trivial comment here:
The last line of the d/ch entry says "fix #980085. (Closes: #980085)" which doesn't really help me understand what the change was in the first glance. I understand that this was exactly the commit message/header in Debian, but maybe worth adding a one-liner about what this is about?
This would help others to quickly see what changed or fix from just reading the d/ch entry. Anyway, this is just me so please feel free to ignore this.

  - [√] update-maintainer has been run

* Actual changes:
  - [-] no further upstream version to consider
  - [√] debian changes look safe

* New Delta:
  - [√] patches match what was proposed upstream
  - [√] patches correctly included in debian/patches/series
  - [√] patches have correct DEP3 metadata

No "Origin" field but that's okay since these changes are actually a part of Debian so this part of the delta can be very easily dropped. So all good here.

* Build/Test:
  - [√] build is ok
  - [√] verified PPA package installs/uninstalls
  - [√] autopkgtest against the PPA package passes

Ran autopkgtest against what's in the archive, which failed, as the bug report correctly highlights and then ran autopkgtest against this branch, which passed, as intended, which correctly fixes the issue.
cf: autopkgtest [17:32:52]: @@@@@@@@@@@@@@@@@@@@ summary
install PASS
testsuite PASS
nested PASS

So besides the trivial comments above, this looks good! \o/

[Christian Ehrhardt  (paelzer)]

Thanks for the catch ont he CL, auto-log at fail.
Fixed

I added a hint what #980085 is - that was worth to ask for

For the patches yeah, since they came in the "upstream" subdir and I mentioned in the CL where they came from I thought that I can keep them as-is. Then it also will be easy to compare when dropping them on the next merge.

Thank you Utkarsh, combined with my tests that is enough for me to upload

review: Approve

[Christian Ehrhardt  (paelzer)]

To ssh://git.launchpad.net/~usd-import-team/ubuntu/+source/open-iscsi
 * [new tag] upload/2.1.3-1ubuntu5 -> upload/2.1.3-1ubuntu5

Uploading to ubuntu (via ftp to upload.ubuntu.com):
  Uploading open-iscsi_2.1.3-1ubuntu5.dsc: done.
  Uploading open-iscsi_2.1.3-1ubuntu5.debian.tar.xz: done.
  Uploading open-iscsi_2.1.3-1ubuntu5_source.buildinfo: done.
  Uploading open-iscsi_2.1.3-1ubuntu5_source.changes: done.
Successfully uploaded packages.

[Bryce Harrington (bryce)]

Migrated
  - Current Version: 2.1.3-1ubuntu5
  - Proposed Version: None
  - Debian Version: 2.1.3-1ubuntu5
  - New Version: 2.1.3-1ubuntu5

diff --git a/debian/changelog b/debian/changelog
index 0b9f498..827c0eb 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,21 @@
+open-iscsi (2.1.3-1ubuntu5) hirsute; urgency=medium
+
+  * make d/t/testuite python3 compatible (LP: #1919461)
+    - backport changes from qa-regression-testing since we diverged
+      - various tests: make py3 compliant, fix formatting a bit
+      - tests: convert deprecated assertEquals() to assertEqual()
+      - Remove all references to python-utils
+    - d/t/testlib.py: update to last state from git+ssh://git.launchpad.net/qa-regression-testing
+    - d/t/{control,testsuite}: bump to use python3
+    - d/t/test-open-iscsi.py: switch shebang to python3
+    - d/t/test-open-iscsi.py: adapt to updated testlib
+  * Add patches from upstream [this is from Debian upload 2.1.3-2]:
+    - Fix memory leak in iscsiadm, Fix iscsiadm segfault when exiting, and
+    - Fix iscsistart login issue when target is delayed. The last one should
+    - fix #980085. (Closes: #980085)
+
+ -- Christian Ehrhardt <[e-mail]>  Thu, 18 Mar 2021 09:44:07 +0100
+
 open-iscsi (2.1.3-1ubuntu4) hirsute; urgency=medium
 
   * Rebuild again so s390x pick up the right debhelper
diff --git a/debian/patches/series b/debian/patches/series
index 909a8f3..8260850 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1 +1,4 @@
+upstream/0001-iscsiadm-Fix-memory-leak-in-iscsiadm.patch
+upstream/0002-Fix-iscsiadm-segfault-when-exiting.patch
+upstream/0003-Fix-iscsistart-login-issue-when-target-is-delayed.patch
 lp1755858-default-iscsid_conf-to-iscsid_socket.patch
diff --git a/debian/patches/upstream/0001-iscsiadm-Fix-memory-leak-in-iscsiadm.patch b/debian/patches/upstream/0001-iscsiadm-Fix-memory-leak-in-iscsiadm.patch
 new file mode 100644
index 0000000..dda9a00
--- /dev/null
+++ b/debian/patches/upstream/0001-iscsiadm-Fix-memory-leak-in-iscsiadm.patch
@@ -0,0 +1,156 @@
+From: Wenchao Hao <[e-mail]>
+Date: Tue, 29 Dec 2020 20:30:25 +0800
+Subject: iscsiadm: Fix memory leak in iscsiadm
+
+Memory allocated by iscsi_context_new() would not be freed if
+error occurred during parameters parser stage and goto free_ifaces
+is used to jump to resource clean.
+
+Since all resource clean is performed after verified, so change
+all goto free_ifaces to goto out where handles resource better.
+
+Signed-off-by: Wenchao Hao <[e-mail]>
+---
+ libopeniscsiusr/context.c |  6 +++++-
+ usr/iscsiadm.c            | 27 +++++++++++++--------------
+ 2 files changed, 18 insertions(+), 15 deletions(-)
+
+diff --git a/libopeniscsiusr/context.c b/libopeniscsiusr/context.c
+index fe92155..c5e869f 100644
+--- a/libopeniscsiusr/context.c
++++ b/libopeniscsiusr/context.c
+@@ -55,8 +55,12 @@ struct iscsi_context *iscsi_context_new(void)
+ 
+ void iscsi_context_free(struct iscsi_context *ctx)
+ {
+-	if (ctx != NULL)
++	if (ctx == NULL)
++		return;
++
++	if (ctx->db)
+ 		_idbm_free(ctx->db);
++
+ 	free(ctx);
+ }
+ 
+diff --git a/usr/iscsiadm.c b/usr/iscsiadm.c
+index ea1643b..3987168 100644
+--- a/usr/iscsiadm.c
++++ b/usr/iscsiadm.c
+@@ -3627,7 +3627,7 @@ main(int argc, char **argv)
+ 					  "Priority must be greater than or "
+ 					  "equal to zero.", killiscsid);
+ 				rc = ISCSI_ERR_INVAL;
+-				goto free_ifaces;
++				goto out;
+ 			}
+ 			break;
+ 		case 't':
+@@ -3639,7 +3639,7 @@ main(int argc, char **argv)
+ 				log_error("can not recognize operation: '%s'",
+ 					optarg);
+ 				rc = ISCSI_ERR_INVAL;
+-				goto free_ifaces;
++				goto out;
+ 			}
+ 			break;
+ 		case 'n':
+@@ -3651,7 +3651,7 @@ main(int argc, char **argv)
+ 		case 'H':
+ 			host_no = parse_host_info(optarg, &rc);
+ 			if (rc)
+-				goto free_ifaces;
++				goto out;
+ 			break;
+ 		case 'r':
+ 			sid = iscsi_sysfs_get_sid_from_path(optarg);
+@@ -3659,7 +3659,7 @@ main(int argc, char **argv)
+ 				log_error("invalid sid '%s'",
+ 					  optarg);
+ 				rc = ISCSI_ERR_INVAL;
+-				goto free_ifaces;
++				goto out;
+ 			}
+ 			break;
+ 		case 'R':
+@@ -3710,7 +3710,7 @@ main(int argc, char **argv)
+ 			mode = str_to_mode(optarg);
+ 			rc = verify_mode_params(argc, argv, mode);
+ 			if (ISCSI_SUCCESS != rc)
+-				goto free_ifaces;
++				goto out;
+ 			break;
+ 		case 'C':
+ 			sub_mode = str_to_submode(optarg);
+@@ -3739,11 +3739,11 @@ main(int argc, char **argv)
+ 				printf("Invalid iface name %s. Must be from "
+ 					"1 to %d characters.\n",
+ 					optarg, ISCSI_MAX_IFACE_LEN - 1);
+-				goto free_ifaces;
++				goto out;
+ 			} else if (!iface || rc) {
+ 				printf("Could not add iface %s.", optarg);
+ 				rc = ISCSI_ERR_INVAL;
+-				goto free_ifaces;
++				goto out;
+ 			}
+ 
+ 			list_add_tail(&iface->list, &ifaces);
+@@ -3760,7 +3760,7 @@ main(int argc, char **argv)
+ 				log_error("Invalid index %s. %s.",
+ 					  optarg, strerror(errno));
+ 				rc = ISCSI_ERR_INVAL;
+-				goto free_ifaces;
++				goto out;
+ 			}
+ 			break;
+ 		case 'A':
+@@ -3778,7 +3778,7 @@ main(int argc, char **argv)
+ 			if (!param) {
+ 				log_error("Cannot allocate memory for params.");
+ 				rc = ISCSI_ERR_NOMEM;
+-				goto free_ifaces;
++				goto out;
+ 			}
+ 			list_add_tail(&param->list, &params);
+ 			name = NULL;
+@@ -3789,12 +3789,12 @@ main(int argc, char **argv)
+ 	if (optopt) {
+ 		log_error("unrecognized character '%c'", optopt);
+ 		rc = ISCSI_ERR_INVAL;
+-		goto free_ifaces;
++		goto out;
+ 	}
+ 
+ 	if (killiscsid >= 0) {
+ 		kill_iscsid(killiscsid, timeout);
+-		goto free_ifaces;
++		goto out;
+ 	}
+ 
+ 	if (mode < 0)
+@@ -3802,14 +3802,14 @@ main(int argc, char **argv)
+ 
+ 	if (mode == MODE_FW) {
+ 		rc = exec_fw_op(NULL, NULL, info_level, do_login, op);
+-		goto free_ifaces;
++		goto out;
+ 	}
+ 
+ 	increase_max_files();
+ 	if (idbm_init(get_config_file)) {
+ 		log_warning("exiting due to idbm configuration error");
+ 		rc = ISCSI_ERR_IDBM;
+-		goto free_ifaces;
++		goto out;
+ 	}
+ 
+ 	switch (mode) {
+@@ -4070,7 +4070,6 @@ out:
+ 		free(rec);
+ 	iscsi_sessions_free(ses, se_count);
+ 	idbm_terminate();
+-free_ifaces:
+ 	list_for_each_entry_safe(iface, tmp, &ifaces, list) {
+ 		list_del(&iface->list);
+ 		free(iface);
diff --git a/debian/patches/upstream/0002-Fix-iscsiadm-segfault-when-exiting.patch b/debian/patches/upstream/0002-Fix-iscsiadm-segfault-when-exiting.patch
 new file mode 100644
index 0000000..183bdaa
--- /dev/null
+++ b/debian/patches/upstream/0002-Fix-iscsiadm-segfault-when-exiting.patch
@@ -0,0 +1,47 @@
+From: Lee Duncan <[e-mail]>
+Date: Tue, 26 Jan 2021 11:48:32 -0800
+Subject: Fix iscsiadm segfault when exiting
+
+Commit b532ad67d495d added some cleanup code
+to iscsiadm right before it exits, but it
+used a list_for_each_entry() to iterate through
+a list was being deleted, when it should use
+list_for_each_entry_safe().
+
+Fixes: b532ad67d495d
+---
+ usr/iscsiadm.c | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/usr/iscsiadm.c b/usr/iscsiadm.c
+index 3987168..bb6821d 100644
+--- a/usr/iscsiadm.c
++++ b/usr/iscsiadm.c
+@@ -3582,11 +3582,11 @@ main(int argc, char **argv)
+ 	struct sigaction sa_old;
+ 	struct sigaction sa_new;
+ 	LIST_HEAD(ifaces);
+-	struct iface_rec *iface = NULL, *tmp;
++	struct iface_rec *iface = NULL, *tmp_iface;
+ 	struct node_rec *rec = NULL;
+ 	uint32_t host_no =  MAX_HOST_NO + 1;
+ 	uint64_t index = ULLONG_MAX;
+-	struct user_param *param;
++	struct user_param *param, *tmp_param;
+ 	LIST_HEAD(params);
+ 	struct iscsi_context *ctx = NULL;
+ 	int librc = LIBISCSI_OK;
+@@ -4070,11 +4070,11 @@ out:
+ 		free(rec);
+ 	iscsi_sessions_free(ses, se_count);
+ 	idbm_terminate();
+-	list_for_each_entry_safe(iface, tmp, &ifaces, list) {
++	list_for_each_entry_safe(iface, tmp_iface, &ifaces, list) {
+ 		list_del(&iface->list);
+ 		free(iface);
+ 	}
+-	list_for_each_entry(param, &params, list) {
++	list_for_each_entry_safe(param, tmp_param, &params, list) {
+ 		list_del(&param->list);
+ 		idbm_free_user_param(param);
+ 	}
diff --git a/debian/patches/upstream/0003-Fix-iscsistart-login-issue-when-target-is-delayed.patch b/debian/patches/upstream/0003-Fix-iscsistart-login-issue-when-target-is-delayed.patch
 new file mode 100644
index 0000000..6602f3a
--- /dev/null
+++ b/debian/patches/upstream/0003-Fix-iscsistart-login-issue-when-target-is-delayed.patch
@@ -0,0 +1,58 @@
+From: Lee Duncan <[e-mail]>
+Date: Thu, 4 Feb 2021 11:45:00 -0800
+Subject: Fix iscsistart login issue when target is delayed.
+
+Earlier commit 9258c8eae046 changed the return value fron
+iscsid_response() from ISCSI_ERR_ISCSID_NOTCONN to
+ISCSI_ERR_SESSION_NOT_CONNECTED in the case where no iscsi response is
+received when expected.
+
+This effected the login code in iscsistart when the target is not
+completely ready at iscsi login time. This commit updates iscsistart
+to expect the new error code, but fixing this uncovered another issue,
+causing iscsistart logins to continue to fail if the target returned its
+login response too slowly.
+
+This commit ups the timeout time for iscsistart logins from 1 second per
+try to 10 seconds per try. This is perhaps excessive, and a shorter
+delay would be more appropriate, but the retry/nanosleep logic in
+iscsistart meant to retry the login in such cases seems problematic in
+this case, since retrying the 2nd time returns "session already exists",
+and most iscsistart clients aren't prepared for the command to return a
+non-zero return value.
+---
+ usr/iscsistart.c | 17 +++++++++++++++--
+ 1 file changed, 15 insertions(+), 2 deletions(-)
+
+diff --git a/usr/iscsistart.c b/usr/iscsistart.c
+index 73991b3..755489f 100644
+--- a/usr/iscsistart.c
++++ b/usr/iscsistart.c
+@@ -241,12 +241,25 @@ static int login_session(struct node_rec *rec)
+ 	/*
+ 	 * Need to handle race where iscsid proc is starting up while we are
+ 	 * trying to connect. Retry with exponential backoff, start from 50 ms.
++	 *
++	 * NOTE: another race condition can occur if the system is just coming
++	 * up, where our login request will be sent, but the login response
++	 * takes a while. In such a case, if we timeout and give up, the
++	 * login response may still show up once we give up, in which case
++	 * it seems to get iscsistart into a state where it cannot try to
++	 * login again because it thinks there's already a session. So make
++	 * sure our timeout is long enough, on each try, to give the response
++	 * a chance to show up. The old value of 1 second was not enough,
++	 * so we multiply that by 10, which seems reasonable for initial
++	 * login.
+ 	 */
+ 	for (msec = 50; msec <= 15000; msec <<= 1) {
+-		rc = iscsid_exec_req(&req, &rsp, 0, ISCSID_REQ_TIMEOUT);
++		int tmo = ISCSID_REQ_TIMEOUT * 10;
++
++		rc = iscsid_exec_req(&req, &rsp, 0, tmo);
+ 		if (rc == 0) {
+ 			return rc;
+-		} else if (rc == ISCSI_ERR_ISCSID_NOTCONN) {
++		} else if (rc == ISCSI_ERR_SESSION_NOT_CONNECTED) {
+ 			ts.tv_sec = msec / 1000;
+ 			ts.tv_nsec = (msec % 1000) * 1000000L;
+ 
diff --git a/debian/tests/control b/debian/tests/control
index 026cfc9..0fcfd11 100644
--- a/debian/tests/control
+++ b/debian/tests/control
@@ -3,7 +3,7 @@ Restrictions: needs-root, isolation-machine, breaks-testbed
 
 Tests: testsuite
 Restrictions: needs-root isolation-machine breaks-testbed
-Depends: open-iscsi, python2, tgt, qemu-system, ubuntu-cloudimage-keyring, simplestreams, python-netifaces, distro-info, cloud-image-utils, dctrl-tools, rsync
+Depends: open-iscsi, python3, tgt, qemu-system, ubuntu-cloudimage-keyring, simplestreams, python3-netifaces, distro-info, cloud-image-utils, dctrl-tools, rsync
 
 Tests: nested
 Restrictions: needs-root, isolation-machine, breaks-testbed, allow-stderr
diff --git a/debian/tests/test-open-iscsi.py b/debian/tests/test-open-iscsi.py
index cce02fb..1ad8b4f 100644
--- a/debian/tests/test-open-iscsi.py
+++ b/debian/tests/test-open-iscsi.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/python3
 #
 #    test-open-iscsi.py quality assurance test script for open-iscsi
 #    Copyright (C) 2011 Canonical Ltd.
@@ -32,16 +32,17 @@
     alter the machine. You have been warned.
 
     How to run in a clean VM:
-    $ sudo apt-get -y install python-unit <QRT-Packages> && sudo ./test-PKG.py -v'
+    $ sudo apt-get -y install <QRT-Packages> && sudo ./test-PKG.py -v'
 
     How to run in a clean schroot named 'lucid':
-    $ schroot -c lucid -u root -- sh -c 'apt-get -y install python-unit <QRT-Packages> && ./test-PKG.py -v'
+    $ schroot -c lucid -u root -- sh -c 'apt-get -y install <QRT-Packages> && ./test-PKG.py -v'
 
 
     NOTES:
     - currently only tested on Ubuntu 8.04
 '''
 
+from __future__ import print_function
 
 from netifaces import gateways, AF_INET
 import unittest, subprocess, sys, os, glob
@@ -120,7 +121,7 @@ try:
 except ImportError:
     class PrivateOpenIscsiTest(object):
         '''Empty class'''
-    print >>sys.stdout, "Skipping private tests"
+    print("Skipping private tests", file=sys.stdout)
 
 class OpenIscsiTest(testlib.TestlibCase, PrivateOpenIscsiTest):
     '''Test my thing.'''
@@ -129,7 +130,7 @@ class OpenIscsiTest(testlib.TestlibCase, PrivateOpenIscsiTest):
         '''Set up prior to each test_* function'''
         self.pidfile = "/var/run/iscsid.pid"
         self.exe = "/sbin/iscsid"
-        self.daemon = testlib.TestDaemon(["service", "open-iscsi"])
+        self.daemon = testlib.TestDaemon("open-iscsi")
         self.initiatorname_iscsi = '/etc/iscsi/initiatorname.iscsi'
         self.iscsid_conf = '/etc/iscsi/iscsid.conf'
 
@@ -189,7 +190,7 @@ discovery.sendtargets.auth.password_in = %s
         rc, report = testlib.cmd(["/sbin/iscsi_discovery", remote_server])
         expected = 0
         result = 'Got exit code %d, expected %d\n' % (rc, expected)
-        self.assertEquals(expected, rc, result + report)
+        self.assertEqual(expected, rc, result + report)
         for i in ['starting discovery to %s' % remote_server,
                   'Testing iser-login to target %s portal %s' % (initiatorname, remote_server),
                   'starting to test tcp-login to target %s portal %s' % (initiatorname, remote_server),
@@ -409,13 +410,13 @@ if __name__ == '__main__':
             password_in = options.password_in
         if options.initiatorname:
             initiatorname = options.initiatorname
-        print "Connecting to remote server with:"
-        print " host = %s " % remote_server
-        print ' initiatorname = %s' % initiatorname
-        print ' username = %s' % username
-        print ' password = %s' % password
-        print ' username_in = %s' % username_in
-        print ' password_in = %s' % password_in
+        print("Connecting to remote server with:")
+        print(" host = %s " % remote_server)
+        print(' initiatorname = %s' % initiatorname)
+        print(' username = %s' % username)
+        print(' password = %s' % password)
+        print(' username_in = %s' % username_in)
+        print(' password_in = %s' % password_in)
 
     suite = unittest.TestSuite()
     suite.addTest(unittest.TestLoader().loadTestsFromTestCase(OpenIscsiTest))
diff --git a/debian/tests/testlib.py b/debian/tests/testlib.py
index b17c3fc..dce4252 100644
--- a/debian/tests/testlib.py
+++ b/debian/tests/testlib.py
@@ -1,6 +1,7 @@
+from __future__ import print_function
 #
 #    testlib.py quality assurance test script
-#    Copyright (C) 2008-2011 Canonical Ltd.
+#    Copyright (C) 2008-2016 Canonical Ltd.
 #
 #    This library is free software; you can redistribute it and/or
 #    modify it under the terms of the GNU Library General Public
@@ -19,31 +20,71 @@
 
 '''Common classes and functions for package tests.'''
 
-import string, random, crypt, subprocess, pwd, grp,  signal, time, unittest, tempfile, shutil, os, os.path, re, glob
-import sys, socket, gzip
-from stat import *
-from encodings import string_escape
+import crypt
+import glob
+import grp
+import gzip
+import os
+import os.path
+import platform
+import pwd
+import random
+import re
+import shutil
+import socket
+import string
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+from stat import ST_SIZE
+
+# Don't make python-pexpect mandatory
+try:
+    import pexpect
+except ImportError:
+    pass
 
 import warnings
 warnings.filterwarnings('ignore', message=r'.*apt_pkg\.TagFile.*', category=DeprecationWarning)
 try:
     import apt_pkg
-    apt_pkg.InitSystem();
+    # cope with apt_pkg api changes.
+    if 'init_system' in dir(apt_pkg):
+        apt_pkg.init_system()
+    else:
+        apt_pkg.InitSystem()
 except:
     # On non-Debian system, fall back to simple comparison without debianisms
     class apt_pkg(object):
-        def VersionCompare(one, two):
+        @staticmethod
+        def version_compare(one, two):
             list_one = one.split('.')
             list_two = two.split('.')
-            while len(list_one)>0 and len(list_two)>0:
-                if list_one[0] > list_two[0]:
-                    return 1
-                if list_one[0] < list_two[0]:
-                    return -1
+            while len(list_one) > 0 and len(list_two) > 0:
+                try:
+                    if int(list_one[0]) > int(list_two[0]):
+                        return 1
+                    if int(list_one[0]) < int(list_two[0]):
+                        return -1
+                except:
+                    # ugh, non-numerics in the version, fall back to
+                    # string comparison, which will be wrong for e.g.
+                    # 3.2 vs 3.16rc1
+                    if list_one[0] > list_two[0]:
+                        return 1
+                    if list_one[0] < list_two[0]:
+                        return -1
                 list_one.pop(0)
                 list_two.pop(0)
             return 0
 
+        @staticmethod
+        def VersionCompare(one, two):
+            return apt_pkg.version_compare(one, two)
+
 bogus_nxdomain = "208.69.32.132"
 
 # http://www.chiark.greenend.org.uk/ucgi/~cjwatson/blosxom/2009-07-02-python-sigpipe.html
@@ -55,17 +96,21 @@ def subprocess_setup():
     # non-Python subprocesses expect.
     signal.signal(signal.SIGPIPE, signal.SIG_DFL)
 
+
 class TimedOutException(Exception):
-    def __init__(self, value = "Timed Out"):
+    def __init__(self, value="Timed Out"):
         self.value = value
+
     def __str__(self):
         return repr(self.value)
 
+
 def _restore_backup(path):
     pathbackup = path + '.autotest'
     if os.path.exists(pathbackup):
         shutil.move(pathbackup, path)
 
+
 def _save_backup(path):
     pathbackup = path + '.autotest'
     if os.path.exists(path) and not os.path.exists(pathbackup):
@@ -75,53 +120,64 @@ def _save_backup(path):
         a = os.stat(path)
         os.chown(pathbackup, a[4], a[5])
 
+
 def config_copydir(path):
     if os.path.exists(path) and not os.path.isdir(path):
-        raise OSError, "'%s' is not a directory" % (path)
+        raise OSError("'%s' is not a directory" % (path))
     _restore_backup(path)
 
     pathbackup = path + '.autotest'
     if os.path.exists(path):
         shutil.copytree(path, pathbackup, symlinks=True)
 
-def config_replace(path,contents,append=False):
+
+def config_replace(path, contents, append=False):
     '''Replace (or append) to a config file'''
     _restore_backup(path)
     if os.path.exists(path):
         _save_backup(path)
         if append:
-            contents = file(path).read() + contents
-    open(path, 'w').write(contents)
+            with open(path) as fh:
+                contents = fh.read() + contents
+    with open(path, 'w') as fh:
+        fh.write(contents)
+
 
 def config_comment(path, field):
     _save_backup(path)
     contents = ""
-    for line in file(path):
-        if re.search("^\s*%s\s*=" % (field), line):
-            line = "#" + line
-        contents += line
+    with open(path) as fh:
+        for line in fh:
+            if re.search("^\s*%s\s*=" % (field), line):
+                line = "#" + line
+            contents += line
+
+    with open(path + '.new', 'w') as new_fh:
+        new_fh.write(contents)
+    os.rename(path + '.new', path)
 
-    open(path+'.new', 'w').write(contents)
-    os.rename(path+'.new', path)
 
 def config_set(path, field, value, spaces=True):
     _save_backup(path)
     contents = ""
-    if spaces==True:
+    if spaces:
         setting = '%s = %s\n' % (field, value)
     else:
         setting = '%s=%s\n' % (field, value)
     found = False
-    for line in file(path):
-        if re.search("^\s*%s\s*=" % (field), line):
-            found = True
-            line = setting
-        contents += line
+    with open(path) as fh:
+        for line in fh:
+            if re.search("^\s*%s\s*=" % (field), line):
+                found = True
+                line = setting
+            contents += line
     if not found:
         contents += setting
 
-    open(path+'.new', 'w').write(contents)
-    os.rename(path+'.new', path)
+    with open(path + '.new', 'w') as new_config:
+        new_config.write(contents)
+    os.rename(path + '.new', path)
+
 
 def config_patch(path, patch, depth=1):
     '''Patch a config file'''
@@ -129,15 +185,17 @@ def config_patch(path, patch, depth=1):
     _save_backup(path)
 
     handle, name = mkstemp_fill(patch)
-    rc = subprocess.call(['/usr/bin/patch', '-p%s' %(depth), path], stdin=handle, stdout=subprocess.PIPE)
+    rc = subprocess.call(['/usr/bin/patch', '-p%s' % depth, path], stdin=handle, stdout=subprocess.PIPE)
     os.unlink(name)
     if rc != 0:
         raise Exception("Patch failed")
 
+
 def config_restore(path):
     '''Rename a replaced config file back to its initial state'''
     _restore_backup(path)
 
+
 def timeout(secs, f, *args):
     def handler(signum, frame):
         raise TimedOutException()
@@ -153,51 +211,57 @@ def timeout(secs, f, *args):
 
     return result
 
+
 def require_nonroot():
     if os.geteuid() == 0:
-        print >>sys.stderr, "This series of tests should be run as a regular user with sudo access, not as root."
+        print("This series of tests should be run as a regular user with sudo access, not as root.", file=sys.stderr)
         sys.exit(1)
 
+
 def require_root():
     if os.geteuid() != 0:
-        print >>sys.stderr, "This series of tests should be run with root privileges (e.g. via sudo)."
+        print("This series of tests should be run with root privileges (e.g. via sudo).", file=sys.stderr)
         sys.exit(1)
 
+
 def require_sudo():
-    if os.geteuid() != 0 or os.environ.get('SUDO_USER', None) == None:
-        print >>sys.stderr, "This series of tests must be run under sudo."
+    if os.geteuid() != 0 or os.environ.get('SUDO_USER', None) is None:
+        print("This series of tests must be run under sudo.", file=sys.stderr)
         sys.exit(1)
     if os.environ['SUDO_USER'] == 'root':
-        print >>sys.stderr, 'Please run this test using sudo from a regular user. (You ran sudo from root.)'
+        print('Please run this test using sudo from a regular user. (You ran sudo from root.)', file=sys.stderr)
         sys.exit(1)
 
-def random_string(length,lower=False):
+
+def random_string(length, lower=False):
     '''Return a random string, consisting of ASCII letters, with given
     length.'''
 
     s = ''
-    selection = string.letters
+    selection = string.ascii_letters
     if lower:
-        selection = string.lowercase
-    maxind = len(selection)-1
+        selection = string.ascii_lowercase
+    maxind = len(selection) - 1
     for l in range(length):
         s += selection[random.randint(0, maxind)]
     return s
 
-def mkstemp_fill(contents,suffix='',prefix='testlib-',dir=None):
+
+def mkstemp_fill(contents, suffix='', prefix='testlib-', dir=None):
     '''As tempfile.mkstemp does, return a (file, name) pair, but with
     prefilled contents.'''
 
-    handle, name = tempfile.mkstemp(suffix=suffix,prefix=prefix,dir=dir)
+    handle, name = tempfile.mkstemp(suffix=suffix, prefix=prefix, dir=dir)
     os.close(handle)
-    handle = file(name,"w+")
+    handle = open(name, "w+")
     handle.write(contents)
     handle.flush()
     handle.seek(0)
 
     return handle, name
 
-def create_fill(path, contents, mode=0644):
+
+def create_fill(path, contents, mode=0o644):
     '''Safely create a page'''
     # make the temp file in the same dir as the destination file so we
     # don't get invalid cross-device link errors when we rename
@@ -206,6 +270,7 @@ def create_fill(path, contents, mode=0644):
     os.rename(name, path)
     os.chmod(path, mode)
 
+
 def login_exists(login):
     '''Checks whether the given login exists on the system.'''
 
@@ -215,6 +280,7 @@ def login_exists(login):
     except KeyError:
         return False
 
+
 def group_exists(group):
     '''Checks whether the given login exists on the system.'''
 
@@ -224,6 +290,13 @@ def group_exists(group):
     except KeyError:
         return False
 
+
+def is_empty_file(path):
+    '''test if file is empty, returns True if so'''
+    with open(path) as fh:
+        return (len(fh.read()) == 0)
+
+
 def recursive_rm(dirPath, contents_only=False):
     '''recursively remove directory'''
     names = os.listdir(dirPath)
@@ -233,9 +306,10 @@ def recursive_rm(dirPath, contents_only=False):
             os.unlink(path)
         else:
             recursive_rm(path)
-    if contents_only == False:
+    if not contents_only:
         os.rmdir(dirPath)
 
+
 def check_pidfile(exe, pidfile):
     '''Checks if pid in pidfile is running'''
     if not os.path.exists(pidfile):
@@ -243,14 +317,14 @@ def check_pidfile(exe, pidfile):
 
     # get the pid
     try:
-        fd = open(pidfile, 'r')
-        pid = fd.readline().rstrip('\n')
-        fd.close()
+        with open(pidfile, 'r') as fd:
+            pid = fd.readline().rstrip('\n')
     except:
         return False
 
     return check_pid(exe, pid)
 
+
 def check_pid(exe, pid):
     '''Checks if pid is running'''
     cmdline = "/proc/%s/cmdline" % (str(pid))
@@ -259,9 +333,8 @@ def check_pid(exe, pid):
 
     # get the command line
     try:
-        fd = open(cmdline, 'r')
-        tmp = fd.readline().split('\0')
-        fd.close()
+        with open(cmdline, 'r') as fd:
+            tmp = fd.readline().split('\0')
     except:
         return False
 
@@ -274,6 +347,7 @@ def check_pid(exe, pid):
 
     return False
 
+
 def check_port(port, proto, ver=4):
     '''Check if something is listening on the specified port.
        WARNING: for some reason this does not work with a bind mounted /proc
@@ -296,12 +370,29 @@ def check_port(port, proto, ver=4):
         return True
     return False
 
+
 def get_arch():
     '''Get the current architecture'''
     rc, report = cmd(['uname', '-m'])
     assert (rc == 0)
     return report.strip()
 
+
+def get_multiarch_tuple():
+    '''Get the current debian multiarch tuple'''
+
+    # XXX dpkg-architecture on Ubuntu 12.04 requires -q be adjacent to
+    # the variable name
+    rc, report = cmd(['dpkg-architecture', '-qDEB_HOST_MULTIARCH'])
+    assert (rc == 0)
+    return report.strip()
+
+
+def get_bits():
+    '''return the default architecture number of bits (32 or 64, usually)'''
+    return platform.architecture()[0][0:2]
+
+
 def get_memory():
     '''Gets total ram and swap'''
     meminfo = "/proc/meminfo"
@@ -322,7 +413,8 @@ def get_memory():
     except:
         return (False, False)
 
-    return (memtotal,swaptotal)
+    return (memtotal, swaptotal)
+
 
 def is_running_in_vm():
     '''Check if running under a VM'''
@@ -333,6 +425,7 @@ def is_running_in_vm():
             return True
     return False
 
+
 def ubuntu_release():
     '''Get the Ubuntu release'''
     f = "/etc/lsb-release"
@@ -341,16 +434,11 @@ def ubuntu_release():
     except:
         return "UNKNOWN"
 
-    if size > 1024*1024:
-        raise IOError, 'Could not open "%s" (too big)' % f
-
-    try:
-        fh = open("/etc/lsb-release", 'r')
-    except:
-        raise
+    if size > 1024 * 1024:
+        raise IOError('Could not open "%s" (too big)' % f)
 
-    lines = fh.readlines()
-    fh.close()
+    with open("/etc/lsb-release", 'r') as fh:
+        lines = fh.readlines()
 
     pat = re.compile(r'DISTRIB_CODENAME')
     for line in lines:
@@ -359,40 +447,53 @@ def ubuntu_release():
 
     return "UNKNOWN"
 
-def cmd(command, input = None, stderr = subprocess.STDOUT, stdout = subprocess.PIPE, stdin = None, timeout = None):
+
+def cmd(command, input=None, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, stdin=None, timeout=None, env=None, shell=False, text=True):
     '''Try to execute given command (array) and return its stdout, or return
     a textual error if it failed.'''
 
     try:
-        sp = subprocess.Popen(command, stdin=stdin, stdout=stdout, stderr=stderr, close_fds=True, preexec_fn=subprocess_setup)
-    except OSError, e:
+        sp = subprocess.Popen(command, stdin=stdin, stdout=stdout, stderr=stderr, close_fds=True, preexec_fn=subprocess_setup, env=env, universal_newlines=text, shell=shell)
+        if sys.version_info[0] >= 3 and sys.version_info[1] > 3:
+            out, outerr = sp.communicate(input, timeout=timeout)
+        else:
+            out, outerr = sp.communicate(input)
+    except OSError as e:
         return [127, str(e)]
 
-    out, outerr = sp.communicate(input)
     # Handle redirection of stdout
-    if out == None:
+    if out is None:
         out = ''
     # Handle redirection of stderr
-    if outerr == None:
+    if outerr is None:
         outerr = ''
-    return [sp.returncode,out+outerr]
+    if text == False:
+        out = str(out)
+    return [sp.returncode, out + outerr]
 
-def cmd_pipe(command1, command2, input = None, stderr = subprocess.STDOUT, stdin = None):
+
+def cmd_pipe(command1, command2, input=None, stderr=subprocess.STDOUT, stdin=None):
     '''Try to pipe command1 into command2.'''
     try:
         sp1 = subprocess.Popen(command1, stdin=stdin, stdout=subprocess.PIPE, stderr=stderr, close_fds=True)
-        sp2 = subprocess.Popen(command2, stdin=sp1.stdout, stdout=subprocess.PIPE, stderr=stderr, close_fds=True)
-    except OSError, e:
+        sp2 = subprocess.Popen(command2, stdin=sp1.stdout, stdout=subprocess.PIPE, stderr=stderr, close_fds=True, universal_newlines=True)
+    except OSError as e:
         return [127, str(e)]
 
     out = sp2.communicate(input)[0]
-    return [sp2.returncode,out]
+    # ensure we don't leak open files and that sp1 is stopped
+    sp1.stdout.close()
+    sp1.wait()
+    return [sp2.returncode, out]
+
 
 def cwd_has_enough_space(cdir, total_bytes):
     '''Determine if the partition of the current working directory has 'bytes'
        free.'''
     rc, df_output = cmd(['df'])
-    result = 'Got exit code %d, expected %d\n' % (rc, 0)
+    if rc != 0:
+        result = 'df failed, got exit code %d, expected %d\n' % (rc, 0)
+        raise OSError(result)
     if rc != 0:
         return False
 
@@ -407,18 +508,13 @@ def cwd_has_enough_space(cdir, total_bytes):
 
     cdir = os.getcwd()
     while cdir != '/':
-        if not mounts.has_key(cdir):
+        if cdir not in mounts:
             cdir = os.path.dirname(cdir)
             continue
-        if kb < mounts[cdir]:
-            return True
-        else:
-            return False
+        return kb < mounts[cdir]
 
-    if kb < mounts['/']:
-        return True
+    return kb < mounts['/']
 
-    return False
 
 def get_md5(filename):
     '''Gets the md5sum of the file specified'''
@@ -429,6 +525,7 @@ def get_md5(filename):
 
     return report.split(' ')[0]
 
+
 def dpkg_compare_installed_version(pkg, check, version):
     '''Gets the version for the installed package, and compares it to the
        specified version.
@@ -449,6 +546,35 @@ def dpkg_compare_installed_version(pkg, check, version):
         return True
     return False
 
+
+def _run_apt_command(pkg_list, apt_cmd='install'):
+    env = os.environ.copy()
+    env['DEBIAN_FRONTEND'] = 'noninteractive'
+    # debugging version, but on precise doesn't actually run dpkg
+    # command = ['apt-get', '-y', '--force-yes', '-o', 'Dpkg::Options::=--force-confold', '-o', 'Debug::pkgDPkgPM=true', apt_cmd]
+    command = ['apt-get', '-y', '--force-yes', '-o', 'Dpkg::Options::=--force-confold', apt_cmd]
+    command.extend(pkg_list)
+    rc, report = cmd(command)
+    return rc, report
+
+
+# note: for the following install_* functions, you probably want the
+# versions in the TestlibCase class (see below)
+def install_builddeps(src_pkg):
+    rc, report = _run_apt_command([src_pkg], 'build-dep')
+    assert(rc == 0)
+
+
+def install_package(package):
+    rc, report = _run_apt_command([package], 'install')
+    assert(rc == 0)
+
+
+def install_packages(pkg_list):
+    rc, report = _run_apt_command(pkg_list, 'install')
+    assert(rc == 0)
+
+
 def prepare_source(source, builder, cached_src, build_src, patch_system):
     '''Download and unpack source package, installing necessary build depends,
        adjusting the permissions for the 'builder' user, and returning the
@@ -468,7 +594,7 @@ def prepare_source(source, builder, cached_src, build_src, patch_system):
            self.tmpdir = tempfile.mkdtemp(prefix='testlib', dir='/tmp')
            self.builder = testlib.TestUser()
            testlib.cmd(['chgrp', self.builder.login, self.tmpdir])
-           os.chmod(self.tmpdir, 0775)
+           os.chmod(self.tmpdir, 0o775)
 
        def tearDown(self):
            ...
@@ -488,21 +614,21 @@ def prepare_source(source, builder, cached_src, build_src, patch_system):
            os.chdir(build_dir)
 
            # Example for typical build, adjust as necessary
-           print ""
-           print "  make clean"
+           print("")
+           print("  make clean")
            rc, report = testlib.cmd(['sudo', '-u', self.builder.login, 'make', 'clean'])
 
-           print "  configure"
+           print("  configure")
            rc, report = testlib.cmd(['sudo', '-u', self.builder.login, './configure', '--prefix=%s' % self.tmpdir, '--enable-debug'])
 
-           print "  make (will take a while)"
+           print("  make (will take a while)")
            rc, report = testlib.cmd(['sudo', '-u', self.builder.login, 'make'])
 
-           print "  make check (will take a while)",
+           print("  make check (will take a while)",)
            rc, report = testlib.cmd(['sudo', '-u', self.builder.login, 'make', 'check'])
            expected = 0
            result = 'Got exit code %d, expected %d\n' % (rc, expected)
-           self.assertEquals(expected, rc, result + report)
+           self.assertEqual(expected, rc, result + report)
 
         def test_suite_cleanup(self):
             ...
@@ -526,20 +652,18 @@ def prepare_source(source, builder, cached_src, build_src, patch_system):
         os.chdir(build_src)
     else:
         # Only install the build dependencies on the initial setup
-        rc, report = cmd(['apt-get','-y','--force-yes','build-dep',source])
-        assert (rc == 0)
-
+        install_builddeps(source)
         os.makedirs(build_src)
         os.chdir(build_src)
 
         # These are always needed
         pkgs = ['build-essential', 'dpkg-dev', 'fakeroot']
-        rc, report = cmd(['apt-get','-y','--force-yes','install'] + pkgs)
-        assert (rc == 0)
+        install_packages(pkgs)
 
-        rc, report = cmd(['apt-get','source',source])
+        rc, report = cmd(['apt-get', 'source', source])
         assert (rc == 0)
         shutil.copytree(build_src, cached_src)
+        print("(unpacked %s)" % os.path.basename(glob.glob('%s_*.dsc' % source)[0]), end=' ')
 
     unpacked_dir = os.path.join(build_src, glob.glob('%s-*' % source)[0])
 
@@ -547,9 +671,9 @@ def prepare_source(source, builder, cached_src, build_src, patch_system):
     # sources.
     os.chdir(unpacked_dir)
     assert (patch_system in ['cdbs', 'dpatch', 'quilt', 'quiltv3', None])
-    if patch_system != None and patch_system != "quiltv3":
+    if patch_system is not None and patch_system != "quiltv3":
         if patch_system == "quilt":
-            os.environ.setdefault('QUILT_PATCHES','debian/patches')
+            os.environ.setdefault('QUILT_PATCHES', 'debian/patches')
             rc, report = cmd(['quilt', 'push', '-a'])
             assert (rc == 0)
         elif patch_system == "cdbs":
@@ -564,6 +688,21 @@ def prepare_source(source, builder, cached_src, build_src, patch_system):
 
     return unpacked_dir
 
+
+def get_changelog_version(source_dir):
+    '''Extract a package version from a changelog'''
+    package_version = ""
+
+    changelog_file = os.path.join(source_dir, "debian/changelog")
+
+    if os.path.exists(changelog_file):
+        changelog = open(changelog_file, 'r')
+        header = changelog.readline().split()
+        package_version = header[1].strip('()')
+
+    return package_version
+
+
 def _aa_status():
     '''Get aa-status output'''
     exe = "/usr/sbin/aa-status"
@@ -572,6 +711,7 @@ def _aa_status():
         return cmd([exe])
     return cmd(['sudo', exe])
 
+
 def is_apparmor_loaded(path):
     '''Check if profile is loaded'''
     rc, report = _aa_status()
@@ -583,6 +723,7 @@ def is_apparmor_loaded(path):
             return True
     return False
 
+
 def is_apparmor_confined(path):
     '''Check if application is confined'''
     rc, report = _aa_status()
@@ -594,6 +735,7 @@ def is_apparmor_confined(path):
             return True
     return False
 
+
 def check_apparmor(path, first_ubuntu_release, is_running=True):
     '''Check if path is loaded and confined for everything higher than the
        first Ubuntu release specified.
@@ -605,7 +747,7 @@ def check_apparmor(path, first_ubuntu_release, is_running=True):
 
         expected = 0
         result = 'Got exit code %d, expected %d\n' % (rc, expected)
-        self.assertEquals(expected, rc, result + report)
+        self.assertEqual(expected, rc, result + report)
      '''
     global manager
     rc = -1
@@ -629,13 +771,14 @@ def check_apparmor(path, first_ubuntu_release, is_running=True):
 
     return (rc, msg)
 
+
 def get_gcc_version(gcc, full=True):
     gcc_version = 'none'
     if not gcc.startswith('/'):
         gcc = '/usr/bin/%s' % (gcc)
     if os.path.exists(gcc):
         gcc_version = 'unknown'
-        lines = cmd([gcc,'-v'])[1].strip().splitlines()
+        lines = cmd([gcc, '-v'])[1].strip().splitlines()
         version_lines = [x for x in lines if x.startswith('gcc version')]
         if len(version_lines) == 1:
             gcc_version = " ".join(version_lines[0].split()[2:])
@@ -643,6 +786,7 @@ def get_gcc_version(gcc, full=True):
         return gcc_version.split()[0]
     return gcc_version
 
+
 def is_kdeinit_running():
     '''Test if kdeinit is running'''
     # applications that use kdeinit will spawn it if it isn't running in the
@@ -650,106 +794,154 @@ def is_kdeinit_running():
     # check for it.
     rc, report = cmd(['ps', 'x'])
     if 'kdeinit4 Running' not in report:
-        print >>sys.stderr, ("kdeinit not running (you may start/stop any KDE application then run this script again)")
+        print("kdeinit not running (you may start/stop any KDE application then run this script again)", file=sys.stderr)
         return False
     return True
 
+
 def get_pkgconfig_flags(libs=[]):
     '''Find pkg-config flags for libraries'''
     assert (len(libs) > 0)
     rc, pkg_config = cmd(['pkg-config', '--cflags', '--libs'] + libs)
     expected = 0
     if rc != expected:
-        print >>sys.stderr, 'Got exit code %d, expected %d\n' % (rc, expected)
+        print('Got exit code %d, expected %d\n' % (rc, expected), file=sys.stderr)
     assert(rc == expected)
     return pkg_config.split()
 
+
+def cap_to_name(cap_num):
+    '''given an integer, return the capability name'''
+    rc, output = cmd(['capsh', '--decode=%x' % cap_num])
+    expected = 0
+    if rc != expected:
+        print('capsh: got exit code %d, expected %d\n' % (rc, expected), file=sys.stderr)
+    cap_name = output.strip().split('=')[1]
+    return cap_name
+
+
+def enumerate_capabilities():
+    i = 0
+    cap_list = []
+    done = False
+    while not done:
+        cap_name = cap_to_name(pow(2, i))
+        if cap_name == str(i):
+            done = True
+        else:
+            cap_list.append(cap_name)
+            i += 1
+        if i > 64:
+            done = True
+    return cap_list
+
+
+def _run_snap_install(snapname, track="latest/stable", classic=False):
+    # crude, but effective
+    if os.path.exists(os.path.join("/snap", snapname)):
+        return 0, ""
+
+    command = ["snap", "install", "--channel=%s" % track, snapname]
+    if classic:
+        command.append("--classic")
+    rc, report = cmd(command)
+    return rc, report
+
+
+def _run_snap_remove(snapname):
+    # crude, but effective
+    if not os.path.exists(os.path.join("/snap", snapname)):
+        return 0, ""
+
+    command = ["snap", "remove", "--purge", snapname]
+    rc, report = cmd(command)
+    return rc, report
+
+
+def install_snap(self, snapname, track="latest/stable", classic=False):
+    rc, report = _run_snap_install(snapname, track, classic)
+    self.assertEqual(0, rc, "Failed to install snap %s\nOutput:\n%s" %
+                            (snapname, report))
+
+
+def remove_snap(self, snapname):
+    rc, report = _run_snap_remove(snapname)
+    self.assertEqual(0, rc, "Failed to install snap %s\nOutput:\n%s" %
+                            (snapname, report))
+
+
 class TestDaemon:
     '''Helper class to manage daemons consistently'''
-    def __init__(self, init):
+    def __init__(self, service_name):
         '''Setup daemon attributes'''
-        self.initscript = init
-
-    def _build_command(self, suffix):
-        command = []
-        if isinstance(self.initscript, list):
-            command.extend(self.initscript)
+        if os.path.isfile('/usr/sbin/service') or os.path.islink('/usr/sbin/service'):
+            self.test_daemon_commands = ['service', service_name]
         else:
-            command.append(self.initscript)
-        command.append(suffix)
-        return command
+            self.test_daemon_commands = ['/etc/init.d/' + service_name]
 
-    def start(self):
-        '''Start daemon'''
-        rc, report = cmd(self._build_command('start'))
+    def _run_command(self, action, seconds_to_wait=2):
+        command = list(self.test_daemon_commands)
+        command.append(action)
+        rc, report = cmd(command)
         expected = 0
         result = 'Got exit code %d, expected %d\n' % (rc, expected)
-        time.sleep(2)
+        time.sleep(seconds_to_wait)
         if expected != rc:
-            return (False, result + report)
+            return False, result + report
 
         if "fail" in report:
-            return (False, "Found 'fail' in report\n" + report)
+            return False, "Found 'fail' in report\n" + report
 
-        return (True, "")
+        return True, ""
+
+    def start(self):
+        '''Start daemon'''
+        return self._run_command('start')
 
     def stop(self):
         '''Stop daemon'''
-        rc, report = cmd(self._build_command('stop'))
-        expected = 0
-        result = 'Got exit code %d, expected %d\n' % (rc, expected)
-        if expected != rc:
-            return (False, result + report)
-
-        if "fail" in report:
-            return (False, "Found 'fail' in report\n" + report)
-
-        return (True, "")
+        return self._run_command('stop')
 
     def reload(self):
         '''Reload daemon'''
-        rc, report = cmd(self._build_command('force-reload'))
-        expected = 0
-        result = 'Got exit code %d, expected %d\n' % (rc, expected)
-        if expected != rc:
-            return (False, result + report)
+        return self._run_command('force-reload')
 
-        if "fail" in report:
-            return (False, "Found 'fail' in report\n" + report)
+    def restart(self):
+        if self.test_daemon_commands[0] == 'service':
+            return self._run_command('restart')
+        else:
+            '''Restart daemon'''
+            (res, str) = self.stop()
+            if not res:
+                return res, str
 
-        return (True, "")
+            (res, str) = self.start()
+            if not res:
+                return res, str
 
-    def restart(self):
-        '''Restart daemon'''
-        (res, str) = self.stop()
-        if not res:
-            return (res, str)
+            return True, ""
+
+    def force_restart(self):
+        '''Restart daemon even if already stopped'''
+        self.stop()
 
         (res, str) = self.start()
         if not res:
-            return (res, str)
+            return res, str
 
-        return (True, "")
+        return True, ""
 
     def status(self):
         '''Check daemon status'''
-        rc, report = cmd(self._build_command('status'))
-        expected = 0
-        result = 'Got exit code %d, expected %d\n' % (rc, expected)
-        if expected != rc:
-            return (False, result + report)
-
-        if "fail" in report:
-            return (False, "Found 'fail' in report\n" + report)
+        return self._run_command('status')
 
-        return (True, "")
 
 class TestlibManager(object):
     '''Singleton class used to set up per-test-run information'''
     def __init__(self):
         # Set glibc aborts to dump to stderr instead of the tty so test output
         # is more sane.
-        os.environ.setdefault('LIBC_FATAL_STDERR_','1')
+        os.environ.setdefault('LIBC_FATAL_STDERR_', '1')
 
         # check verbosity
         self.verbosity = False
@@ -759,17 +951,17 @@ class TestlibManager(object):
         # Load LSB release file
         self.lsb_release = dict()
         if not os.path.exists('/usr/bin/lsb_release') and not os.path.exists('/bin/lsb_release'):
-            raise OSError, "Please install 'lsb-release'"
-        for line in subprocess.Popen(['lsb_release','-a'],stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0].splitlines():
-            field, value = line.split(':',1)
-            value=value.strip()
-            field=field.strip()
+            raise OSError("Please install 'lsb-release'")
+        for line in subprocess.Popen(['lsb_release', '-a'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True).communicate()[0].splitlines():
+            field, value = line.split(':', 1)
+            value = value.strip()
+            field = field.strip()
             # Convert numerics
             try:
                 value = float(value)
             except:
                 pass
-            self.lsb_release.setdefault(field,value)
+            self.lsb_release.setdefault(field, value)
 
         # FIXME: hack OEM releases into known-Ubuntu versions
         if self.lsb_release['Distributor ID'] == "HP MIE (Mobile Internet Experience)":
@@ -777,20 +969,20 @@ class TestlibManager(object):
                 self.lsb_release['Distributor ID'] = "Ubuntu"
                 self.lsb_release['Release'] = 8.04
             else:
-                raise OSError, "Unknown version of HP MIE"
+                raise OSError("Unknown version of HP MIE")
 
         # FIXME: hack to assume a most-recent release if we're not
         # running under Ubuntu.
-        if self.lsb_release['Distributor ID'] not in ["Ubuntu","Linaro"]:
+        if self.lsb_release['Distributor ID'] not in ["Ubuntu", "Linaro"]:
             self.lsb_release['Release'] = 10000
         # Adjust Linaro release to pretend to be Ubuntu
         if self.lsb_release['Distributor ID'] in ["Linaro"]:
-       	    self.lsb_release['Distributor ID'] = "Ubuntu"
+            self.lsb_release['Distributor ID'] = "Ubuntu"
             self.lsb_release['Release'] -= 0.01
 
         # Load arch
         if not os.path.exists('/usr/bin/dpkg'):
-            machine = cmd(['uname','-m'])[1].strip()
+            machine = cmd(['uname', '-m'])[1].strip()
             if machine.endswith('86'):
                 self.dpkg_arch = 'i386'
             elif machine.endswith('_64'):
@@ -798,26 +990,26 @@ class TestlibManager(object):
             elif machine.startswith('arm'):
                 self.dpkg_arch = 'armel'
             else:
-                raise ValueError, "Unknown machine type '%s'" % (machine)
+                raise ValueError("Unknown machine type '%s'" % (machine))
         else:
-            self.dpkg_arch = cmd(['dpkg','--print-architecture'])[1].strip()
+            self.dpkg_arch = cmd(['dpkg', '--print-architecture'])[1].strip()
 
         # Find kernel version
         self.kernel_is_ubuntu = False
         self.kernel_version_signature = None
-        self.kernel_version = cmd(["uname","-r"])[1].strip()
+        self.kernel_version = cmd(["uname", "-r"])[1].strip()
         versig = '/proc/version_signature'
         if os.path.exists(versig):
             self.kernel_is_ubuntu = True
-            self.kernel_version_signature = file(versig).read().strip()
+            self.kernel_version_signature = open(versig).read().strip()
             self.kernel_version_ubuntu = self.kernel_version
         elif os.path.exists('/usr/bin/dpkg'):
             # this can easily be inaccurate but is only an issue for Dapper
-            rc, out = cmd(['dpkg','-l','linux-image-%s' % (self.kernel_version)])
+            rc, out = cmd(['dpkg', '-l', 'linux-image-%s' % (self.kernel_version)])
             if rc == 0:
                 self.kernel_version_signature = out.strip().split('\n').pop().split()[2]
                 self.kernel_version_ubuntu = self.kernel_version_signature
-        if self.kernel_version_signature == None:
+        if self.kernel_version_signature is None:
             # Attempt to fall back to something for non-Debian-based
             self.kernel_version_signature = self.kernel_version
             self.kernel_version_ubuntu = self.kernel_version
@@ -831,25 +1023,25 @@ class TestlibManager(object):
         self.gcc_version = get_gcc_version('gcc')
 
         # Find libc
-        self.path_libc = [x.split()[2] for x in cmd(['ldd','/bin/ls'])[1].splitlines() if x.startswith('\tlibc.so.')][0]
+        self.path_libc = [x.split()[2] for x in cmd(['ldd', '/bin/ls'])[1].splitlines() if x.startswith('\tlibc.so.')][0]
 
         # Report self
         if self.verbosity:
             kernel = self.kernel_version_ubuntu
             if kernel != self.kernel_version_signature:
                 kernel += " (%s)" % (self.kernel_version_signature)
-            print >>sys.stdout, "Running test: '%s' distro: '%s %.2f' kernel: '%s' arch: '%s' uid: %d/%d SUDO_USER: '%s')" % ( \
+            print("Running test: '%s' distro: '%s %.2f' kernel: '%s' arch: '%s' uid: %d/%d SUDO_USER: '%s')" % (
                 sys.argv[0],
                 self.lsb_release['Distributor ID'],
                 self.lsb_release['Release'],
                 kernel,
                 self.dpkg_arch,
                 os.geteuid(), os.getuid(),
-                os.environ.get('SUDO_USER', ''))
+                os.environ.get('SUDO_USER', '')), file=sys.stdout)
             sys.stdout.flush()
 
         # Additional heuristics
-        #if os.environ.get('SUDO_USER', os.environ.get('USER', '')) in ['mdeslaur']:
+        # if os.environ.get('SUDO_USER', os.environ.get('USER', '')) in ['mdeslaur']:
         #    sys.stdout.write("Replying to Marc Deslauriers in http://launchpad.net/bugs/%d: " % random.randint(600000, 980000))
         #    sys.stdout.flush()
         #    time.sleep(0.5)
@@ -857,10 +1049,11 @@ class TestlibManager(object):
         #    time.sleep(0.5)
 
     def hello(self, msg):
-        print >>sys.stderr, "Hello from %s" % (msg)
+        print("Hello from %s" % (msg), file=sys.stderr)
 # The central instance
 manager = TestlibManager()
 
+
 class TestlibCase(unittest.TestCase):
     def __init__(self, *args):
         '''This is called for each TestCase test instance, which isn't much better
@@ -870,7 +1063,7 @@ class TestlibCase(unittest.TestCase):
 
         # Attach to and duplicate dicts from manager singleton
         self.manager = manager
-        #self.manager.hello(repr(self) + repr(*args))
+        # self.manager.hello(repr(self) + repr(*args))
         self.my_verbosity = self.manager.verbosity
         self.lsb_release = self.manager.lsb_release
         self.dpkg_arch = self.manager.dpkg_arch
@@ -882,9 +1075,12 @@ class TestlibCase(unittest.TestCase):
         self.path_libc = self.manager.path_libc
 
     def version_compare(self, one, two):
-        return apt_pkg.VersionCompare(one,two)
+        if 'version_compare' in dir(apt_pkg):
+            return apt_pkg.version_compare(one, two)
+        else:
+            return apt_pkg.VersionCompare(one, two)
 
-    def assertFileType(self, filename, filetype):
+    def assertFileType(self, filename, filetype, strict=True):
         '''Checks the file type of the file specified'''
 
         (rc, report, out) = self._testlib_shell_cmd(["/usr/bin/file", "-b", filename])
@@ -894,15 +1090,19 @@ class TestlibCase(unittest.TestCase):
         if self.lsb_release['Release'] == 8.04 and rc == 255 and len(out) > 0:
             rc = 0
         result = 'Got exit code %d, expected %d:\n%s\n' % (rc, expected, report)
-        self.assertEquals(expected, rc, result)
+        self.assertEqual(expected, rc, result)
 
-        filetype = '^%s$' % (filetype)
+        if strict:
+            filetype = '^%s$' % (filetype)
+        else:
+            # accept if the beginning of the line matches
+            filetype = '^%s' % (filetype)
         result = 'File type reported by file: [%s], expected regex: [%s]\n' % (out, filetype)
-        self.assertNotEquals(None, re.search(filetype, out), result)
+        self.assertNotEqual(None, re.search(filetype, out), result)
 
     def yank_commonname_from_cert(self, certfile):
         '''Extract the commonName from a given PEM'''
-        rc, out = cmd(['openssl','asn1parse','-in',certfile])
+        rc, out = cmd(['openssl', 'asn1parse', '-in', certfile])
         if rc == 0:
             ready = False
             for line in out.splitlines():
@@ -914,12 +1114,12 @@ class TestlibCase(unittest.TestCase):
 
     def announce(self, text):
         if self.my_verbosity:
-            print >>sys.stdout, "(%s) " % (text),
+            print("(%s) " % (text), file=sys.stderr, end='')
             sys.stdout.flush()
 
     def make_clean(self):
-        rc, output = self.shell_cmd(['make','clean'])
-        self.assertEquals(rc, 0, output)
+        rc, output = self.shell_cmd(['make', 'clean'])
+        self.assertEqual(rc, 0, output)
 
     def get_makefile_compiler(self):
         # Find potential compiler name
@@ -937,8 +1137,8 @@ class TestlibCase(unittest.TestCase):
         '''Compile a target and report output'''
 
         compiler = self.get_makefile_compiler()
-        rc, output = self.shell_cmd(['make',target])
-        self.assertEquals(rc, expected, 'rc(%d)!=%d:\n' % (rc, expected) + output)
+        rc, output = self.shell_cmd(['make', target])
+        self.assertEqual(rc, expected, 'rc(%d)!=%d:\n' % (rc, expected) + output)
         self.assertTrue('%s ' % (compiler) in output, 'Expected "%s":' % (compiler) + output)
         return output
 
@@ -950,28 +1150,43 @@ class TestlibCase(unittest.TestCase):
         self.announce("skipped%s" % (reason))
         return False
 
-    def _testlib_shell_cmd(self,args,stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT):
+    def _testlib_shell_cmd(self, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=None):
         argstr = "'" + "', '".join(args).strip() + "'"
-        rc, out = cmd(args,stdin=stdin,stdout=stdout,stderr=stderr)
+        rc, out = cmd(args, stdin=stdin, stdout=stdout, stderr=stderr, env=env)
         report = 'Command: ' + argstr + '\nOutput:\n' + out
         return rc, report, out
 
     def shell_cmd(self, args, stdin=None):
-        return cmd(args,stdin=stdin)
+        return cmd(args, stdin=stdin)
 
-    def assertShellExitEquals(self, expected, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg=""):
+    def assertShellExitEquals(self, expected, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=None, msg="", bare_report=False):
         '''Test a shell command matches a specific exit code'''
-        rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
+        rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr, env=env)
         result = 'Got exit code %d, expected %d\n' % (rc, expected)
-        self.assertEquals(expected, rc, msg + result + report)
+        self.assertEqual(expected, rc, msg + result + report)
+        if bare_report:
+            return out
+        else:
+            return report
+
+    def assertShellExitSuccess(self, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=None, msg="", bare_report=False):
+        '''Same as assertShellEquals but with an expected exit status of 0 (success).'''
+        return self.assertShellExitEquals(0, args, stdin, stdout, stderr, env, msg, bare_report)
+
+    # make sure exit value is in a list of expected values
+    def assertShellExitIn(self, expected, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg=""):
+        '''Test a shell command matches a specific exit code'''
+        rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
+        result = 'Got exit code %d, expected one of %s\n' % (rc, ', '.join(map(str, expected)))
+        self.assertIn(rc, expected, msg + result + report)
 
     def assertShellExitNotEquals(self, unwanted, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg=""):
         '''Test a shell command doesn't match a specific exit code'''
         rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
         result = 'Got (unwanted) exit code %d\n' % rc
-        self.assertNotEquals(unwanted, rc, msg + result + report)
+        self.assertNotEqual(unwanted, rc, msg + result + report)
 
-    def assertShellOutputContains(self, text, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg="", invert=False):
+    def assertShellOutputContains(self, text, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg="", invert=False, expected=None):
         '''Test a shell command contains a specific output'''
         rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
         result = 'Got exit code %d.  Looking for text "%s"\n' % (rc, text)
@@ -979,18 +1194,21 @@ class TestlibCase(unittest.TestCase):
             self.assertTrue(text in out, msg + result + report)
         else:
             self.assertFalse(text in out, msg + result + report)
+        if expected is not None:
+            result = 'Got exit code %d. Expected %d (%s)\n' % (rc, expected, " ".join(args))
+            self.assertEqual(rc, expected, msg + result + report)
 
     def assertShellOutputEquals(self, text, args, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, msg="", invert=False, expected=None):
         '''Test a shell command matches a specific output'''
         rc, report, out = self._testlib_shell_cmd(args, stdin=stdin, stdout=stdout, stderr=stderr)
         result = 'Got exit code %d. Looking for exact text "%s" (%s)\n' % (rc, text, " ".join(args))
         if not invert:
-            self.assertEquals(text, out, msg + result + report)
+            self.assertEqual(text, out, msg + result + report)
         else:
-            self.assertNotEquals(text, out, msg + result + report)
-        if expected != None:
+            self.assertNotEqual(text, out, msg + result + report)
+        if expected is not None:
             result = 'Got exit code %d. Expected %d (%s)\n' % (rc, expected, " ".join(args))
-            self.assertEquals(rc, expected, msg + result + report)
+            self.assertEqual(rc, expected, msg + result + report)
 
     def _word_find(self, report, content, invert=False):
         '''Check for a specific string'''
@@ -1003,20 +1221,22 @@ class TestlibCase(unittest.TestCase):
 
     def _test_sysctl_value(self, path, expected, msg=None, exists=True):
         sysctl = '/proc/sys/%s' % (path)
-        self.assertEquals(exists, os.path.exists(sysctl), sysctl)
+        self.assertEqual(exists, os.path.exists(sysctl), sysctl)
         value = None
         if exists:
-            value = int(file(sysctl).read())
+            with open(sysctl) as sysctl_fd:
+                value = int(sysctl_fd.read())
             report = "%s is not %d: %d" % (sysctl, expected, value)
             if msg:
                 report += " (%s)" % (msg)
-            self.assertEquals(value, expected, report)
+            self.assertEqual(value, expected, report)
         return value
 
     def set_sysctl_value(self, path, desired):
         sysctl = '/proc/sys/%s' % (path)
-        self.assertTrue(os.path.exists(sysctl),"%s does not exist" % (sysctl))
-        file(sysctl,'w').write(str(desired))
+        self.assertTrue(os.path.exists(sysctl), "%s does not exist" % (sysctl))
+        with open(sysctl, 'w') as sysctl_fh:
+            sysctl_fh.write(str(desired))
         self._test_sysctl_value(path, desired)
 
     def kernel_at_least(self, introduced):
@@ -1027,10 +1247,33 @@ class TestlibCase(unittest.TestCase):
         changelog = "/usr/share/doc/linux-image-%s/changelog.Debian.gz" % (self.kernel_version)
         if os.path.exists(changelog):
             for line in gzip.open(changelog):
-                if cve in line and not "revert" in line and not "Revert" in line:
+                if cve in line and "revert" not in line and "Revert" not in line:
                     return True
         return False
 
+    def install_builddeps(self, src_pkg):
+        rc, report = _run_apt_command([src_pkg], 'build-dep')
+        self.assertEqual(0, rc, 'Failed to install build-deps for %s\nOutput:\n%s' % (src_pkg, report))
+
+    def install_package(self, package):
+        rc, report = _run_apt_command([package], 'install')
+        self.assertEqual(0, rc, 'Failed to install package %s\nOutput:\n%s' % (package, report))
+
+    def install_packages(self, pkg_list):
+        rc, report = _run_apt_command(pkg_list, 'install')
+        self.assertEqual(0, rc, 'Failed to install packages %s\nOutput:\n%s' % (','.join(pkg_list), report))
+
+    def install_snap(self, snapname, track="latest/stable", classic=False):
+        rc, report = _run_snap_install(snapname, track, classic)
+        self.assertEqual(0, rc, "Failed to install snap %s\nOutput:\n%s" %
+                                (snapname, report))
+
+    def remove_snap(self, snapname):
+        rc, report = _run_snap_remove(snapname)
+        self.assertEqual(0, rc, "Failed to install snap %s\nOutput:\n%s" %
+                                (snapname, report))
+
+
 class TestGroup:
     '''Create a temporary test group and remove it again in the dtor.'''
 
@@ -1040,14 +1283,14 @@ class TestGroup:
         self.group = None
         if group:
             if group_exists(group):
-                raise ValueError, 'group name already exists'
+                raise ValueError('group name already exists')
         else:
             while(True):
-                group = random_string(7,lower=lower)
+                group = random_string(7, lower=lower)
                 if not group_exists(group):
                     break
 
-        assert subprocess.call(['groupadd',group]) == 0
+        assert subprocess.call(['groupadd', group]) == 0
         self.group = group
         g = grp.getgrnam(self.group)
         self.gid = g[2]
@@ -1059,6 +1302,7 @@ class TestGroup:
             rc, report = cmd(['groupdel', self.group])
             assert rc == 0
 
+
 class TestUser:
     '''Create a temporary test user and remove it again in the dtor.'''
 
@@ -1072,34 +1316,38 @@ class TestUser:
         self.login = None
 
         if os.geteuid() != 0:
-            raise ValueError, "You must be root to run this test"
+            raise ValueError("You must be root to run this test")
 
         if login:
             if login_exists(login):
-                raise ValueError, 'login name already exists'
+                raise ValueError('login name already exists')
         else:
             while(True):
-                login = 't' + random_string(7,lower=lower)
+                login = 't' + random_string(7, lower=lower)
                 if not login_exists(login):
                     break
 
-        self.salt = random_string(2)
-        self.password = random_string(8,lower=lower)
+        # when fips is enabled, python2.7 crypt.crypt() returns None
+        # for DES salts for being too weak. Force sha256 with "$5$" for
+        # the salt. XXX in python3, the salt is optional and will
+        # generate strong passwords automatically.
+        self.salt = "$5$%s" % random_string(2)
+        self.password = random_string(8, lower=lower)
         self.crypted = crypt.crypt(self.password, self.salt)
 
         creation = ['useradd', '-p', self.crypted]
         if home:
             creation += ['-m']
         if group:
-            creation += ['-G',group]
+            creation += ['-G', group]
         if uidmin:
-            creation += ['-K','UID_MIN=%d'%uidmin]
+            creation += ['-K', 'UID_MIN=%d' % uidmin]
         if shell:
-            creation += ['-s',shell]
+            creation += ['-s', shell]
         creation += [login]
         assert subprocess.call(creation) == 0
         # Set GECOS
-        assert subprocess.call(['usermod','-c','Buddy %s' % (login),login]) == 0
+        assert subprocess.call(['usermod', '-c', 'Buddy %s' % (login), login]) == 0
 
         self.login = login
         p = pwd.getpwnam(self.login)
@@ -1114,8 +1362,8 @@ class TestUser:
 
         if self.login:
             # sanity check the login name so we don't accidentally wipe too much
-            if len(self.login)>3 and not '/' in self.login:
-                subprocess.call(['rm','-rf', '/home/'+self.login, '/var/mail/'+self.login])
+            if len(self.login) > 3 and '/' not in self.login:
+                subprocess.call(['rm', '-rf', '/home/' + self.login, '/var/mail/' + self.login])
             rc, report = cmd(['userdel', '-f', self.login])
             assert rc == 0
 
@@ -1123,13 +1371,99 @@ class TestUser:
         '''Add user to the specified group name'''
         rc, report = cmd(['usermod', '-G', group, self.login])
         if rc != 0:
-            print report
+            print(report)
         assert rc == 0
 
+
+class AddUser:
+    '''Create a temporary test user and remove it again in the dtor.'''
+
+    def __init__(self, login=None, home=True, encrypt_home=False, group=None, lower=False, shell=None):
+        '''Create a new user account with a random password.
+
+        By default, the login name is random, too, but can be explicitly
+        specified with 'login'. By default, a home directory is created, this
+        can be suppressed with 'home=False'.
+
+        This class differs from the TestUser class in that the adduser/deluser
+        tools are used rather than the useradd/user/del tools. The adduser
+        program is the only commandline program that can be used to add a new
+        user with an encrypted home directory. It is possible that the AddUser
+        class may replace the TestUser class in the future.'''
+
+        self.login = None
+
+        if os.geteuid() != 0:
+            raise ValueError("You must be root to run this test")
+
+        if login:
+            if login_exists(login):
+                raise ValueError('login name already exists')
+        else:
+            while(True):
+                login = 't' + random_string(7, lower=True)
+                if not login_exists(login):
+                    break
+
+        self.password = random_string(8, lower=lower)
+
+        creation = ['adduser', '--quiet']
+
+        if not home:
+            creation += ['--no-create-home']
+        elif encrypt_home:
+            creation += ['--encrypt-home']
+
+        if shell:
+            creation += ['--shell', shell]
+
+        creation += ['--gecos', 'Buddy %s' % (login), login]
+
+        child = pexpect.spawn(creation.pop(0), creation, timeout=5)
+        assert child.expect(b'(Enter new UNIX|New) password:') == 0
+        child.sendline(self.password)
+        assert child.expect(b'Retype new (UNIX )?password:') == 0
+        child.sendline(self.password)
+
+        child.wait()
+        child.close()
+        assert child.exitstatus == 0
+        assert child.signalstatus is None
+
+        self.login = login
+
+        if group:
+            assert self.add_to_group(group) == 0
+
+        p = pwd.getpwnam(self.login)
+        self.uid   = p[2]
+        self.gid   = p[3]
+        self.gecos = p[4]
+        self.home  = p[5]
+        self.shell = p[6]
+
+    def __del__(self):
+        '''Remove the created user account.'''
+
+        if self.login:
+            # sanity check the login name so we don't accidentally wipe too much
+            rc, report = cmd(['deluser', '--remove-home', self.login])
+            assert rc == 0
+
+    def add_to_group(self, group):
+        '''Add user to the specified group name'''
+        rc, report = cmd(['adduser', self.login, group])
+        if rc != 0:
+            print(report)
+        assert rc == 0
+
+
 # Timeout handler using alarm() from John P. Speno's Pythonic Avocado
 class TimeoutFunctionException(Exception):
     """Exception to raise on a timeout"""
     pass
+
+
 class TimeoutFunction:
     def __init__(self, function, timeout):
         self.timeout = timeout
@@ -1148,6 +1482,7 @@ class TimeoutFunction:
         signal.alarm(0)
         return result
 
+
 def main():
-    print "hi"
+    print("hi")
     unittest.main()
diff --git a/debian/tests/testsuite b/debian/tests/testsuite
index 47c7a70..29cf597 100644
--- a/debian/tests/testsuite
+++ b/debian/tests/testsuite
@@ -3,5 +3,4 @@
 # Testing open-iscsi
 #-------------------
 set -e
-python2 `dirname $0`/test-open-iscsi.py 2>&1
-
+python3 `dirname $0`/test-open-iscsi.py 2>&1