Merge ~dviererbe/ubuntu/+source/unzip:fix-missing-documentation-and-add-autopkgtest into ubuntu/+source/unzip:ubuntu/devel

[Dominik Viererbe]

[Dominik Viererbe (dviererbe)]

I have a PPA where the changes builds fine: https://launchpad.net/~dviererbe/+archive/ubuntu/unzip6-0-28ubuntu2

I also run successfully the autopkgtests locally with qemu and a fresh autopkgtest-buildvm-ubuntu-cloud mantic image.

[Dominik Viererbe (dviererbe)]

I just updated the changelog (with push force) because of https://bugs.launchpad.net/ubuntu/+source/unzip/+bug/1429939/comments/7

[Christian Ehrhardt  (paelzer)]

My first reaction was "have you submitted to Debian" but this is in fact about a Ubuntu-only delta.

Next I wanted to criticize how much whitespace damage this patch had, but then it is probably as taken from arch-linux. While we are changing it I wonder if we should not:
- find where it is from and mention it as origin if there is any link
- fix the whitespace damage (mostly tailing whitespace, mixed space/tab)
- combined with your fixes submit it back to archlinux

Looking at that I found that it is actually from https://src.fedoraproject.org/rpms/unzip/raw/rawhide/f/unzip-6.0-alt-iconv-utf8.patch

So - if nothing else - that should be mentioned in the dep-3 header.

But I've seen and appreciate that the last change (Updated 2015-02-11 by Marc Deslauriers <email address hidden> to fix buffer overflow in charset_to_intern()) was submitted there.

So I guess fedora is "the upstream" of that delta. To ease long term maintenance I think you should check if that evolved since then and submit your changes there - to then update both and in the future be able to pull their changes as well.

For example there is a follow on patch
https://src.fedoraproject.org/rpms/unzip/raw/rawhide/f/unzip-6.0-alt-iconv-utf8-print.patch

Also the signature changed massively
$ diffstat debian/patches/20-unzip60-alt-iconv-utf8.patch
 unix/unix.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 unix/unxcfg.h | 26 ++++++++++++++++++++++++++
 unzip.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 unzpriv.h | 2 +-
 zipinfo.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 279 insertions(+), 1 deletion(-)

vs
$ diffstat ~/unzip-6.0-alt-iconv-utf8-print.patch
 extract.c | 289 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------
 unzpriv.h | 7 ++++
 2 files changed, 233 insertions(+), 63 deletions(-)

I think this is worth a deeper revisit to patch it once and patch it right - unless you disagree.

review: Needs Information

[Christian Ehrhardt  (paelzer)]

debian/tests/control also has trailing whitespace

debian/tests/smoke-tests has shellcheck reports
SC2164: Use 'cd ... || exit' or 'cd ... || return' in case cd fails.

debian/tests/SmokeTests.py also has a lot of whitespace damage
Since this is new how about throwing your favorite python linter and styler on it until it is silent?

Finally you either have written a lot of tests (thanks) or this started based on some other source.
In that case please link to where the inspiration or file came from.

0aab383... by Dominik Viererbe on 2024-02-22

changelog

[Dominik Viererbe (dviererbe)]

> I think this is worth a deeper revisit to patch it once and patch it right - unless you disagree.
I think so too, but I would like to get these changes uploaded. I created a new bug ticked to address the mentioned concerns.
See LP: #2054625

> debian/tests/control also has trailing whitespace
>
> debian/tests/smoke-tests has shellcheck reports
> SC2164: Use 'cd ... || exit' or 'cd ... || return' in case cd fails.
>
> debian/tests/SmokeTests.py also has a lot of whitespace damage
> Since this is new how about throwing your favorite python linter and styler on it until it is silent?
This is now fixed.

> Finally you either have written a lot of tests (thanks) or [...]
I wrote the test suite myself.

[Dominik Viererbe (dviererbe)]

Build successfully in a PPA:
https://launchpad.net/~dviererbe/+archive/ubuntu/unzip6-0-28ubuntu2/+packages

Get source package with:
$ dget https://launchpad.net/~dviererbe/+archive/ubuntu/unzip6-0-28ubuntu2/+sourcefiles/unzip/6.0-28ubuntu3~ppa1/unzip_6.0-28ubuntu3~ppa1.dsc

48235a1... by Dominik Viererbe on 2024-02-22

  * d/p/29-fix-troff-warning.patch:
    Removes monospace directives to fix troff warnings (LP: #2054670)

[Dominik Viererbe (dviererbe)]

The tests failed, because they detected non empty STDERR output when showing man pages (LP: #2054670). This is a win for the newly added smoke tests, because they caught a regression that would not have been caught otherwise. \o/

I uploaded a patch to the PPA and waiting for publication to rerun the autopkgtests.

[Dominik Viererbe (dviererbe)]

Built in a PPA:
https://launchpad.net/~dviererbe/+archive/ubuntu/unzip6-0-28ubuntu2

Download source package:
$ dget https://launchpad.net/~dviererbe/+archive/ubuntu/unzip6-0-28ubuntu2/+sourcefiles/unzip/6.0-28ubuntu3~ppa4/unzip_6.0-28ubuntu3~ppa4.dsc

Autopkgtest pass:
- amd64 https://autopkgtest.ubuntu.com/results/autopkgtest-noble-dviererbe-unzip6-0-28ubuntu2/noble/amd64/u/unzip/20240222_230310_c7134@/log.gz
- arm64 https://autopkgtest.ubuntu.com/results/autopkgtest-noble-dviererbe-unzip6-0-28ubuntu2/noble/arm64/u/unzip/20240222_225902_f002d@/log.gz
- armhf https://autopkgtest.ubuntu.com/results/autopkgtest-noble-dviererbe-unzip6-0-28ubuntu2/noble/armhf/u/unzip/20240222_231424_286a6@/log.gz
- ppc64el https://autopkgtest.ubuntu.com/results/autopkgtest-noble-dviererbe-unzip6-0-28ubuntu2/noble/ppc64el/u/unzip/20240222_225826_f712e@/log.gz
- s390x https://autopkgtest.ubuntu.com/results/autopkgtest-noble-dviererbe-unzip6-0-28ubuntu2/noble/s390x/u/unzip/20240222_230556_9b89f@/log.gz

Note: The i386 autopkgtest [1] fails, because of a bug that does not correctly satisfy the test dependencies. See LP: #1881504 for more details.

[1] https://autopkgtest.ubuntu.com/results/autopkgtest-noble-dviererbe-unzip6-0-28ubuntu2/noble/i386/u/unzip/20240222_230037_3ba6a@/log.gz

[Dominik Viererbe (dviererbe)]

This is ready for sponsoring.

[Gianfranco Costamagna (costamagnagianfranco)]

review: Approve

diff --git a/debian/changelog b/debian/changelog
index 250dfe6..42bad71 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,18 @@
+unzip (6.0-28ubuntu3) noble; urgency=medium
+
+  * d/t/*: Added autopkgtest (LP: #2023994)
+  * d/p/29-fix-troff-warning.patch:
+    Removes monospace directives to fix troff warnings (LP: #2054670)
+  * d/p/20-unzip60-alt-iconv-utf8.patch 
+    * Refreshed as ab-style patch.
+    * Added documentation for `-I` and `-O` options to `unzip -hh`. 
+    * Added documentation for `-I` and `-O` options to unzip (man/unzip.1) and 
+      zipinfo (man/zipinfo.1) man pages (LP: #138307).
+    * Fixed garbled output when `zipinfo` or `unzip -Z` is called 
+      without arguments (LP: #1429939).
+
+ -- Dominik Viererbe <[e-mail]>  Thu, 22 Feb 2024 02:48:49 +0200
+
 unzip (6.0-28ubuntu2) noble; urgency=medium
 
   * Properly handle Microsoft ZIP64 file (LP: #2051952)
diff --git a/debian/patches/20-unzip60-alt-iconv-utf8.patch b/debian/patches/20-unzip60-alt-iconv-utf8.patch
index b9e3777..3d45dcf 100644
--- a/debian/patches/20-unzip60-alt-iconv-utf8.patch
+++ b/debian/patches/20-unzip60-alt-iconv-utf8.patch
@@ -1,14 +1,18 @@
 From: Giovanni Scafora <giovanni.archlinux.org>
 Subject: unzip files encoded with non-latin, non-unicode file names
-Last-Update: 2015-02-11
+Last-Update: 2024-02-22
 
-Updated 2015-02-11 by Marc Deslauriers <[e-mail]>
-to fix buffer overflow in charset_to_intern()
+* Updated 2015-02-11 by Marc Deslauriers <[e-mail]>
+  to fix buffer overflow in charset_to_intern()
+* Updated 2023-06-15 by Dominik Viererbe <[e-mail]>
+  to add documentation for `-I` and `-O` options (LP: #138307) and fixed
+  garbled output when `zipinfo` or `unzip -Z` is called without arguments
+  (LP: #1429939)
 
-Index: unzip-6.0/unix/unix.c
+Index: unzip/unix/unix.c
 ===================================================================
---- unzip-6.0.orig/unix/unix.c	2015-02-11 08:46:43.675324290 -0500
-+++ unzip-6.0/unix/unix.c	2015-02-11 09:18:04.902081319 -0500
+--- unzip.orig/unix/unix.c	2023-06-15 21:24:46.857092642 +0300
++++ unzip/unix/unix.c	2023-06-15 21:24:46.845092668 +0300
 @@ -30,6 +30,9 @@
  #define UNZIP_INTERNAL
  #include "unzip.h"
@@ -52,7 +56,7 @@ Index: unzip-6.0/unix/unix.c
 +    const char *local_charset;
 +    int i;
 +
-+    /* Make a guess only if OEM_CP not already set. */ 
++    /* Make a guess only if OEM_CP not already set. */
 +    if(*OEM_CP == '\0') {
 +    	local_charset = nl_langinfo(CODESET);
 +    	for(i = 0; i < sizeof(dos_charset_map)/sizeof(CHARSET_MAP); i++)
@@ -122,23 +126,23 @@ Index: unzip-6.0/unix/unix.c
 +{
 +    charset_to_intern(string, ISO_CP);
 +}
-Index: unzip-6.0/unix/unxcfg.h
+Index: unzip/unix/unxcfg.h
 ===================================================================
---- unzip-6.0.orig/unix/unxcfg.h	2015-02-11 08:46:43.675324290 -0500
-+++ unzip-6.0/unix/unxcfg.h	2015-02-11 08:46:43.671324260 -0500
+--- unzip.orig/unix/unxcfg.h	2023-06-15 21:24:46.857092642 +0300
++++ unzip/unix/unxcfg.h	2023-06-15 21:24:46.845092668 +0300
 @@ -228,4 +228,30 @@
  /* wild_dir, dirname, wildname, matchname[], dirnamelen, have_dirname, */
  /*    and notfirstcall are used by do_wild().                          */
  
 +
-+#define MAX_CP_NAME 25 
-+   
++#define MAX_CP_NAME 25
++
 +#ifdef SETLOCALE
 +#  undef SETLOCALE
 +#endif
 +#define SETLOCALE(category, locale) setlocale(category, locale)
 +#include <locale.h>
-+   
++
 +#ifdef _ISO_INTERN
 +#  undef _ISO_INTERN
 +#endif
@@ -155,12 +159,12 @@ Index: unzip-6.0/unix/unxcfg.h
 +void iso_intern(char *);
 +void oem_intern(char *);
 +void init_conversion_charsets(void);
-+   
++
  #endif /* !__unxcfg_h */
-Index: unzip-6.0/unzip.c
+Index: unzip/unzip.c
 ===================================================================
---- unzip-6.0.orig/unzip.c	2015-02-11 08:46:43.675324290 -0500
-+++ unzip-6.0/unzip.c	2015-02-11 08:46:43.675324290 -0500
+--- unzip.orig/unzip.c	2023-06-15 21:24:46.857092642 +0300
++++ unzip/unzip.c	2023-06-15 21:28:32.324638973 +0300
 @@ -327,11 +327,21 @@
    -2  just filenames but allow -h/-t/-z  -l  long Unix \"ls -l\" format\n\
                                           -v  verbose, multi-page format\n";
@@ -168,14 +172,16 @@ Index: unzip-6.0/unzip.c
 +#ifndef UNIX
  static ZCONST char Far ZipInfoUsageLine3[] = "miscellaneous options:\n\
    -h  print header line       -t  print totals for listed files or for all\n\
-   -z  print zipfile comment   -T  print file times in sortable decimal format\
- \n  -C  be case-insensitive   %s\
+-  -z  print zipfile comment   -T  print file times in sortable decimal format\
+-\n  -C  be case-insensitive   %s\
++  -z  print zipfile comment   -T  print file times in sortable decimal format\n\
++  -C  be case-insensitive     %s\
    -x  exclude filenames that follow from listing\n";
 +#else /* UNIX */
 +static ZCONST char Far ZipInfoUsageLine3[] = "miscellaneous options:\n\
 +  -h  print header line       -t  print totals for listed files or for all\n\
-+  -z  print zipfile comment  %c-T%c print file times in sortable decimal format\
-+\n %c-C%c be case-insensitive   %s\
++  -z  print zipfile comment   -T  print file times in sortable decimal format\n\
++  -C  be case-insensitive   %s\
 +  -x  exclude filenames that follow from listing\n\
 +  -O CHARSET  specify a character encoding for DOS, Windows and OS/2 archives\n\
 +  -I CHARSET  specify a character encoding for UNIX and other archives\n";
@@ -220,7 +226,7 @@ Index: unzip-6.0/unzip.c
 +    extern char OEM_CP[MAX_CP_NAME];
 +    extern char ISO_CP[MAX_CP_NAME];
 +#endif
-+    
++
      while (++argv, (--argc > 0 && *argv != NULL && **argv == '-')) {
          s = *argv + 1;
          while ((c = *s++) != 0) {    /* "!= 0":  prevent Turbo C warning */
@@ -237,10 +243,10 @@ Index: unzip-6.0/unzip.c
 +    				} else {
 +    					if(*s) { /* Handle the -Icharset case */
 +    						/* Assume that charsets can't start with a dash to spot arguments misuse */
-+    						if(*s == '-') { 
++    						if(*s == '-') {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -I argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						strncpy(ISO_CP, s, sizeof(ISO_CP));
 +    					} else { /* -I charset */
@@ -248,7 +254,7 @@ Index: unzip-6.0/unzip.c
 +    						if(!(--argc > 0 && *argv != NULL && **argv != '-')) {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -I argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						s = *argv;
 +    						strncpy(ISO_CP, s, sizeof(ISO_CP));
@@ -273,10 +279,10 @@ Index: unzip-6.0/unzip.c
 +    				} else {
 +    					if(*s) { /* Handle the -Ocharset case */
 +    						/* Assume that charsets can't start with a dash to spot arguments misuse */
-+    						if(*s == '-') { 
++    						if(*s == '-') {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -I argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						strncpy(OEM_CP, s, sizeof(OEM_CP));
 +    					} else { /* -O charset */
@@ -284,7 +290,7 @@ Index: unzip-6.0/unzip.c
 +    						if(!(--argc > 0 && *argv != NULL && **argv != '-')) {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -O argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						s = *argv;
 +    						strncpy(OEM_CP, s, sizeof(OEM_CP));
@@ -296,10 +302,37 @@ Index: unzip-6.0/unzip.c
                  case ('p'):    /* pipes:  extract to stdout, no messages */
                      if (negative) {
                          uO.cflag = FALSE;
-Index: unzip-6.0/unzpriv.h
+@@ -2162,6 +2250,7 @@
+   "         ACORN_FTYPE_NFS] Translate filetype and append to name.",
+   "  -i   [MacOS] Ignore filenames in MacOS extra field.  Instead, use name in",
+   "         standard header.",
++  "  -I CHARSET  [UNIX] Specify a character encoding for UNIX and other archives.",
+   "  -j   Junk paths and deposit all files in extraction directory.",
+   "  -J   [BeOS] Junk file attributes.  [MacOS] Ignore MacOS specific info.",
+   "  -K   [AtheOS, BeOS, Unix] Restore SUID/SGID/Tacky file attributes.",
+@@ -2172,6 +2261,8 @@
+   "  -N   [Amiga] Extract file comments as Amiga filenotes.",
+   "  -o   Overwrite existing files without prompting.  Useful with -f.  Use with",
+   "         care.",
++  "  -O CHARSET  [UNIX] Specify a character encoding for DOS, Windows",
++  "                and OS/2 archives.",
+   "  -P p Use password p to decrypt files.  THIS IS INSECURE!  Some OS show",
+   "         command line to other users.",
+   "  -q   Perform operations quietly.  The more q (as in -qq) the quieter.",
+@@ -2264,6 +2355,9 @@
+   "        representing the Unicode character number of the character in hex.",
+   "  -UU [UNICODE]  Disable use of any UTF-8 path information.",
+   "  -z  Include archive comment if any in listing.",
++  "  -O CHARSET  [UNIX] Specify a character encoding for DOS, Windows",
++  "                and OS/2 archives.",
++  "  -I CHARSET  [UNIX] Specify a character encoding for UNIX and other archives.",
+   "",
+   "",
+   "funzip stream extractor:",
+Index: unzip/unzpriv.h
 ===================================================================
---- unzip-6.0.orig/unzpriv.h	2015-02-11 08:46:43.675324290 -0500
-+++ unzip-6.0/unzpriv.h	2015-02-11 08:46:43.675324290 -0500
+--- unzip.orig/unzpriv.h	2023-06-15 21:24:46.857092642 +0300
++++ unzip/unzpriv.h	2023-06-15 21:24:46.849092659 +0300
 @@ -3008,7 +3008,7 @@
           !(((islochdr) || (isuxatt)) && \
             ((hostver) == 25 || (hostver) == 26 || (hostver) == 40))) || \
@@ -309,10 +342,10 @@ Index: unzip-6.0/unzpriv.h
          _OEM_INTERN((string)); \
      } else { \
          _ISO_INTERN((string)); \
-Index: unzip-6.0/zipinfo.c
+Index: unzip/zipinfo.c
 ===================================================================
---- unzip-6.0.orig/zipinfo.c	2015-02-11 08:46:43.675324290 -0500
-+++ unzip-6.0/zipinfo.c	2015-02-11 08:46:43.675324290 -0500
+--- unzip.orig/zipinfo.c	2023-06-15 21:24:46.857092642 +0300
++++ unzip/zipinfo.c	2023-06-15 21:24:46.849092659 +0300
 @@ -457,6 +457,10 @@
      int    tflag_slm=TRUE, tflag_2v=FALSE;
      int    explicit_h=FALSE, explicit_t=FALSE;
@@ -337,10 +370,10 @@ Index: unzip-6.0/zipinfo.c
 +    				} else {
 +    					if(*s) { /* Handle the -Icharset case */
 +    						/* Assume that charsets can't start with a dash to spot arguments misuse */
-+    						if(*s == '-') { 
++    						if(*s == '-') {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -I argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						strncpy(ISO_CP, s, sizeof(ISO_CP));
 +    					} else { /* -I charset */
@@ -348,7 +381,7 @@ Index: unzip-6.0/zipinfo.c
 +    						if(!(--argc > 0 && *argv != NULL && **argv != '-')) {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -I argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						s = *argv;
 +    						strncpy(ISO_CP, s, sizeof(ISO_CP));
@@ -373,10 +406,10 @@ Index: unzip-6.0/zipinfo.c
 +    				} else {
 +    					if(*s) { /* Handle the -Ocharset case */
 +    						/* Assume that charsets can't start with a dash to spot arguments misuse */
-+    						if(*s == '-') { 
++    						if(*s == '-') {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -I argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						strncpy(OEM_CP, s, sizeof(OEM_CP));
 +    					} else { /* -O charset */
@@ -384,7 +417,7 @@ Index: unzip-6.0/zipinfo.c
 +    						if(!(--argc > 0 && *argv != NULL && **argv != '-')) {
 +    	                        Info(slide, 0x401, ((char *)slide,
 +        		                  "error:  a valid character encoding should follow the -O argument"));
-+    	                        return(PK_PARAM); 
++    	                        return(PK_PARAM);
 +    						}
 +    						s = *argv;
 +    						strncpy(OEM_CP, s, sizeof(OEM_CP));
@@ -396,3 +429,40 @@ Index: unzip-6.0/zipinfo.c
                  case 's':      /* default:  shorter "ls -l" type listing */
                      if (negative)
                          uO.lflag = -2, negative = 0;
+Index: unzip/man/unzip.1
+===================================================================
+--- unzip.orig/man/unzip.1	2023-06-15 21:24:46.857092642 +0300
++++ unzip/man/unzip.1	2023-06-15 21:24:46.849092659 +0300
+@@ -325,6 +325,8 @@
+ [MacOS only] ignore filenames stored in MacOS extra fields. Instead, the
+ most compatible filename stored in the generic part of the entry's header
+ is used.
++.IP \fB\-I\fP\ \fICHARSET\fP
++[UNIX only] Specify a character encoding for UNIX and other archives.
+ .TP
+ .B \-j
+ junk paths.  The archive's directory structure is not recreated; all files
+@@ -386,6 +388,8 @@
+ overwrite existing files without prompting.  This is a dangerous option, so
+ use it with care.  (It is often used with \fB\-f\fP, however, and is the only
+ way to overwrite directory EAs under OS/2.)
++.IP \fB\-O\fP\ \fICHARSET\fP
++[UNIX only] Specify a character encoding for DOS, Windows and OS/2 archives.
+ .IP \fB\-P\fP\ \fIpassword\fP
+ use \fIpassword\fP to decrypt encrypted zipfile entries (if any).  \fBTHIS IS
+ INSECURE!\fP  Many multi-user operating systems provide ways for any user to
+Index: unzip/man/zipinfo.1
+===================================================================
+--- unzip.orig/man/zipinfo.1	2023-06-15 21:24:46.857092642 +0300
++++ unzip/man/zipinfo.1	2023-06-15 21:24:46.849092659 +0300
+@@ -174,6 +174,10 @@
+ .TP
+ .B \-z
+ include the archive comment (if any) in the listing.
++.IP \fB\-I\fP\ \fICHARSET\fP
++[UNIX only] Specify a character encoding for UNIX and other archives.
++.IP \fB\-O\fP\ \fICHARSET\fP
++[UNIX only] Specify a character encoding for DOS, Windows and OS/2 archives.
+ .PD
+ .\" =========================================================================
+ .SH "DETAILED DESCRIPTION"
diff --git a/debian/patches/29-fix-troff-warning.patch b/debian/patches/29-fix-troff-warning.patch
new file mode 100644
index 0000000..c6de74a
--- /dev/null
+++ b/debian/patches/29-fix-troff-warning.patch
@@ -0,0 +1,422 @@
+Description: Remove monospace font directives
+ When viewing any man page the following warning is displayed:
+ troff: warning: cannot select font 'C'
+ .
+ This is a new warning. Other projects replaced the \fC directives with
+ nothing, as it is currently a no-op.
+ .
+ Context: \fC sets the font to a monospace font. The terminal can not change
+ the font to any other font than a monospace font. Therefore removing the \fC
+ directives should result in no visual change.
+Author: Dominik Viererbe <[e-mail]>
+Origin: vendor
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/unzip/+bug/2054670
+Forwarded: no
+Last-Update: 2024-02-22
+---
+This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
+--- a/man/funzip.1
++++ b/man/funzip.1
+@@ -115,11 +115,11 @@
+ .SH URL
+ The Info-ZIP home page is currently at
+ .EX
+-\fChttp://www.info-zip.org/pub/infozip/\fR
++http://www.info-zip.org/pub/infozip/
+ .EE
+ or
+ .EX
+-\fCftp://ftp.info-zip.org/pub/infozip/\fR .
++ftp://ftp.info-zip.org/pub/infozip/ .
+ .EE
+ .PD
+ .\" =========================================================================
+--- a/man/unzip.1
++++ b/man/unzip.1
+@@ -65,9 +65,9 @@
+ (Be sure to quote any character that might otherwise be interpreted or
+ modified by the operating system, particularly under Unix and VMS.)  If no
+ matches are found, the specification is assumed to be a literal filename;
+-and if that also fails, the suffix \fC.zip\fR is appended.  Note that
++and if that also fails, the suffix .zip is appended.  Note that
+ self-extracting ZIP files are supported, as with any other ZIP archive;
+-just specify the \fC.exe\fR suffix (if any) explicitly.
++just specify the .exe suffix (if any) explicitly.
+ .IP [\fIfile(s)\fP]
+ An optional list of archive members to be processed, separated by spaces.
+ (VMS versions compiled with VMSCLI defined must delimit files with commas
+@@ -80,7 +80,7 @@
+ Since wildcard characters normally match (`/') directory separators
+ (for exceptions see the option \fB\-W\fP), this option may be used
+ to exclude any files that are in subdirectories.  For
+-example, ``\fCunzip foo *.[ch] -x */*\fR'' would extract all C source files
++example, ``unzip foo *.[ch] -x */*'' would extract all C source files
+ in the main directory, but none in any subdirectories.  Without the \fB\-x\fP
+ option, all C source files in all directories within the zipfile would be
+ extracted.
+@@ -94,8 +94,8 @@
+ specification, or between the \fIfile(s)\fP and the \fB\-x\fP option.
+ The option and directory may be concatenated without any white space
+ between them, but note that this may cause normal shell behavior to be
+-suppressed.  In particular, ``\fC\-d\ ~\fR'' (tilde) is expanded by Unix
+-C shells into the name of the user's home directory, but ``\fC\-d~\fR''
++suppressed.  In particular, ``\-d\ ~'' (tilde) is expanded by Unix
++C shells into the name of the user's home directory, but ``\-d~''
+ is treated as a literal subdirectory ``\fB~\fP'' of the current directory.
+ .\" =========================================================================
+ .SH OPTIONS
+@@ -156,7 +156,7 @@
+ .B \-T
+ [most OSes] set the timestamp on the archive(s) to that of the newest file
+ in each one.  This corresponds to \fIzip\fP's \fB\-go\fP option except that
+-it can be used on wildcard zipfiles (e.g., ``\fCunzip \-T \e*.zip\fR'') and
++it can be used on wildcard zipfiles (e.g., ``unzip \-T \e*.zip'') and
+ is much faster.
+ .TP
+ .B \-u
+@@ -180,7 +180,7 @@
+ size of the encrypted compressed data stream for zipfile entries is reported
+ by the more verbose \fIzipinfo\fP(1) reports, see the separate manual.)
+ When no zipfile is specified (that is, the complete command is simply
+-``\fCunzip \-v\fR''), a diagnostic screen is printed.  In addition to
++``unzip \-v''), a diagnostic screen is printed.  In addition to
+ the normal header with release date and version, \fIunzip\fP lists the
+ home Info-ZIP ftp site and where to find a list of other ftp and non-ftp
+ sites; the target operating system for which it was compiled, as well
+@@ -212,7 +212,7 @@
+ rather than the more common ASCII character set, and NT supports Unicode.)
+ Note that \fIzip\fP's identification of text files is by no means perfect; some
+ ``text'' files may actually be binary and vice versa.  \fIunzip\fP therefore
+-prints ``\fC[text]\fR'' or ``\fC[binary]\fR'' as a visual check for each file
++prints ``[text]'' or ``[binary]'' as a visual check for each file
+ it extracts when using the \fB\-a\fP option.  The \fB\-aa\fP option forces
+ all files to be extracted as text, regardless of the supposed file type.
+ On VMS, see also \fB\-S\fP.
+@@ -246,14 +246,14 @@
+ This feature works similarly to the default behavior of \fIemacs\fP(1)
+ in many locations.
+ .IP
+-Example: the old copy of ``\fCfoo\fR'' is renamed to ``\fCfoo~\fR''.
++Example: the old copy of ``foo'' is renamed to ``foo~''.
+ .IP
+ Warning: Users should be aware that the \fB-B\fP option does not prevent
+ loss of existing data under all circumstances.  For example, when
+-\fIunzip\fP is run in overwrite-all mode, an existing ``\fCfoo~\fR'' file
+-is deleted before \fIunzip\fP attempts to rename ``\fCfoo\fR'' to
+-``\fCfoo~\fR''.  When this rename attempt fails (because of a file locks,
+-insufficient privileges, or ...), the extraction of ``\fCfoo~\fR'' gets
++\fIunzip\fP is run in overwrite-all mode, an existing ``foo~'' file
++is deleted before \fIunzip\fP attempts to rename ``foo'' to
++``foo~''.  When this rename attempt fails (because of a file locks,
++insufficient privileges, or ...), the extraction of ``foo~'' gets
+ cancelled, but the old backup file is already lost.  A similar scenario
+ takes place when the sequence number range for numbered backup files gets
+ exhausted (99999, or 65535 for 16-bit systems).  In this case, the backup
+@@ -269,15 +269,15 @@
+ (notably those under the Unix operating system) and because
+ both ZIP archives and \fIunzip\fP itself are portable across platforms,
+ \fIunzip\fP's default behavior is to match both wildcard and literal
+-filenames case-sensitively.  That is, specifying ``\fCmakefile\fR''
++filenames case-sensitively.  That is, specifying ``makefile''
+ on the command line will \fIonly\fP match ``makefile'' in the archive,
+ not ``Makefile'' or ``MAKEFILE'' (and similarly for wildcard specifications).
+ Since this does not correspond to the behavior of many other
+ operating/file systems (for example, OS/2 HPFS, which preserves
+ mixed case but is not sensitive to it), the \fB\-C\fP option may be
+ used to force all filename matches to be case-insensitive.  In the
+-example above, all three files would then match ``\fCmakefile\fR''
+-(or ``\fCmake*\fR'', or similar).  The \fB\-C\fP option affects
++example above, all three files would then match ``makefile''
++(or ``make*'', or similar).  The \fB\-C\fP option affects
+ file specs in both the normal file list and the excluded-file list (xlist).
+ .IP
+ Please note that the \fB\-C\fP option does neither affect the search for
+@@ -411,7 +411,7 @@
+ .B \-s
+ [OS/2, NT, MS-DOS] convert spaces in filenames to underscores.  Since all PC
+ operating systems allow spaces in filenames, \fIunzip\fP by default extracts
+-filenames with spaces intact (e.g., ``\fCEA\ DATA.\ SF\fR'').  This can be
++filenames with spaces intact (e.g., ``EA\ DATA.\ SF'').  This can be
+ awkward, however, since MS-DOS in particular does not gracefully support
+ spaces in filenames.  Conversion of spaces to underscores can eliminate the
+ awkwardness in some cases.
+@@ -440,7 +440,7 @@
+ .TP
+ .B \-V
+ retain (VMS) file version numbers.  VMS files can be stored with a version
+-number, in the format \fCfile.ext;##\fR.  By default the ``\fC;##\fR'' version
++number, in the format file.ext;##.  By default the ``;##'' version
+ numbers are stripped, but this option allows them to be retained.  (On
+ file systems that limit filenames to particularly short lengths, the version
+ numbers may be truncated or stripped regardless of this option.)
+@@ -629,7 +629,7 @@
+ Some compiled versions of \fIunzip\fP may not support decryption.
+ To check a version for crypt support, either attempt to test or extract
+ an encrypted archive, or else check \fIunzip\fP's diagnostic
+-screen (see the \fB\-v\fP option above) for ``\fC[decryption]\fR'' as one
++screen (see the \fB\-v\fP option above) for ``[decryption]'' as one
+ of the special compilation options.
+ .PP
+ As noted above, the \fB\-P\fP option may be used to supply a password on
+@@ -787,7 +787,7 @@
+ unzip \-ql file.zip
+ .EE
+ .PP
+-(Note that the ``\fC.zip\fR'' is generally not necessary.)  To do a standard
++(Note that the ``.zip'' is generally not necessary.)  To do a standard
+ listing:
+ .PP
+ .EX
+@@ -806,16 +806,16 @@
+ .\" =========================================================================
+ .SH TIPS
+ The current maintainer, being a lazy sort, finds it very useful to define
+-a pair of aliases:  \fCtt\fR for ``\fCunzip \-tq\fR'' and \fCii\fR for
+-``\fCunzip \-Z\fR'' (or ``\fCzipinfo\fR'').  One may then simply type
+-``\fCtt zipfile\fR'' to test an archive, something that is worth making a
+-habit of doing.  With luck \fIunzip\fP will report ``\fCNo errors detected
+-in compressed data of zipfile.zip\fR,'' after which one may breathe a sigh
++a pair of aliases:  tt for ``unzip \-tq'' and ii for
++``unzip \-Z'' (or ``zipinfo'').  One may then simply type
++``tt zipfile'' to test an archive, something that is worth making a
++habit of doing.  With luck \fIunzip\fP will report ``No errors detected
++in compressed data of zipfile.zip,'' after which one may breathe a sigh
+ of relief.
+ .PP
+ The maintainer also finds it useful to set the UNZIP environment variable
+-to ``\fC\-aL\fR'' and is tempted to add ``\fC\-C\fR'' as well.  His ZIPINFO
+-variable is set to ``\fC\-z\fR''.
++to ``\-aL'' and is tempted to add ``\-C'' as well.  His ZIPINFO
++variable is set to ``\-z''.
+ .PD
+ .\" =========================================================================
+ .SH DIAGNOSTICS
+@@ -882,11 +882,11 @@
+ .SH BUGS
+ Multi-part archives are not yet supported, except in conjunction with
+ \fIzip\fP.  (All parts must be concatenated together in order, and then
+-``\fCzip \-F\fR'' (for \fIzip 2.x\fP) or ``\fCzip \-FF\fR'' (for
++``zip \-F'' (for \fIzip 2.x\fP) or ``zip \-FF'' (for
+ \fIzip 3.x\fP) must be performed on the concatenated archive in order to
+ ``fix'' it.  Also, \fIzip 3.0\fP and later can combine multi-part (split)
+-archives into a combined single-file archive using ``\fCzip \-s\- inarchive
+--O outarchive\fR''.  See the \fIzip 3\fP manual page for more information.)
++archives into a combined single-file archive using ``zip \-s\- inarchive
++-O outarchive''.  See the \fIzip 3\fP manual page for more information.)
+ This will definitely be corrected in the next major release.
+ .PP
+ Archives read from standard input are not yet supported, except with
+@@ -933,7 +933,7 @@
+ are newer or older than those on disk.  In practice this may mean a two-pass
+ approach is required:  first unpack the archive normally (with or without
+ freshening/updating existing files), then overwrite just the directory entries
+-(e.g., ``\fCunzip -o foo */\fR'').
++(e.g., ``unzip -o foo */'').
+ .PP
+ [VMS] When extracting to another directory, only the \fI[.foo]\fP syntax is
+ accepted for the \fB\-d\fP option; the simple Unix \fIfoo\fP syntax is
+@@ -954,11 +954,11 @@
+ .SH URL
+ The Info-ZIP home page is currently at
+ .EX
+-\fChttp://www.info-zip.org/pub/infozip/\fR
++http://www.info-zip.org/pub/infozip/
+ .EE
+ or
+ .EX
+-\fCftp://ftp.info-zip.org/pub/infozip/\fR .
++ftp://ftp.info-zip.org/pub/infozip/ .
+ .EE
+ .PD
+ .\" =========================================================================
+--- a/man/unzipsfx.1
++++ b/man/unzipsfx.1
+@@ -89,7 +89,7 @@
+ An optional list of archive members to be excluded from processing.
+ Since wildcard characters match directory separators (`/'), this option
+ may be used to exclude any files that are in subdirectories.  For
+-example, ``\fCfoosfx *.[ch] -x */*\fR'' would extract all C source files
++example, ``foosfx *.[ch] -x */*'' would extract all C source files
+ in the main directory, but none in any subdirectories.  Without the \fB\-x\fP
+ option, all C source files in all directories within the zipfile would be
+ extracted.
+@@ -103,8 +103,8 @@
+ has permission to write to the directory).  The option and directory may
+ be concatenated without any white space between them, but note that this
+ may cause normal shell behavior to be suppressed.  In particular,
+-``\fC\-d\ ~\fR'' (tilde) is expanded by Unix C shells into the name
+-of the user's home directory, but ``\fC\-d~\fR'' is treated as a
++``\-d\ ~'' (tilde) is expanded by Unix C shells into the name
++of the user's home directory, but ``\-d~'' is treated as a
+ literal subdirectory ``\fB~\fP'' of the current directory.
+ .PD
+ .\" =========================================================================
+@@ -213,7 +213,7 @@
+ .EE
+ .PP
+ (MakeSFX is included with the UnZip source distribution and with Amiga
+-binary distributions.  ``\fCzip -A\fR'' doesn't work on Amiga self-extracting
++binary distributions.  ``zip -A'' doesn't work on Amiga self-extracting
+ archives.)
+ To test (or list) the newly created self-extracting archive:
+ .PP
+@@ -235,13 +235,13 @@
+ letters
+ .EE
+ .PP
+-To extract all \fC*.txt\fR files (in Unix quote the `*'):
++To extract all *.txt files (in Unix quote the `*'):
+ .PP
+ .EX
+ letters *.txt
+ .EE
+ .PP
+-To extract everything \fIexcept\fP the \fC*.txt\fR files:
++To extract everything \fIexcept\fP the *.txt files:
+ .PP
+ .EX
+ letters -x *.txt
+@@ -295,7 +295,7 @@
+ VMS users must know how to set up self-extracting archives as foreign
+ commands in order to use any of \fIunzipsfx\fP's options.  This is not
+ necessary for simple extraction, but the command to do so then becomes,
+-e.g., ``\fCrun letters\fR'' (to continue the examples given above).
++e.g., ``run letters'' (to continue the examples given above).
+ .PP
+ \fIunzipsfx\fP on the Amiga requires the use of a special program, MakeSFX,
+ in order to create working self-extracting archives; simple concatenation
+@@ -320,11 +320,11 @@
+ .SH URL
+ The Info-ZIP home page is currently at
+ .EX
+-\fChttp://www.info-zip.org/pub/infozip/\fR
++http://www.info-zip.org/pub/infozip/
+ .EE
+ or
+ .EX
+-\fCftp://ftp.info-zip.org/pub/infozip/\fR .
++ftp://ftp.info-zip.org/pub/infozip/ .
+ .EE
+ .PD
+ .\" =========================================================================
+--- a/man/zipgrep.1
++++ b/man/zipgrep.1
+@@ -32,9 +32,9 @@
+ expression accepted by \fIegrep\fP(1) may be used.
+ .IR file [ .zip ]
+ Path of the ZIP archive.  (Wildcard expressions for the ZIP archive name are
+-not supported.)  If the literal filename is not found, the suffix \fC.zip\fR
++not supported.)  If the literal filename is not found, the suffix .zip
+ is appended.  Note that self-extracting ZIP files are supported, as with any
+-other ZIP archive; just specify the \fC.exe\fR suffix (if any) explicitly.
++other ZIP archive; just specify the .exe suffix (if any) explicitly.
+ .IP [\fIfile(s)\fP]
+ An optional list of archive members to be processed, separated by spaces.
+ If no member files are specified, all members of the ZIP archive are searched.
+@@ -58,7 +58,7 @@
+ An optional list of archive members to be excluded from processing.
+ Since wildcard characters match directory separators (`/'), this option
+ may be used to exclude any files that are in subdirectories.  For
+-example, ``\fCzipgrep grumpy foo *.[ch] -x */*\fR'' would search for the
++example, ``zipgrep grumpy foo *.[ch] -x */*'' would search for the
+ string ``grumpy'' in all C source files in the main directory of the ``foo''
+ archive, but none in any subdirectories.  Without the \fB\-x\fP
+ option, all C source files in all directories within the zipfile would be
+@@ -76,11 +76,11 @@
+ .SH URL
+ The Info-ZIP home page is currently at
+ .EX
+-\fChttp://www.info-zip.org/pub/infozip/\fR
++http://www.info-zip.org/pub/infozip/
+ .EE
+ or
+ .EX
+-\fCftp://ftp.info-zip.org/pub/infozip/\fR .
++ftp://ftp.info-zip.org/pub/infozip/ .
+ .EE
+ .PD
+ .\" =========================================================================
+--- a/man/zipinfo.1
++++ b/man/zipinfo.1
+@@ -54,7 +54,7 @@
+ behavior (with no options) is
+ to list single-line entries for each file in the archive, with header and
+ trailer lines providing summary information for the entire archive.  The
+-format is a cross between Unix ``\fCls \-l\fR'' and ``\fCunzip \-v\fR''
++format is a cross between Unix ``ls \-l'' and ``unzip \-v''
+ output.  See
+ .B "DETAILED DESCRIPTION"
+ below.  Note that \fIzipinfo\fP is the same program as \fIunzip\fP (under
+@@ -87,9 +87,9 @@
+ (Be sure to quote any character that might otherwise be interpreted or
+ modified by the operating system, particularly under Unix and VMS.)  If no
+ matches are found, the specification is assumed to be a literal filename;
+-and if that also fails, the suffix \fC.zip\fR is appended.  Note that
++and if that also fails, the suffix .zip is appended.  Note that
+ self-extracting ZIP files are supported, as with any other ZIP archive;
+-just specify the \fC.exe\fR suffix (if any) explicitly.
++just specify the .exe suffix (if any) explicitly.
+ .IP [\fIfile(s)\fP]
+ An optional list of archive members to be processed, separated by spaces.
+ (VMS versions compiled with VMSCLI defined must delimit files with commas
+@@ -113,16 +113,16 @@
+ useful in cases where the stored filenames are particularly long.
+ .TP
+ .B \-s
+-list zipfile info in short Unix ``\fCls \-l\fR'' format.  This is the default
++list zipfile info in short Unix ``ls \-l'' format.  This is the default
+ behavior; see below.
+ .TP
+ .B \-m
+-list zipfile info in medium Unix ``\fCls \-l\fR'' format.  Identical to the
++list zipfile info in medium Unix ``ls \-l'' format.  Identical to the
+ \fB\-s\fP output, except that the compression factor, expressed as a
+ percentage, is also listed.
+ .TP
+ .B \-l
+-list zipfile info in long Unix ``\fCls \-l\fR'' format.  As with \fB\-m\fP
++list zipfile info in long Unix ``ls \-l'' format.  As with \fB\-m\fP
+ except that the compressed size (in bytes) is printed instead of the
+ compression ratio.
+ .TP
+@@ -294,7 +294,7 @@
+ their total uncompressed size, and their total compressed size (not
+ including any of \fIzip\fP's internal overhead).  If, however, one or
+ more \fIfile(s)\fP are provided, the header and trailer lines are
+-not listed.  This behavior is also similar to that of Unix's ``\fCls \-l\fR'';
++not listed.  This behavior is also similar to that of Unix's ``ls \-l'';
+ it may be overridden by specifying the \fB\-h\fP and \fB\-t\fP options
+ explicitly.
+ In such a case the listing format must also be specified explicitly,
+@@ -334,7 +334,7 @@
+ either of the above.
+ .PP
+ The default listing format, as noted above, corresponds roughly
+-to the "\fCzipinfo \-hst\fR" command (except when individual zipfile members
++to the "zipinfo \-hst" command (except when individual zipfile members
+ are specified).
+ A user who prefers the long-listing format (\fB\-l\fP) can make use of the
+ \fIzipinfo\fP's environment variable to change this default:
+@@ -355,7 +355,7 @@
+ If, in addition, the user dislikes the trailer line, \fIzipinfo\fP's
+ concept of ``negative options'' may be used to override the default
+ inclusion of the line.  This is accomplished by preceding the undesired
+-option with one or more minuses:  e.g., ``\fC\-l\-t\fR'' or ``\fC\-\-tl\fR'',
++option with one or more minuses:  e.g., ``\-l\-t'' or ``\-\-tl'',
+ in this example.  The first hyphen is the regular switch character, but the
+ one before the `t' is a minus sign.  The dual use of hyphens may seem a
+ little awkward, but it's reasonably intuitive nonetheless:  simply ignore
+@@ -507,11 +507,11 @@
+ .SH URL
+ The Info-ZIP home page is currently at
+ .EX
+-\fChttp://www.info-zip.org/pub/infozip/\fR
++http://www.info-zip.org/pub/infozip/
+ .EE
+ or
+ .EX
+-\fCftp://ftp.info-zip.org/pub/infozip/\fR .
++ftp://ftp.info-zip.org/pub/infozip/ .
+ .EE
+ .PD
+ .\" =========================================================================
diff --git a/debian/patches/series b/debian/patches/series
index 3793f99..2a5353a 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -28,3 +28,4 @@
 27-zipgrep-avoid-test-errors.patch
 28-cve-2022-0529-and-cve-2022-0530.patch
 handle_windows_zip64.patch
+29-fix-troff-warning.patch
diff --git a/debian/tests/SmokeTests.py b/debian/tests/SmokeTests.py
new file mode 100755
index 0000000..86c9d33
--- /dev/null
+++ b/debian/tests/SmokeTests.py
@@ -0,0 +1,1422 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import shutil
+import subprocess
+import unittest
+
+# Debug Flag:
+# When set to `False` the `tearDown` methods of the TestCases will not delete
+# the temporary test directories.
+CleanUp = True
+
+
+def diff(expected: str, actual: str) -> str:
+    """
+    Wrapper function for the shell command 'diff' to compare and show the\
+    difference of two strings.
+
+    Args:
+        expected: The string value that was expected.
+        actual: The string that was actually produced and that should be\
+                compared against expected.
+
+    Returns:
+        str: A string representation in a diff format that shows the\
+             difference between `expected` and `actual`.
+    """
+
+    bash_command = f'''/usr/bin/env bash -c "printf -- 'diff EXPECTED ACTUAL\\n---EXPECTED\\n+++ACTUAL\\n'; diff --minimal --unified <(cat << 'EOF'
+{expected}
+EOF
+) <(cat << 'EOF'
+{actual}
+EOF
+) | tail -n +3"'''
+
+    try:
+        output = subprocess.check_output(bash_command,
+                                         shell=True, stderr=subprocess.STDOUT)
+        return output.decode()
+    except subprocess.CalledProcessError as error:
+        # Error can safely be ignored, because diff returns with failure
+        # exit code if expected and actual have no difference.
+        return error.output.decode()
+
+
+def mktemp(createDirectory: bool = False,
+           basePath: str | None = None,
+           template: str = "tmp.XXXXXXXXXX") -> str:
+    """
+    Create a temporary file or directory and returns its path.
+
+    Remarks:
+        Files are created u+rw, and directories u+rwx, minus umask\
+        restrictions.
+
+        See `$ man mktemp` for more details.
+
+    Args:
+        createDirectory: If True create a directory, otherwise a file.\
+                         (default: `False`)
+        basePath: Base path of the provided `template`; if `None`, use current\
+                  working directory. (default: `None`)
+        template: Template of the created temporary file/directory. `X`s will\
+                  be replaced by a random alpha-numeric character.\
+                  `template` must contain at least 3 consecutive 'X's in last\
+                  component. (default: `"tmp.XXXXXXXXXX"`)
+
+    Returns:
+        str: Absolute path of the created  temporary  file  or directory.
+    """
+
+    command = "mktemp "
+
+    if createDirectory:
+        command += "--directory "
+
+    if basePath is None:
+        command += "--tmpdir=\"$PWD\" "
+    else:
+        command += f"--tmpdir='{str(basePath)}' "
+
+    command += f"'{str(template)}'"
+
+    return subprocess.check_output(command,
+                                   shell=True, encoding="utf-8").strip()
+
+
+def deleteRecursiveWithForce(path: str) -> None:
+    """
+    Deletes a directory or file for a given path recursively and forcefully.
+
+    Args:
+        path: Path to the file/directory to delete.
+
+    Returns:
+        `None`
+    """
+
+    subprocess.check_call(f"rm -rf '{path}'", shell=True)
+
+
+def dd(inputFile: str,
+       outputFile: str,
+       blockSize: str | int,
+       blockCount: str | int,
+       cwd: str | None = None) -> None:
+    """
+    Convert and copy a file; Wrapper function of the shell command `dd`.
+
+    Args:
+        inputFile: The path of the file where `dd` should read the data from.
+        outputFile: The path of the file where `dd` should write the data to.
+        blockSize: The size of a block limits the amount of reads or writes\
+                   at a time in byte.
+        blockCount: Copy the specified amount of blocks to the output file.
+        cwd: Path of the working directory where `dd` will be executed.\
+             If `None` is provided the working directory of the test script\
+             process will be used. (default: `None`)
+
+    Returns:
+        `None`
+    """
+
+    command = ("dd"
+               f" if='{inputFile}'"
+               f" of='{outputFile}'"
+               f" bs='{str(blockSize)}'"
+               f" count='{str(blockCount)}'"
+               " status='none'")
+
+    subprocess.check_call(command, cwd=cwd, shell=True)
+
+
+def ddRandom(outputFile: str,
+             outputFileSizeInMebibyte: int,
+             cwd: str | None = None) -> None:
+    """
+    Writes random data to a file using the shell command `dd`.
+
+    Args:
+        outputFile: The path of the file where the random data should be\
+                    written to.
+        outputFileSizeInMebibyte: The amount of random data in MiB (Mebibyte)\
+                                  that should be copied into the output file.
+        cwd: Path of the working directory where `dd` will be executed.\
+             If `None` is provided the working directory of the test script\
+             process will be used. (default: `None`)
+
+    Returns:
+        `None`
+    """
+
+    dd(inputFile='/dev/random',
+       outputFile=outputFile,
+       blockSize=1024,
+       blockCount=1024 * outputFileSizeInMebibyte,
+       cwd=cwd)
+
+
+def zip(zipArchive: str,
+        fileToAdd: str,
+        password: str | None = None,
+        cwd: str | None = None) -> None:
+    """
+    Adds a file to a zip archive (and creates it if it does not exist).\
+    Wrapper function of the shell command `zip`.
+
+    Args:
+        zipArchive: Path of the zip archive, the file should be added to.\
+                    The file will be created if it does not exists.
+        fileToAdd: Path of the file to add to the zip archive.
+        password: Used to encrypt zipfile entries. If `None` is provided, the\
+                  zip archive will not be encrypted. (default: `None`)
+        cwd: Path of the working directory where `zip` will be executed.\
+             If `None` is provided the working directory of the test script\
+             process will be used. (default: `None`)
+
+    Returns:
+        `None`
+    """
+
+    command = "zip -q"
+    if password is not None:
+        command += f" --password '{password}'"
+    command += f" '{zipArchive}' '{fileToAdd}'"
+
+    subprocess.check_call(command, cwd=cwd, shell=True)
+
+
+def prependUnZipSFX(zipArchive: str,
+                    outputFile: str,
+                    cwd: str | None = None) -> None:
+    """
+    Prepends UnZipSFX in fornt of a zip archive and configures it to be\
+    ready to run.
+
+    Args:
+        zipArchive: Path of the zip archive, UnZipSFX should be prepended to.
+        outputFile: Path of the resulting file (UnZipSFX + zip archive).
+        cwd: Path of the working directory where the operation will be\
+             executed. If `None` is provided the working directory of the\
+             test script process will be used. (default: `None`)
+
+    Returns:
+        `None`
+    """
+
+    subprocess.check_call(f"cat $(which unzipsfx) '{zipArchive}'"
+                          f" > '{outputFile}'", cwd=cwd, shell=True)
+    subprocess.check_call(f"chmod u+x '{outputFile}'", cwd=cwd, shell=True)
+    subprocess.check_call(f"zip -Aq '{outputFile}'", cwd=cwd, shell=True)
+
+
+class ShellCommandResult(object):
+    """
+    Holds the result of a shell command and provides convenience functions\
+    to run assertions on them.
+    """
+
+    def __init__(self,
+                 command: str,
+                 exitcode: int,
+                 stdout: str,
+                 stderr: str) -> None:
+        self.command = command
+        self.exitcode = exitcode
+        self.stdout = stdout
+        self.stderr = stderr
+
+    def __CombinedOutput(self) -> str:
+        result = ""
+
+        if self.stdout != "":
+            result += "\n\nSTDOUT:\n" + self.stdout
+
+        if self.stderr != "":
+            result += "\n\nSTDERR:\n" + self.stderr
+
+        return result
+
+    def __AssertOutputStartsWith(self,
+                                 output: str,
+                                 outputName: str,
+                                 expectedStart: str) -> None:
+        difference = diff(expectedStart, output[:len(expectedStart)])
+
+        assert len(output) >= len(expectedStart), \
+               (f"Length of {outputName} output is smaller than expected!"
+                f"{self.__CombinedOutput()}\n\n{difference}")
+
+        for i in range(len(expectedStart)):
+            assert output[i] == expectedStart[i], \
+                   (f"{outputName} output does not start with expected output!"
+                    f"\n\nAt postion {i} character '{expectedStart[i]}' "
+                    f"({hex(ord(expectedStart[i]))}) was expected, "
+                    f"got '{output[i]}' "
+                    f"({hex(ord(output[i]))}).\n\n{difference}")
+
+    def AssertSuccessExitCode(self) -> None:
+        """
+        Fail the test unless the exit code of the shell command was `0`.
+        """
+
+        assert self.exitcode == 0, \
+               ("Expected Success Exit Code (== 0), "
+                f"got {self.exitcode}!{self.__CombinedOutput()}")
+
+    def AssertFailureExitCode(self) -> None:
+        """
+        Fail the test unless the exit code of the shell command was NOT `0`.
+        """
+
+        assert self.exitcode != 0, \
+               ("Expected Failure Exit Code (!= 0), "
+                f"got {self.exitcode}!{self.__CombinedOutput()}")
+
+    def AssertStdoutIsEmpty(self) -> None:
+        """
+        Fail the test unless the standard output of the shell command\
+        was empty.
+        """
+
+        assert self.stdout == "", \
+               ("STDOUT output is not empty! "
+                f"Expected was an empty output.{self.__CombinedOutput()}")
+
+    def AssertStdoutIsNotEmpty(self) -> None:
+        """
+        Fail the test unless the standard output of the shell command\
+        was NOT empty.
+        """
+
+        assert self.stdout != "", \
+               ("STDOUT output is empty! "
+                f"Expected was a non-empty output.{self.__CombinedOutput()}")
+
+    def AssertStdoutEquals(self, expectedOutput) -> None:
+        """
+        Fail the test unless the standard output of the shell command\
+        equals an expected value.
+        """
+
+        assert self.stdout == expectedOutput, \
+               ("Unexpected STDOUT output!"
+                f"{self.__CombinedOutput()}\n\n"
+                f"{diff(expectedOutput, self.stdout)}")
+
+    def AssertStdoutStartsWith(self, expectedStart: str) -> None:
+        """
+        Fail the test unless the standard output of the shell command\
+        starts with an expected value.
+        """
+
+        self.__AssertOutputStartsWith(self.stdout, "STDOUT", expectedStart)
+
+    def AssertStderrIsEmpty(self) -> None:
+        """
+        Fail the test unless the standard error output of the shell command\
+        was empty.
+        """
+
+        assert self.stderr == "", \
+            ("STDERR output is not empty! "
+             f"Expected was an empty output.{self.__CombinedOutput()}")
+
+    def AssertStderrIsNotEmpty(self) -> None:
+        """
+        Fail the test unless the standard error output of the shell command\
+        was NOT empty.
+        """
+
+        assert self.stderr != "", \
+            ("STDERR output is empty! "
+             f"Expected was a non-empty output.{self.__CombinedOutput()}")
+
+    def AssertStderrEquals(self, expectedOutput) -> None:
+        """
+        Fail the test unless the standard error output of the shell command\
+        equals an expected value.
+        """
+
+        assert self.stderr == expectedOutput, \
+            ("Unexpected STDERR output!"
+             f"{self.__CombinedOutput()}\n\n"
+             f"{diff(expectedOutput, self.stderr)}")
+
+    def AssertStderrStartsWith(self, expectedStart: str) -> None:
+        """
+        Fail the test unless the standard error output of the shell command\
+        starts with an expected value.
+        """
+
+        self.__AssertOutputStartsWith(self.stderr, "STDERR", expectedStart)
+
+
+def RunShellCommand(command: str,
+                    cwd: str | None = None) -> ShellCommandResult:
+    """
+    Runs a shell command and wraps the result it in a `ShellCommandResult`\
+    instance.
+
+    Args:
+        command: The `/bin/sh` command that should be executed.
+        cwd: The path of the working directory where the shell command\
+             should be executed. If `None` is provided the working directory\
+             of the test script process will be used. (default: `None`)
+
+    Returns:
+        ShellCommandResult: Instance that holds the result of the executed\
+                            shell command.
+    """
+
+    result = subprocess.run(
+        args=command,
+        shell=True,
+        capture_output=True,
+        text=True,
+        encoding='utf-8',
+        cwd=cwd,
+        env={
+            "LANG": "C",
+            "LANGUAGE": "C",
+            "LC_ADDRESS": "C",
+            "LC_IDENTIFICATION": "C",
+            "LC_MEASUREMENT": "C",
+            "LC_MONETARY": "C",
+            "LC_NAME": "C",
+            "LC_NUMERIC": "C",
+            "LC_PAPER": "C",
+            "LC_TELEPHONE": "C",
+            "LC_TIME": "C",
+        })
+
+    return ShellCommandResult(command,
+                              result.returncode, result.stdout, result.stderr)
+
+
+class ManPageTestCases(unittest.TestCase):
+    def AssertManPageContainsContent(self, command: str) -> None:
+        """
+        Fails unless a manpage for the command `command` exists, is not-empty\
+        and starts with the name of the command in upper case.
+        """
+
+        result = RunShellCommand("man -P cat " + command)
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutStartsWith(command.upper())
+
+    def test_When_RunningFUnZipManpage_Expect_NonEmptyManPage(self):
+        """
+        Executing the `man funzip` command should print existing (non-empty)\
+        usage/help information to STDOUT.
+        """
+
+        self.AssertManPageContainsContent("funzip")
+
+    def test_When_RunningUnZipManpage_Expect_NonEmptyManPage(self):
+        """
+        Executing the `man unzip` command should print existing (non-empty)\
+        usage/help information to STDOUT.
+        """
+
+        self.AssertManPageContainsContent("unzip")
+
+    def test_When_RunningUnZipSFXManpage_Expect_NonEmptyManPage(self):
+        """
+        Executing the `man funzipsfx` command should print existing\
+        (non-empty) usage/help information to STDOUT.
+        """
+
+        self.AssertManPageContainsContent("unzipsfx")
+
+    def test_When_RunningZipGrepManpage_Expect_NonEmptyManPage(self):
+        """
+        Executing the `man zipgrep` command should print existing (non-empty)\
+        usage/help information to STDOUT.
+        """
+
+        self.AssertManPageContainsContent("zipgrep")
+
+    def test_When_RunningZipInfoManpage_Expect_NonEmptyManPage(self):
+        """
+        Executing the `man zipinfo` command should print existing (non-empty)\
+        usage/help information to STDOUT.
+        """
+
+        self.AssertManPageContainsContent("zipinfo")
+
+
+class UsageInfoTestCases(unittest.TestCase):
+    """
+    The tests of this class test if the commands provided by the unzip\
+    source packages show basic usage informations.
+    """
+
+    def test_When_RunningFUnZipCommandWithoutParameters_Expect_NonEmptyOutput(self) -> None:  # noqa: E501
+        """
+        Executing the `funzip` command without any additional parameters\
+        should print short usage/help information to STDERR.
+        """
+
+        # Arrange
+        # coyprightHeader = "fUnZip (filter UnZip), version 3.95 of 20 January 2009\n"  # noqa: E501
+
+        # Act
+        result = RunShellCommand("funzip")
+
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStdoutIsEmpty()
+        result.AssertStderrIsNotEmpty()
+
+        # If unzip command is not called in tty mode it will not print the
+        # coypright header. When your run this script locally it would pass,
+        # but the autopkgtest runner has no tty attached.
+        # I could not figure out how to emulate this.
+        # result.AssertStderrStartsWith(coyprightHeader)
+
+    def test_When_RunningUnZipCommandWithoutParameters_Expect_NonEmptyOutput(self) -> None:  # noqa: E501
+        """
+        Executing the `unzip` command without any additional parameters\
+        should print short usage/help information to STDOUT.
+        """
+
+        # Arrange
+        coyprightHeader = "UnZip 6.00 of 20 April 2009, by Debian. Original by Info-ZIP.\n"  # noqa: E501
+
+        # Act
+        result = RunShellCommand("unzip")
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutStartsWith(coyprightHeader)
+
+    def test_When_RunningUnZipCommandWithHH_Expect_DisplayExtendedHelp(self) -> None:  # noqa: E501
+        """
+        Executing the `unzip` command without any additional parameters should\
+        print short usage/help information to STDOUT.
+        """
+
+        # Arrange
+        header = ("\nExtended Help for UnZip\n\n"
+                  "See the UnZip Manual for more detailed help\n\n\n")
+
+        # Act
+        result = RunShellCommand("unzip -hh")
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutStartsWith(header)
+
+    def test_When_RunningUnZipSFXCommandWithoutParameters_Expect_NonEmptyOutput(self) -> None:  # noqa: E501
+        """
+        Executing the `unzipsfx` command without any additional parameters\
+        should print short usage/help information to STDERR.
+        """
+
+        # Arrange
+        coyprightHeader = "UnZipSFX 6.00 of 20 April 2009, by Info-ZIP (http://www.info-zip.org).\n"  # noqa: E501
+
+        # Act
+        result = RunShellCommand("unzipsfx")
+
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsNotEmpty()
+        result.AssertStdoutStartsWith(coyprightHeader)
+
+    def test_When_RunningZipGrepCommandWithoutParameters_Expect_NonEmptyOutput(self) -> None:  # noqa: E501
+        """
+        Executing the `zipgrep` command without any additional parameters\
+        should print short usage/help information to STDOUT.
+        """
+
+        # Arrange
+        expectedOutput = ("usage: zipgrep [egrep_options] pattern zipfile [members...]\n"   # noqa: E501
+                          "Uses unzip and egrep to search the zip members for a string or pattern.\n")  # noqa: E501
+
+        # Act
+        result = RunShellCommand("zipgrep")
+
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutEquals(expectedOutput)
+
+    def test_When_RunningZipInfoCommandWithoutParameters_Expect_NonEmptyOutput(self) -> None:  # noqa: E501
+        """
+        Executing the `zipinfo` command without any additional parameters\
+        should print short usage/help information to STDOUT.
+        """
+
+        # Arrange
+        coyprightHeader = "ZipInfo 3.00 of 20 April 2009, by Greg Roelofs and the Info-ZIP group.\n"  # noqa: E501
+
+        # Act
+        result = RunShellCommand("zipinfo")
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutStartsWith(coyprightHeader)
+
+
+class SingleFileZipTestCases(unittest.TestCase):
+    """
+    The tests of this class test if the commands provided by the unzip\
+    source packages can handle a zip archive with a simple single file.
+    """
+
+    ExampleFileName = "example.txt"
+    ExampleFileContent = "Hello Zip!"
+    SingleFileZipName = "single-file.zip"
+
+    @property
+    def ExampleFilePath(self) -> str:
+        return self.WorkingDirectory + "/" + self.ExampleFileName
+
+    def CreateTemporaryWorkingDirectory(self) -> None:
+        self.WorkingDirectory = mktemp(createDirectory=True)
+
+    def CreateExampleFile(self):
+        with open(self.ExampleFilePath, "w") as file:
+            file.write(self.ExampleFileContent)
+
+    def DeleteExampleFile(self):
+        os.remove(self.ExampleFilePath)
+
+    def CreateSingleFileZipArchive(self):
+        self.CreateExampleFile()
+
+        zip(zipArchive=self.SingleFileZipName,
+            fileToAdd=self.ExampleFileName,
+            cwd=self.WorkingDirectory)
+
+    def setUp(self) -> None:
+        self.CreateTemporaryWorkingDirectory()
+        self.CreateSingleFileZipArchive()
+
+    def tearDown(self) -> None:
+        if CleanUp:
+            deleteRecursiveWithForce(self.WorkingDirectory)
+
+    def AssertExampleFileExists(self) -> None:
+        exampleFilePath = self.ExampleFilePath
+
+        self.assertTrue(os.path.exists(exampleFilePath),
+                        msg="Example file does not exist!")
+
+        with open(exampleFilePath, 'r') as file:
+            fileContent = file.read()
+            self.assertEqual(fileContent, self.ExampleFileContent,
+                             msg="Example file has unexpected content!")
+
+    def test_When_FUnZipIsCalledWithAZipArchiveThatContainsOneFile_Expect_PrintsContentOfSingleFile(self) -> None:  # noqa: E501
+        """
+        When the `funzip` is called with a zip archive that contains one file.\
+        `funzip` should print the content of the file to STDOUT.
+        """
+
+        # Arrange
+        pass
+
+        # Act
+        result = RunShellCommand(f"funzip ./{self.SingleFileZipName}",
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutEquals(self.ExampleFileContent)
+
+    def test_When_UnZipIsCalledWithAZipArchiveThatContainsOneFile_Expect_ExtractsSingleFile(self) -> None:  # noqa: E501
+        """
+        When the `unzip` is called with a zip archive that contains one file.\
+        `unzip` should extract the single file.
+        """
+
+        # Arrange
+        self.DeleteExampleFile()
+
+        # Act
+        result = RunShellCommand(f"unzip ./{self.SingleFileZipName}",
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertExampleFileExists()
+
+    def test_When_UnZipSFXIsPrependedToAZipArchiveThatContainsOneFileAndCalled_Expect_ExtractsSingleFile(self) -> None:  # noqa: E501
+        """
+        When the `unzipsfx` is prepended in front of a zip archive that\
+        contains one file, it should extract the single file.
+        """
+
+        # Arrange
+        self.DeleteExampleFile()
+        prependUnZipSFX(zipArchive=self.SingleFileZipName,
+                        outputFile="single-file-zip",
+                        cwd=self.WorkingDirectory)
+        # Act
+        result = RunShellCommand("./single-file-zip",
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertExampleFileExists()
+
+    def test_When_ZipInfoIsCalledWithAZipArchiveThatContainsOneFileAndNoAdditionalParameters_Expect_PrintUnixStyleFileListThatContainsSingleFile(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipinfo` is called with a zip archive that\
+        contains only one file and no additional parameters. It is expected\
+        that `unzip` will print a unix style file list\
+        (like `ls -l` containing only the single file.)
+        """
+
+        # Arrange
+        zipFileNameAsRegex = re.escape(self.SingleFileZipName)
+        exampleFileNameAsRegex = re.escape(self.ExampleFileName)
+        pattern = re.compile(rf"^Archive:  ./{zipFileNameAsRegex}\nZip file size: \d+ bytes, number of entries: 1\n-rw-rw-r--.*{exampleFileNameAsRegex}\n1 file, \d+ bytes uncompressed, \d+ bytes compressed: .*%$")  # noqa: E501
+
+        # Act
+        result = RunShellCommand(f"zipinfo ./{self.SingleFileZipName}",
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        self.assertRegex(result.stdout, pattern,
+                         msg="ZipInfo did not show the expected output.")
+
+    def test_When_ZipInfoIsCalledWithAZipArchiveThatContainsOneFileAndDash1_Expect_PrintSingleFileName(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipinfo` is called with a zip archive that\
+        contains only one file and the parameter `-1`. It is expected that\
+        `unzip` will print the name of the single file.)
+        """
+
+        # Arrange
+        pass
+
+        # Act
+        result = RunShellCommand(f"zipinfo -1 ./{self.SingleFileZipName}",
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutEquals(f"{self.ExampleFileName}\n")
+
+    def test_When_ZipGrepIsCalledWithAZipArchiveThatContainsOneFileAndAPatternThatMatchesTheContentOfTheSingleFile_Expect_ReturnSingleFile(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipgrep` is called with a zip archive that\
+        contains only one file and an egrep pattern that matches the single\
+        file content, it should return a reference to the single file.
+        """
+
+        # Arrange
+        pass
+
+        # Act
+        result = RunShellCommand(f"zipgrep '{self.ExampleFileContent}' "
+                                 f"./{self.SingleFileZipName} "
+                                 f"{self.ExampleFileName}",
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutEquals(f"{self.ExampleFileName}:"
+                                  f"{self.ExampleFileContent}\n")
+
+
+class MultiFileZipTestCases(unittest.TestCase):
+    """
+    The tests of this class test if the commands provided by the unzip\
+    source packages can handle a zip archive with a multiple files.
+    """
+
+    FileAmount = 10
+    MultiFileZipFileName = "multi-file.zip"
+
+    def CreateTemporaryWorkingDirectory(self) -> None:
+        self.WorkingDirectory = mktemp(createDirectory=True)
+
+    def TestFilePath(self, suffix, absolutePath: bool = False) -> str:
+        path = "test-file_" + str(suffix) + ".txt"
+
+        if absolutePath:
+            path = self.WorkingDirectory + "/" + path
+
+        return path
+
+    def CreateMultiFileZipArchive(self) -> None:
+        for i in range(self.FileAmount):
+            testFilePath = self.TestFilePath(i, absolutePath=False)
+
+            ddRandom(outputFile=testFilePath,
+                     outputFileSizeInMebibyte=1,
+                     cwd=self.WorkingDirectory)
+
+            zip(zipArchive=self.MultiFileZipFileName,
+                fileToAdd=testFilePath,
+                cwd=self.WorkingDirectory)
+
+            shutil.move(src=f"{self.WorkingDirectory}/{testFilePath}",
+                        dst=f"{self.WorkingDirectory}/{testFilePath}.backup")
+
+    def AssertExtractedFileEqualsOriginal(self, i) -> None:
+        testFileName = self.TestFilePath(i, absolutePath=False)
+        testFilePath = self.TestFilePath(i, absolutePath=True)
+        originalTestFilePath = testFilePath + ".backup"
+
+        self.assertTrue(os.path.exists(testFilePath),
+                        msg=f"'{testFileName}' was not extracted.")
+
+        self.assertEqual(
+            os.path.getsize(testFilePath),
+            os.path.getsize(originalTestFilePath),
+            msg="Extracted File {testFileName} does not match "
+                "the original file size.")
+
+        # compare file content:
+        with open(testFilePath, 'rb') as originalFile, \
+             open(originalTestFilePath, 'rb') as extractedFile:
+            while True:
+                block1 = originalFile.read(1024)
+                block2 = extractedFile.read(1024)
+
+                self.assertTrue(block1 == block2,
+                                msg=f"Extracted File {testFileName} does not "
+                                    f"match the original file content.")
+
+                # Reached the end of both files without finding any differences
+                if not block1:
+                    break
+
+    def AssertAllFilesExtractedFromMultiFileZipArchive(self):
+        for i in range(self.FileAmount):
+            self.AssertExtractedFileEqualsOriginal(i)
+
+    def setUp(self) -> None:
+        self.CreateTemporaryWorkingDirectory()
+        self.CreateMultiFileZipArchive()
+
+    def tearDown(self) -> None:
+        if CleanUp:
+            deleteRecursiveWithForce(self.WorkingDirectory)
+
+    def test_When_FUnZipIsCalledWithMultiFileArchive_Expect_PrintContentOfFirstFile(self) -> None:  # noqa: E501
+        """
+        When the shell command `funzip` is called with a multi-file\
+        zip archive, it is expected that it prints the content of the\
+        first file contained in the multi-file archive to STDOUT.
+        """
+
+        # Arrange
+        testFilePath = self.TestFilePath(0, absolutePath=False)
+
+        # Act
+        result = RunShellCommand(f"funzip '{self.MultiFileZipFileName}' > "
+                                 f"'{testFilePath}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertExtractedFileEqualsOriginal(0)
+
+    def test_When_UnZipIsCalledWithMultiFileArchive_Expect_ExtractsFilesContainedInMultifileArchive(self) -> None:  # noqa: E501
+        """
+        When the shell command `unzip` is called with a multi-file\
+        zip archive, it is expected that it extracts the files contained\
+        in the multi-file archive.
+        """
+
+        # Arrange
+        pass
+
+        # Act
+        result = RunShellCommand(f"unzip '{self.MultiFileZipFileName}'",
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertAllFilesExtractedFromMultiFileZipArchive()
+
+    def test_When_UnZipSFXIsPrependedToMultiFileArchive_Expect_(self) -> None:
+        """
+        When the `unzipsfx` is prepended in front of a multi-file\
+        zip archive, it is expected that it extracts the files contained\
+        in the multi-file archive when it is called.
+        """
+
+        # Arrange
+        prependUnZipSFX(zipArchive=self.MultiFileZipFileName,
+                        outputFile="multi-file-zip",
+                        cwd=self.WorkingDirectory)
+
+        # Act
+        result = RunShellCommand("./multi-file-zip", cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertAllFilesExtractedFromMultiFileZipArchive()
+
+    def test_When_ZipGrepIsCalledWithMultiFileArchiveAndPattern_Expect_FindsFilesContainedInTheMultiFileArchive(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipgrep` is called with a multi-file\
+        zip archive and a pattern, it is expected that it find the files\
+        with the pattern contained in the multi-file archive and prints\
+        it as a list to STDOUT.
+        """
+
+        # Arrange
+        fileNameAsRegex = re.escape(self.TestFilePath("\\d+", absolutePath=False))  # noqa: E501
+
+        pattern = re.compile(f"^({fileNameAsRegex}:X\n)*$")
+
+        # Act
+        result = RunShellCommand(f"zipgrep -o 'X' '{self.MultiFileZipFileName}'",  # noqa: E501
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        self.assertRegex(result.stdout, pattern)
+
+    def test_When_UsingZipInfoWithoutAdditionalParametersForMultiFileZipArchive_Expect_UnixLsDashLListOfContainedFiles(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipinfo` is called with a multi-file\
+        zip archive and no additional parameters it is expected that it\
+        will list the contained files as a unix style file list\
+        (like `ls -l`) to STDOUT.
+        """
+
+        # Arrange
+        regex = rf"^Archive:  multi-file.zip\nZip file size: \d+ bytes, number of entries: {str(self.FileAmount)}\n"  # noqa: E501
+        for i in range(self.FileAmount):
+            filenameAsRegex = re.escape(self.TestFilePath(i))
+            regex += rf"-rw-rw-r--.*{filenameAsRegex}\n"
+        regex += rf"{str(self.FileAmount)} files, \d+ bytes uncompressed, \d+ bytes compressed: .*%$"  # noqa: E501
+
+        pattern = re.compile(regex)
+
+        # Act
+        result = RunShellCommand("zipinfo " + self.MultiFileZipFileName,
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+
+        self.assertRegex(result.stdout, pattern,
+                         "STDOUT of unzip for a multi-file zip archive "
+                         "does not match the expectations!")
+
+    def test_When_UsingZipInfoDash1ForMultiFileZipArchive_Expect_ListOfContainedFiles(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipinfo` is called with a multi-file\
+        zip archive and the additional parameter `-1` it is expected that\
+        it will list the contained files to STDOUT split by a `\\n` char.
+        """
+
+        # Arrange
+        expectedOutput = ""
+        for i in range(self.FileAmount):
+            expectedOutput += f"{self.TestFilePath(i)}\n"
+
+        # Act
+        result = RunShellCommand("zipinfo -1 " + self.MultiFileZipFileName,
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutEquals(expectedOutput)
+
+    def test_When_UsingZipInfoDash2htForMultiFileZipArchive_Expect_ListOfContainedFilesWithMetadata(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipinfo` is called with a multi-file\
+        zip archive and the additional parameter `-2ht` it is expected\
+        that it will list the contained files to STDOUT split by a `\\n`\
+        char with metadata about the zip archive.
+        """
+
+        # Arrange
+        regex = rf"^Archive:  multi-file.zip\nZip file size: \d+ bytes, number of entries: {str(self.FileAmount)}\n"  # noqa: E501
+        for i in range(self.FileAmount):
+            filenameAsRegex = re.escape(self.TestFilePath(i))
+            regex += filenameAsRegex + "\\n"
+        regex += rf"{str(self.FileAmount)} files, \d+ bytes uncompressed, \d+ bytes compressed: .*%$"  # noqa: E501
+
+        pattern = re.compile(regex)
+
+        # Act
+        result = RunShellCommand("zipinfo -2ht " + self.MultiFileZipFileName,
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+
+        self.assertRegex(result.stdout, pattern,
+                         "STDOUT of unzip for a multi-file zip archive"
+                         "does not match the expectations!")
+
+
+class LargeZipArchiveTestCases(unittest.TestCase):
+    """
+    The tests of this class test if the commands provided by the\
+    unzip source packages can handle a zip archive with a large file.
+    """
+
+    NoLargeFile = False  # Debug Flag
+
+    LargeFileName = "large-file.bin"
+    LargeFileSizeInMebibyte = 500  # 1 MiB = 1024 * 1024 byte
+    LargeZipArchiveFileName = "large.zip"
+
+    def CreateTemporaryWorkingDirectory(self) -> None:
+        self.WorkingDirectory = mktemp(createDirectory=True)
+
+    def CreateLargeZipArchive(self) -> None:
+        largeFilePath = self.WorkingDirectory + "/" + self.LargeFileName
+
+        print("creating large file (this may take a few seconds)")
+        ddRandom(outputFile=self.LargeFileName,
+                 outputFileSizeInMebibyte=self.LargeFileSizeInMebibyte,
+                 cwd=self.WorkingDirectory)
+
+        zip(zipArchive=self.LargeZipArchiveFileName,
+            fileToAdd=self.LargeFileName,
+            cwd=self.WorkingDirectory)
+
+        shutil.move(src=largeFilePath,
+                    dst=largeFilePath + ".backup")
+
+    def setUp(self) -> None:
+        if self.NoLargeFile:
+            self.LargeFileSizeInMebibyte = 1
+
+        self.CreateTemporaryWorkingDirectory()
+        self.CreateLargeZipArchive()
+
+    def tearDown(self) -> None:
+        if CleanUp:
+            deleteRecursiveWithForce(self.WorkingDirectory)
+
+    def AssertBackedUpLargeFileEqualsExtracted(self):
+        largeFilePath = f"{self.WorkingDirectory}/{self.LargeFileName}"
+        backupFilePath = largeFilePath + ".backup"
+
+        self.assertTrue(os.path.exists(largeFilePath),
+                        msg="Large file was not extracted from "
+                            "large file zip.")
+
+        originalFileSize = os.path.getsize(backupFilePath)
+        extractedFileSize = os.path.getsize(largeFilePath)
+
+        self.assertEqual(extractedFileSize, originalFileSize,
+                         msg="Extracted File does not have the same size "
+                             "as the original file.")
+
+        # compare file content:
+        with open(backupFilePath, 'rb') as originalFile, \
+             open(largeFilePath, 'rb') as extractedFile:
+            while True:
+                block1 = originalFile.read(1024)
+                block2 = extractedFile.read(1024)
+
+                self.assertTrue(block1 == block2,
+                                msg="Extracted File does not match "
+                                    "the original file content.")
+
+                # Reached the end of both files without finding any differences
+                if not block1:
+                    break
+
+    def test_When_FUnZipIsCalledWithLargeZipArchive_Expect_PrintContentOfFirstFile(self) -> None:  # noqa: E501
+        """
+        When the shell command `funzip` is called with a large zip archive,\
+        it is expected that it will print the content of the first contained\
+        file to STDOUT.
+        """
+
+        # Arrange
+        pass
+
+        # Act
+        result = RunShellCommand(f"funzip '{self.LargeZipArchiveFileName}' > "
+                                 f"'{self.LargeFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertBackedUpLargeFileEqualsExtracted()
+
+    def test_When_UnZipIsCalledWithLargeZipArchive_Expect_ExtractsContainedFiles(self) -> None:  # noqa: E501
+        """
+        When the shell command `unzip` is called with a large zip archive,\
+        it is expected that it will extract the contained files.
+        """
+
+        # Arrange
+        pass
+
+        # Act
+        result = RunShellCommand(f"unzip '{self.LargeZipArchiveFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertBackedUpLargeFileEqualsExtracted()
+
+    def test_When_UnZipSFXIsPrependedToLargeArchiveAndCalled_Expect_ExtractsContainedFiles(self) -> None:  # noqa: E501
+        """
+        When `unzipsfx` is prepended in front of a large zip archive and\
+        called, it is expected that it will extract the contained files.
+        """
+
+        # Arrange
+        prependUnZipSFX(self.LargeZipArchiveFileName,
+                        outputFile="large-zip",
+                        cwd=self.WorkingDirectory)
+        # Act
+        result = RunShellCommand("./large-zip",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        self.AssertBackedUpLargeFileEqualsExtracted()
+
+    def test_When_ZipGrepIsCalledWithLargeArchiveAndPattern_Expect_FindsContainedFilesWithPattern(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipgrep` is called with a large zip archive\
+        and an egrep pattern it is expected that it will find and list\
+        refrences to the found matches.
+        """
+
+        # Arrange
+        fileNameAsRegex = self.LargeFileName.replace('.', '\\.')
+        pattern = re.compile(f"^({fileNameAsRegex}:X\n)*$")
+
+        # Act
+        result = RunShellCommand(f"zipgrep -o 'X' "
+                                 f"'{self.LargeZipArchiveFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        self.assertRegex(result.stdout, pattern)
+
+    def test_When_ZipInfoIsCalledWithLargeArchive_Expect_ListsContainedFiles(self) -> None:  # noqa: E501
+        """
+        If the shell command `zipinfo` is called with a large zip archive\
+        it is expected that it will list the name of the contained files.
+        """
+
+        # Arrange
+        expectedOutput = f"{self.LargeFileName}\n"
+
+        # Act
+        result = RunShellCommand("zipinfo -1 " + self.LargeZipArchiveFileName,
+                                 cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutEquals(expectedOutput)
+
+
+class PasswordProtectedZipTestCases(unittest.TestCase):
+    """
+    The tests of this class test if the commands provided by the unzip\
+    source packages can handle a simple password protected zip archive.
+    """
+
+    SecretFileName = "secret.txt"
+    SecretFileContent = ("Top Secret: Project Penguin Power - "
+                         "Objective: Unleash Ubuntu-powered penguins - "
+                         "Phase 1: Tux Training - "
+                         "Phase 2: Fishy Integration - "
+                         "Phase 3: Linux March - "
+                         "Caution: Expect adorable waddling and occasional "
+                         "Linux commands quacking.")
+    SecretFileContentFragment = "Top Secret"
+    PasswordProtectedZipFileName = "password-protected.zip"
+    Password = "WaddleFishLinux123"
+
+    @property
+    def SecretFilePath(self) -> str:
+        return f"{self.WorkingDirectory}/{self.SecretFileName}"
+
+    def CreateTemporaryWorkingDirectory(self) -> None:
+        self.WorkingDirectory = mktemp(createDirectory=True)
+
+    def CreatePasswordProtectedZipArchive(self) -> None:
+        secretFilePath = self.SecretFilePath
+
+        with open(secretFilePath, 'w') as secretFile:
+            secretFile.write(self.SecretFileContent)
+
+        zip(zipArchive=self.PasswordProtectedZipFileName,
+            fileToAdd=self.SecretFileName,
+            password=self.Password,
+            cwd=self.WorkingDirectory)
+
+        shutil.move(src=secretFilePath,
+                    dst=secretFilePath + ".backup")
+
+    def AssertSecretFileExists(self) -> None:
+        secretFilePath = self.SecretFilePath
+
+        self.assertTrue(os.path.exists(secretFilePath),
+                        msg="Secret file does not exist!")
+
+        with open(secretFilePath, 'r') as file:
+            fileContent = file.read()
+            self.assertEqual(fileContent, self.SecretFileContent,
+                             msg="Secret file has unexpected content!")
+
+    def setUp(self) -> None:
+        self.CreateTemporaryWorkingDirectory()
+        self.CreatePasswordProtectedZipArchive()
+
+    def tearDown(self) -> None:
+        if CleanUp:
+            deleteRecursiveWithForce(self.WorkingDirectory)
+
+    def test_When_FUnZipIsCalledWithEncrypedZipArchiveAndPassword_Expect_DecryptZipArchiveAndPrintContentOfFirstFile(self) -> None:  # noqa: E501
+        """
+        When the shell command `funzip` is called with an encryped\
+        zip archive and the corresponding password, it is expected that\
+        it will decrypt the archive and print the content of the first\
+        contained file to stdout.
+        """
+
+        # Arange
+        pass
+
+        # Act
+        result = RunShellCommand(f"funzip '-{self.Password}' "
+                                 f"'{self.PasswordProtectedZipFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutEquals(self.SecretFileContent)
+
+    def test_When_UnZipIsCalledWithEncrypedZipArchiveAndPassword_Expect_DecryptZipArchiveAndExtractFiles(self) -> None:  # noqa: E501
+        """
+        When the shell command `unzip` is called with an encryped zip archive\
+        and the corresponding password, it is expected that it will decrypt\
+        the archive extract it's files.
+        """
+
+        # Arange
+        pattern = re.compile(rf"^Archive:  {self.PasswordProtectedZipFileName}\n\s+inflating: {self.SecretFileName}\s+$")  # noqa: E501
+
+        # Act
+        result = RunShellCommand(f"unzip -P '{self.Password}' "
+                                 f"'{self.PasswordProtectedZipFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        self.assertRegex(result.stdout, pattern,
+                         msg="STDOUT does not match expected output.")
+        self.AssertSecretFileExists()
+
+    def test_When_UnZipSFXIsPrependedToEncryptedZipArchive_Expect_FailureDueToUnsupportedUseCase(self) -> None:  # noqa: E501
+        """
+        When the `unzipsfx` is prepended in fron of an encryped zip archive\
+        and called, it is expected that it will fail, because decryption is\
+        not supported.
+        """
+
+        # Arrange
+        copyrightHeader = "UnZipSFX 6.00 of 20 April 2009, by Info-ZIP (http://www.info-zip.org).\n"  # noqa: E501
+        pattern = re.compile(f"^\\s+skipping: {self.SecretFileName}\\s+encrypted \\(not supported\\)\\s+$")  # noqa: E501
+        prependUnZipSFX(zipArchive=self.PasswordProtectedZipFileName,
+                        outputFile="password-protected-zip",
+                        cwd=self.WorkingDirectory)
+        # Act
+        result = RunShellCommand("./password-protected-zip",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStdoutEquals(copyrightHeader)
+        result.AssertStderrIsNotEmpty()
+        self.assertRegex(result.stderr, pattern,
+                         msg="STDERR does not match expected output.")
+        self.assertFalse(os.path.exists(self.SecretFilePath),
+                         msg="Output says, that encrypted files are not "
+                             "supported, but encrypted file was extracted.")
+
+    # I can't get it to work with the autopkgtest ubuntu cloud vm image :/
+    # Probably the same tty problem as
+    # test_When_RunningFUnZipCommandWithoutParameters_Expect_NonEmptyOutput.
+    @unittest.skip(reason="flaky test")
+    def test_When_ZipGrepIsCalledWithEncryptedZipArchiveAndPattern_Expect_PromtsForPasswordAndFindsMatchesOfContainedFiles(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipgrep` is called with an encryped\
+        zip archive and an egrep pattern, it is expected that it will ask\
+        for the password, when given decrypt the archive and print matches\
+        of the patttern of the contained files to stdout.
+        """
+
+        # Arrange
+        expectScript = f"""
+log_user 0
+spawn zipgrep \"{self.SecretFileContentFragment}\" \"{self.PasswordProtectedZipFileName}\"
+expect "password:" {{
+    log_user 1
+    send "{self.Password}\\r"
+}}
+expect eof
+        """
+
+        with open(self.WorkingDirectory + "/expct", "w") as expectFile:
+            expectFile.write(expectScript)
+
+        # Act
+        result = RunShellCommand("expect expct", cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutEquals(f"\n{self.SecretFileName}:{self.SecretFileContent}\n")  # noqa: E501
+
+    def test_When_ZipInfoIsCalledWithEncryptedZipArchiveAndWithoutPassword_Expect_ListContainedFiles(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipinfo` is called with a encrypted\
+        zip archive, it es expected that it can list the contained files\
+        even without the password.
+        """
+
+        # Arange
+        pass
+
+        # Act
+        result = RunShellCommand(
+            f"zipinfo -1 '{self.PasswordProtectedZipFileName}'",
+            cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertSuccessExitCode()
+        result.AssertStdoutIsNotEmpty()
+        result.AssertStderrIsEmpty()
+        result.AssertStdoutEquals(f"{self.SecretFileName}\n")
+
+
+class InvalidZipTestCases(unittest.TestCase):
+    """
+    The tests of this class test if the commands provided by the unzip\
+    source packages fail, when passed an incalid/corruped zip archive.
+    """
+
+    InvalidZipFileName = "invalid.zip"
+
+    def CreateTemporaryWorkingDirectory(self) -> None:
+        self.WorkingDirectory = mktemp(createDirectory=True)
+
+    def CreateInvalidZipFile(self) -> None:
+        ddRandom(outputFile=self.InvalidZipFileName,
+                 outputFileSizeInMebibyte=1,
+                 cwd=self.WorkingDirectory)
+
+    def setUp(self) -> None:
+        self.CreateTemporaryWorkingDirectory()
+        self.CreateInvalidZipFile()
+
+    def tearDown(self) -> None:
+        if CleanUp:
+            deleteRecursiveWithForce(self.WorkingDirectory)
+
+    def test_When_FUnZipIsCalledWithInvalidZipArchive_Expect_Fail(self) -> None:  # noqa: E501
+        """
+        When the shell command `funzip` is called with an invalid\
+        zip archive, expect it to fail.
+        """
+
+        # Arange
+        pass
+
+        # Act
+        result = RunShellCommand(f"funzip '{self.InvalidZipFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStderrIsNotEmpty()
+
+    def test_When_UnZipIsCalledWithInvalidZipArchive_Expect_Fail(self) -> None:  # noqa: E501
+        """
+        When the shell command `unzip` is called with an invalid\
+        zip archive, expect it to fail.
+        """
+
+        # Arange
+        pass
+
+        # Act
+        result = RunShellCommand(f"unzip '{self.InvalidZipFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStderrIsNotEmpty()
+
+    def test_When_ZipGrepIsCalledWithInvalidZipArchive_Expect_Fail(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipgrep` is called with an invalid\
+        zip archive, expect it to fail.
+        """
+
+        # Arange
+        pass
+
+        # Act
+        result = RunShellCommand(
+            f"zipgrep Pattern '{self.InvalidZipFileName}'",
+            cwd=self.WorkingDirectory)
+
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStderrIsNotEmpty()
+
+    def test_When_ZipInfoIsCalledWithInvalidZipArchive_Expect_Fail(self) -> None:  # noqa: E501
+        """
+        When the shell command `zipinfo` is called with an invalid\
+        zip archive, expect it to fail.
+        """
+
+        # Arange
+        pass
+
+        # Act
+        result = RunShellCommand(f"zipinfo '{self.InvalidZipFileName}'",
+                                 cwd=self.WorkingDirectory)
+        # Assert
+        result.AssertFailureExitCode()
+        result.AssertStdoutIsNotEmpty()
+
+
+# if script is not imported as library, run all tests
+if __name__ == "__main__":
+    unittest.main()
diff --git a/debian/tests/control b/debian/tests/control
new file mode 100644
index 0000000..fc221e9
--- /dev/null
+++ b/debian/tests/control
@@ -0,0 +1,3 @@
+Tests: smoke-tests
+Depends: unzip, python3, zip, man, diffutils
+Restrictions: allow-stderr
diff --git a/debian/tests/smoke-tests b/debian/tests/smoke-tests
new file mode 100755
index 0000000..f7bc50a
--- /dev/null
+++ b/debian/tests/smoke-tests
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -e
+
+SmokeTests="$PWD/debian/tests/SmokeTests.py"
+cd "$AUTOPKGTEST_TMP"
+printenv
+
+echo "Running Tests (some test cases invole creating larger files; this may take a few minutes):"
+python3 "$SmokeTests"