Make directory paths configurable

[apt.git] / test / integration / framework

diff --git a/test/integration/framework b/test/integration/framework
index a9acd83a977899313105bc3e71e9b64c3c3e7342..9589ca84c27b8a996d72e67cf0f9b12efeaf1221 100644 (file)
--- a/test/integration/framework
+++ b/test/integration/framework
@@ -54,7 +54,7 @@ msgprintf() {
                printf "$START " "$1"
                shift
                while [ -n "$1" ]; do
                printf "$START " "$1"
                shift
                while [ -n "$1" ]; do

-                       printf "$MIDDLE " "$(echo "$1" | sed -e 's#^apt\([cfghs]\)#apt-\1#')"
+                       printf "$MIDDLE " "$(echo "$1" | sed -e 's#^apt\([cfghks]\)#apt-\1#')"

                        shift
                done
        fi
                        shift
                done
        fi


@@ -95,7 +95,7 @@ msgfail() {
        if [ $# -gt 0 ] && [ -n "$1" ]; then printf "${CFAIL}FAIL: $*${CNORMAL}\n" >&2;
        else printf "${CFAIL}FAIL${CNORMAL}\n" >&2; fi
        if [ -n "$APT_DEBUG_TESTS" ]; then
        if [ $# -gt 0 ] && [ -n "$1" ]; then printf "${CFAIL}FAIL: $*${CNORMAL}\n" >&2;
        else printf "${CFAIL}FAIL${CNORMAL}\n" >&2; fi
        if [ -n "$APT_DEBUG_TESTS" ]; then

-               $SHELL
+               runapt $SHELL

        fi
        EXIT_CODE=$((EXIT_CODE+1));
 }
        fi
        EXIT_CODE=$((EXIT_CODE+1));
 }


@@ -169,17 +169,18 @@ runapt() {
        msgdebug "Executing: ${CCMD}$*${CDEBUG} "
        local CMD="$1"
        shift
        msgdebug "Executing: ${CCMD}$*${CDEBUG} "
        local CMD="$1"
        shift

-       case $CMD in
+       case "$CMD" in

        sh|aptitude|*/*|command) ;;
        *) CMD="${BUILDDIRECTORY}/$CMD";;
        esac
        sh|aptitude|*/*|command) ;;
        *) CMD="${BUILDDIRECTORY}/$CMD";;
        esac

-       MALLOC_PERTURB_=21 MALLOC_CHECK_=2 APT_CONFIG="$(getaptconfig)" LD_LIBRARY_PATH=${LIBRARYPATH} $CMD "$@"
+       MALLOC_PERTURB_=21 MALLOC_CHECK_=2 APT_CONFIG="$(getaptconfig)" LD_LIBRARY_PATH="${LIBRARYPATH}:${LD_LIBRARY_PATH}" "$CMD" "$@"

 }
 }

+runpython3() { runapt command python3 "$@"; }

 aptconfig() { runapt apt-config "$@"; }
 aptcache() { runapt apt-cache "$@"; }
 aptcdrom() { runapt apt-cdrom "$@"; }
 aptget() { runapt apt-get "$@"; }
 aptconfig() { runapt apt-config "$@"; }
 aptcache() { runapt apt-cache "$@"; }
 aptcdrom() { runapt apt-cdrom "$@"; }
 aptget() { runapt apt-get "$@"; }

-aptftparchive() { runapt apt-ftparchive "$@"; }
+aptftparchive() { runapt "${APTFTPARCHIVEBINDIR}/apt-ftparchive" "$@"; }

 aptkey() { runapt apt-key "$@"; }
 aptmark() { runapt apt-mark "$@"; }
 aptsortpkgs() { runapt apt-sortpkgs "$@"; }
 aptkey() { runapt apt-key "$@"; }
 aptmark() { runapt apt-mark "$@"; }
 aptsortpkgs() { runapt apt-sortpkgs "$@"; }


@@ -190,6 +191,7 @@ aptitude() { runapt aptitude "$@"; }
 aptextracttemplates() { runapt apt-extracttemplates "$@"; }
 aptinternalsolver() { runapt "${APTINTERNALSOLVER}" "$@"; }
 aptdumpsolver() { runapt "${APTDUMPSOLVER}" "$@"; }
 aptextracttemplates() { runapt apt-extracttemplates "$@"; }
 aptinternalsolver() { runapt "${APTINTERNALSOLVER}" "$@"; }
 aptdumpsolver() { runapt "${APTDUMPSOLVER}" "$@"; }

+aptinternalplanner() { runapt "${APTINTERNALPLANNER}" "$@"; }

 
 dpkg() {
        "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" "$@"
 
 dpkg() {
        "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" "$@"


@@ -214,7 +216,13 @@ gdb() {
        if [ "${CMD##*/}" = "$CMD" ]; then
                CMD="${BUILDDIRECTORY}/${CMD}"
        fi
        if [ "${CMD##*/}" = "$CMD" ]; then
                CMD="${BUILDDIRECTORY}/${CMD}"
        fi

-       runapt command gdb --quiet -ex run "$CMD" --args "$CMD" "$@"
+       runapt command gdb --quiet -ex "directory '$SOURCEDIRECTORY'" -ex run "$CMD" --args "$CMD" "$@"
+}
+lastmodification() {
+       date -u -d "@$(stat -c '%Y' "${TMPWORKINGDIRECTORY}/$1")" -R
+}
+releasefiledate() {
+       grep "^${2:-Date}:" "$1" | cut -d' ' -f 2-

 }
 
 exitwithstatus() {
 }
 
 exitwithstatus() {


@@ -245,13 +253,41 @@ addtrap() {
        trap "shellsetedetector; $CURRENTTRAP exitwithstatus;" 0 HUP INT QUIT ILL ABRT FPE SEGV PIPE TERM
 }
 
        trap "shellsetedetector; $CURRENTTRAP exitwithstatus;" 0 HUP INT QUIT ILL ABRT FPE SEGV PIPE TERM
 }
 

+escape_shell() {
+    echo "$@" | sed -e "s#'#'\"'\"'#g"
+}
+
+find_project_binary_dir() {
+       local TESTDIRECTORY="$(readlink -f "$(dirname $0)")"
+       if [ -z "$PROJECT_BINARY_DIR" ]; then
+               PROJECT_BINARY_DIR=
+               for dir in ${TESTDIRECTORY}/../../ ${TESTDIRECTORY}/../../*; do
+                       test -e "$dir/CMakeCache.txt"  || continue
+                       if [ -z "$PROJECT_BINARY_DIR" ] ||
+                          [ "$dir/CMakeCache.txt" -nt "$PROJECT_BINARY_DIR/CMakeCache.txt" ]; then
+                               PROJECT_BINARY_DIR="$dir"
+                       fi
+               done
+               if [ -z "$PROJECT_BINARY_DIR" ]; then
+                       echo "Cannot find build directory, you might want to set PROJECT_BINARY_DIR" >&2
+                       exit 1
+               fi
+               export PROJECT_BINARY_DIR
+       fi
+}

 setupenvironment() {
        # privilege dropping and testing doesn't work if /tmp isn't world-writeable (as e.g. with libpam-tmpdir)
        if [ -n "$TMPDIR" ] && [ "$(id -u)" = '0' ] && [ "$(stat --format '%a' "$TMPDIR")" != '1777' ]; then
                unset TMPDIR
        fi
        TMPWORKINGDIRECTORY="$(mktemp -d)"
 setupenvironment() {
        # privilege dropping and testing doesn't work if /tmp isn't world-writeable (as e.g. with libpam-tmpdir)
        if [ -n "$TMPDIR" ] && [ "$(id -u)" = '0' ] && [ "$(stat --format '%a' "$TMPDIR")" != '1777' ]; then
                unset TMPDIR
        fi
        TMPWORKINGDIRECTORY="$(mktemp -d)"

-       addtrap "cd /; rm -rf \"$TMPWORKINGDIRECTORY\";"
+       addtrap "cd /; rm -rf '$(escape_shell "$TMPWORKINGDIRECTORY")';"
+       if [ -n "$TMPDIR_ADD" ]; then
+               TMPWORKINGDIRECTORY="${TMPWORKINGDIRECTORY}/${TMPDIR_ADD}"
+               mkdir -p "$TMPWORKINGDIRECTORY"
+               unset TMPDIR_ADD
+               export TMPDIR="$TMPWORKINGDIRECTORY"
+       fi

        msgninfo "Preparing environment for ${0##*/} in ${TMPWORKINGDIRECTORY}…"
 
        mkdir -m 700 "${TMPWORKINGDIRECTORY}/downloaded"
        msgninfo "Preparing environment for ${0##*/} in ${TMPWORKINGDIRECTORY}…"
 
        mkdir -m 700 "${TMPWORKINGDIRECTORY}/downloaded"


@@ -263,15 +299,19 @@ setupenvironment() {
        fi
 
        TESTDIRECTORY="$(readlink -f "$(dirname $0)")"
        fi
 
        TESTDIRECTORY="$(readlink -f "$(dirname $0)")"

+       # Find the newest build directory (sets PROJECT_BINARY_DIR)
+       find_project_binary_dir

         # allow overriding the default BUILDDIR location
        SOURCEDIRECTORY="${APT_INTEGRATION_TESTS_SOURCE_DIR:-"${TESTDIRECTORY}/../../"}"
         # allow overriding the default BUILDDIR location
        SOURCEDIRECTORY="${APT_INTEGRATION_TESTS_SOURCE_DIR:-"${TESTDIRECTORY}/../../"}"

-       BUILDDIRECTORY="${APT_INTEGRATION_TESTS_BUILD_DIR:-"${TESTDIRECTORY}/../../build/bin"}"
-       LIBRARYPATH="${APT_INTEGRATION_TESTS_LIBRARY_PATH:-"${BUILDDIRECTORY}"}"
-        METHODSDIR="${APT_INTEGRATION_TESTS_METHODS_DIR:-"${BUILDDIRECTORY}/methods"}"
+       BUILDDIRECTORY="${APT_INTEGRATION_TESTS_BUILD_DIR:-"${PROJECT_BINARY_DIR}/cmdline"}"
+       LIBRARYPATH="${APT_INTEGRATION_TESTS_LIBRARY_PATH:-"${BUILDDIRECTORY}/../apt-pkg"}"
+        METHODSDIR="${APT_INTEGRATION_TESTS_METHODS_DIR:-"${BUILDDIRECTORY}/../methods"}"

         APTHELPERBINDIR="${APT_INTEGRATION_TESTS_LIBEXEC_DIR:-"${BUILDDIRECTORY}"}"
         APTHELPERBINDIR="${APT_INTEGRATION_TESTS_LIBEXEC_DIR:-"${BUILDDIRECTORY}"}"

-        APTWEBSERVERBINDIR="${APT_INTEGRATION_TESTS_WEBSERVER_BIN_DIR:-"${BUILDDIRECTORY}"}"
-        APTINTERNALSOLVER="${APT_INTEGRATION_TESTS_INTERNAL_SOLVER:-"${BUILDDIRECTORY}/apt-internal-solver"}"
-       APTDUMPSOLVER="${APT_INTEGRATION_TESTS_DUMP_SOLVER:-"${BUILDDIRECTORY}/apt-dump-solver"}"
+        APTWEBSERVERBINDIR="${APT_INTEGRATION_TESTS_WEBSERVER_BIN_DIR:-"${BUILDDIRECTORY}/../test/interactive-helper"}"
+        APTFTPARCHIVEBINDIR="${APT_INTEGRATION_TESTS_FTPARCHIVE_BIN_DIR:-"${BUILDDIRECTORY}/../ftparchive"}"
+        APTINTERNALSOLVER="${APT_INTEGRATION_TESTS_INTERNAL_SOLVER:-"${BUILDDIRECTORY}/solvers/apt"}"
+       APTDUMPSOLVER="${APT_INTEGRATION_TESTS_DUMP_SOLVER:-"${BUILDDIRECTORY}/solvers/dump"}"
+       APTINTERNALPLANNER="${APT_INTEGRATION_TESTS_INTERNAL_PLANNER:-"${BUILDDIRECTORY}/planners/apt"}"

        test -x "${BUILDDIRECTORY}/apt-get" || msgdie "You need to build tree first"
         # -----
 
        test -x "${BUILDDIRECTORY}/apt-get" || msgdie "You need to build tree first"
         # -----
 


@@ -279,21 +319,21 @@ setupenvironment() {
        mkdir rootdir aptarchive keys
        cd rootdir
        mkdir -p etc/apt/apt.conf.d etc/apt/sources.list.d etc/apt/trusted.gpg.d etc/apt/preferences.d
        mkdir rootdir aptarchive keys
        cd rootdir
        mkdir -p etc/apt/apt.conf.d etc/apt/sources.list.d etc/apt/trusted.gpg.d etc/apt/preferences.d

-       mkdir -p usr/bin var/cache var/lib var/log tmp
+       mkdir -p usr/bin var/cache var/lib var/log var/crash tmp

        mkdir -p var/lib/dpkg/info var/lib/dpkg/updates var/lib/dpkg/triggers
        mkdir -p var/lib/dpkg/info var/lib/dpkg/updates var/lib/dpkg/triggers

+       mkdir -p usr/lib/apt/solvers usr/lib/apt/planners

        touch var/lib/dpkg/available
        touch var/lib/dpkg/available

-       mkdir -p usr/lib/apt

        ln -s "${METHODSDIR}" usr/lib/apt/methods
        ln -s "${METHODSDIR}" usr/lib/apt/methods

-       if [ "$BUILDDIRECTORY" = "$LIBRARYPATH" ]; then
-               mkdir -p usr/lib/apt/solvers
-               ln -s "${BUILDDIRECTORY}/apt-dump-solver" usr/lib/apt/solvers/dump
-               ln -s "${BUILDDIRECTORY}/apt-internal-solver" usr/lib/apt/solvers/apt
-               echo "Dir::Bin::Solvers \"${TMPWORKINGDIRECTORY}/rootdir/usr/lib/apt/solvers\";" > etc/apt/apt.conf.d/externalsolver.conf
-       fi
+       ln -s "${APTDUMPSOLVER}" usr/lib/apt/solvers/dump
+       ln -s "${APTDUMPSOLVER}" usr/lib/apt/planners/dump
+       ln -s "${APTINTERNALSOLVER}" usr/lib/apt/solvers/apt
+       ln -s "${APTINTERNALPLANNER}" usr/lib/apt/planners/apt
+       echo "Dir::Bin::Solvers \"${TMPWORKINGDIRECTORY}/rootdir/usr/lib/apt/solvers\";" >> ../aptconfig.conf
+       echo "Dir::Bin::Planners \"${TMPWORKINGDIRECTORY}/rootdir/usr/lib/apt/planners\";" >> ../aptconfig.conf

         # use the autoremove from the BUILDDIRECTORY if its there, otherwise
         # system
         # use the autoremove from the BUILDDIRECTORY if its there, otherwise
         # system

-        if [ -e "${BUILDDIRECTORY}/../../debian/apt.conf.autoremove" ]; then
-           ln -s "${BUILDDIRECTORY}/../../debian/apt.conf.autoremove" etc/apt/apt.conf.d/01autoremove
+        if [ -z "${APT_INTEGRATION_TESTS_SOURCE_DIR}" ]; then
+           ln -s "${SOURCEDIRECTORY}/debian/apt.conf.autoremove" etc/apt/apt.conf.d/01autoremove

         else
            ln -s /etc/apt/apt.conf.d/01autoremove etc/apt/apt.conf.d/01autoremove
         fi
         else
            ln -s /etc/apt/apt.conf.d/01autoremove etc/apt/apt.conf.d/01autoremove
         fi


@@ -307,34 +347,39 @@ setupenvironment() {
        if [ -f "${TESTDIRECTORY}/${SOURCESSFILE}" ]; then
                cp "${TESTDIRECTORY}/${SOURCESSFILE}" aptarchive/Sources
        fi
        if [ -f "${TESTDIRECTORY}/${SOURCESSFILE}" ]; then
                cp "${TESTDIRECTORY}/${SOURCESSFILE}" aptarchive/Sources
        fi

-       for key in $(find "$TESTDIRECTORY" -name '*.pub' -o -name '*.sec'); do
-               cp "$key" keys/
-               chmod 644 "$key"
-       done
+       find "$TESTDIRECTORY" \( -name '*.pub' -o -name '*.sec' \) -exec cp '{}' keys/ \;
+       chmod 644 keys/*

        ln -s "${TMPWORKINGDIRECTORY}/keys/joesixpack.pub" rootdir/etc/apt/trusted.gpg.d/joesixpack.gpg
 
        ln -s "${TMPWORKINGDIRECTORY}/keys/joesixpack.pub" rootdir/etc/apt/trusted.gpg.d/joesixpack.gpg
 

-       echo "Dir \"${TMPWORKINGDIRECTORY}/rootdir\";" > aptconfig.conf
-       echo "Dir::state::status \"${TMPWORKINGDIRECTORY}/rootdir/var/lib/dpkg/status\";" >> aptconfig.conf
+       echo "Dir \"${TMPWORKINGDIRECTORY}/rootdir\";" >> aptconfig.conf
+       echo "Dir::Etc \"etc\";" >> aptconfig.conf
+       echo "Dir::State \"var/lib/apt\";" >> aptconfig.conf
+       echo "Dir::Cache \"var/cache/apt\";" >> aptconfig.conf
+       echo "Dir::Etc \"etc/apt\";" >> aptconfig.conf
+       echo "Dir::Log \"var/log/apt\";" >> aptconfig.conf

        echo "APT::Get::Show-User-Simulation-Note \"false\";" >> aptconfig.conf
        echo "Dir::Bin::Methods \"${TMPWORKINGDIRECTORY}/rootdir/usr/lib/apt/methods\";" >> aptconfig.conf
        echo "APT::Get::Show-User-Simulation-Note \"false\";" >> aptconfig.conf
        echo "Dir::Bin::Methods \"${TMPWORKINGDIRECTORY}/rootdir/usr/lib/apt/methods\";" >> aptconfig.conf

-       # store apt-key were we can access it, even if we run it as a different user
-       # destroys coverage reporting though, so just do it for root for now
+       # either store apt-key were we can access it, even if we run it as a different user
+       #cp "${BUILDDIRECTORY}/apt-key" "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/"
+       #chmod o+rx "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/apt-key"
+       #echo "Dir::Bin::apt-key \"${TMPWORKINGDIRECTORY}/rootdir/usr/bin/apt-key\";" >> aptconfig.conf
+       # destroys coverage reporting though, so we disable changing user for the calling gpgv
+       echo "Dir::Bin::apt-key \"${BUILDDIRECTORY}/apt-key\";" >> aptconfig.conf

        if [ "$(id -u)" = '0' ]; then
        if [ "$(id -u)" = '0' ]; then

-               cp "${BUILDDIRECTORY}/apt-key" "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/"
-               chmod o+rx "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/apt-key"
-               echo "Dir::Bin::apt-key \"${TMPWORKINGDIRECTORY}/rootdir/usr/bin/apt-key\";" >> aptconfig.conf
-       else
-               echo "Dir::Bin::apt-key \"${BUILDDIRECTORY}/apt-key\";" >> aptconfig.conf
+               echo 'Binary::gpgv::APT::Sandbox::User "root";' >> aptconfig.conf
+               # same for the solver executables
+               echo 'APT::Solver::RunAsUser "root";' >> aptconfig.conf
+               echo 'APT::Planner::RunAsUser "root";' >> aptconfig.conf

        fi
 
        cat > "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" <<EOF
 #!/bin/sh
 set -e
        fi
 
        cat > "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" <<EOF
 #!/bin/sh
 set -e

-if [ -r "${TMPWORKINGDIRECTORY}/noopchroot.so" ]; then
+if [ -r '${TMPWORKINGDIRECTORY}/noopchroot.so' ]; then

        if [ -n "\$LD_LIBRARY_PATH" ]; then
        if [ -n "\$LD_LIBRARY_PATH" ]; then

-               export LD_LIBRARY_PATH="${TMPWORKINGDIRECTORY}:${LD_LIBRARY_PATH}"
+               export LD_LIBRARY_PATH='${TMPWORKINGDIRECTORY}:'"\${LD_LIBRARY_PATH}"

        else
        else

-               export LD_LIBRARY_PATH="${TMPWORKINGDIRECTORY}"
+               export LD_LIBRARY_PATH='${TMPWORKINGDIRECTORY}'

        fi
        if [ -n "\$LD_PRELOAD" ]; then
                export LD_PRELOAD="noopchroot.so \${LD_PRELOAD}"
        fi
        if [ -n "\$LD_PRELOAD" ]; then
                export LD_PRELOAD="noopchroot.so \${LD_PRELOAD}"


@@ -345,13 +390,13 @@ fi
 EOF
        cp "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/gdb-dpkg"
        cat >> "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" <<EOF
 EOF
        cp "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/gdb-dpkg"
        cat >> "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" <<EOF

-exec fakeroot "${DPKG:-dpkg}" --root="${TMPWORKINGDIRECTORY}/rootdir" \\
-       --log="${TMPWORKINGDIRECTORY}/rootdir/var/log/dpkg.log" \\
+exec fakeroot '${DPKG:-dpkg}' --root='${TMPWORKINGDIRECTORY}/rootdir' \\
+       --log='${TMPWORKINGDIRECTORY}/rootdir/var/log/dpkg.log' \\

        --force-not-root --force-bad-path "\$@"
 EOF
        cat >> "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/gdb-dpkg" <<EOF
        --force-not-root --force-bad-path "\$@"
 EOF
        cat >> "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/gdb-dpkg" <<EOF

-exec fakeroot gdb --quiet -ex run "${DPKG:-dpkg}" --args "${DPKG:-dpkg}" --root="${TMPWORKINGDIRECTORY}/rootdir" \\
-       --log="${TMPWORKINGDIRECTORY}/rootdir/var/log/dpkg.log" \\
+exec fakeroot gdb --quiet -ex run '${DPKG:-dpkg}' --args '${DPKG:-dpkg}' --root='${TMPWORKINGDIRECTORY}/rootdir' \\
+       --log='${TMPWORKINGDIRECTORY}/rootdir/var/log/dpkg.log' \\

        --force-not-root --force-bad-path "\$@"
 EOF
        chmod +x "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/gdb-dpkg"
        --force-not-root --force-bad-path "\$@"
 EOF
        chmod +x "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/dpkg" "${TMPWORKINGDIRECTORY}/rootdir/usr/bin/gdb-dpkg"


@@ -361,6 +406,7 @@ EOF
                if ! command dpkg --assert-multi-arch >/dev/null 2>&1; then
                        echo "DPKG::options:: \"--force-architecture\";" # Added to test multiarch before dpkg is ready for it…
                fi
                if ! command dpkg --assert-multi-arch >/dev/null 2>&1; then
                        echo "DPKG::options:: \"--force-architecture\";" # Added to test multiarch before dpkg is ready for it…
                fi

+               echo 'quiet "0";'

                echo 'quiet::NoUpdate "true";'
                echo 'quiet::NoStatistic "true";'
                # too distracting for users, but helpful to detect changes
                echo 'quiet::NoUpdate "true";'
                echo 'quiet::NoStatistic "true";'
                # too distracting for users, but helpful to detect changes


@@ -369,6 +415,8 @@ EOF
                # in testcases, it can appear as if localhost has a rotation setup,
                # hide this as we can't really deal with it properly
                echo 'Acquire::Failure::ShowIP "false";'
                # in testcases, it can appear as if localhost has a rotation setup,
                # hide this as we can't really deal with it properly
                echo 'Acquire::Failure::ShowIP "false";'

+               # fakeroot can't fake everything, so disabled in production but good for tests
+               echo 'APT::Sandbox::Verify "true";'

        } >> aptconfig.conf
 
        cp "${TESTDIRECTORY}/apt.pem" "${TMPWORKINGDIRECTORY}/rootdir/etc/webserver.pem"
        } >> aptconfig.conf
 
        cp "${TESTDIRECTORY}/apt.pem" "${TMPWORKINGDIRECTORY}/rootdir/etc/webserver.pem"


@@ -377,27 +425,40 @@ EOF
        fi
        echo "Acquire::https::CaInfo \"${TMPWORKINGDIRECTORY}/rootdir/etc/webserver.pem\";" > rootdir/etc/apt/apt.conf.d/99https
        echo "Apt::Cmd::Disable-Script-Warning \"1\";" > rootdir/etc/apt/apt.conf.d/apt-binary
        fi
        echo "Acquire::https::CaInfo \"${TMPWORKINGDIRECTORY}/rootdir/etc/webserver.pem\";" > rootdir/etc/apt/apt.conf.d/99https
        echo "Apt::Cmd::Disable-Script-Warning \"1\";" > rootdir/etc/apt/apt.conf.d/apt-binary

+       export APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE=no
+       echo 'Acquire::Connect::AddrConfig "false";' > rootdir/etc/apt/apt.conf.d/connect-addrconfig
+

        configcompression '.' 'gz' #'bz2' 'lzma' 'xz'
        configcompression '.' 'gz' #'bz2' 'lzma' 'xz'

-       confighashes 'SHA1' # these are tests, not security best-practices
+       confighashes 'SHA256' # these are tests, not security best-practices

 
        # create some files in /tmp and look at user/group to get what this means
 
        # create some files in /tmp and look at user/group to get what this means

-       TEST_DEFAULT_USER="$USER"
+       TEST_DEFAULT_USER="$(id -un)"

        if [ "$(uname)" = 'GNU/kFreeBSD' ]; then
                TEST_DEFAULT_GROUP='root'
        else
        if [ "$(uname)" = 'GNU/kFreeBSD' ]; then
                TEST_DEFAULT_GROUP='root'
        else

-               TEST_DEFAULT_GROUP="$USER"
+               TEST_DEFAULT_GROUP="$(id -gn)"

        fi
 
        fi
 

-        # Acquire::AllowInsecureRepositories=false is not yet the default
-        # but we want it to be the default soon
-        configallowinsecurerepositories "false";
-

        # cleanup the environment a bit
        # cleanup the environment a bit

-        # prefer our apt binaries over the system apt binaries
+       # prefer our apt binaries over the system apt binaries

        export PATH="${BUILDDIRECTORY}:${PATH}:/usr/local/sbin:/usr/sbin:/sbin"
        export LC_ALL=C.UTF-8
        unset LANGUAGE APT_CONFIG
        unset GREP_OPTIONS DEB_BUILD_PROFILES
        export PATH="${BUILDDIRECTORY}:${PATH}:/usr/local/sbin:/usr/sbin:/sbin"
        export LC_ALL=C.UTF-8
        unset LANGUAGE APT_CONFIG
        unset GREP_OPTIONS DEB_BUILD_PROFILES

+       unset http_proxy HTTP_PROXY https_proxy HTTPS_PROXY no_proxy
+
+       # If gpgv supports --weak-digest, pass it to make sure we can disable SHA1
+       if aptkey verify --weak-digest SHA1 --help 2>/dev/null >/dev/null; then
+               echo 'Acquire::gpgv::Options { "--weak-digest"; "sha1"; };' > rootdir/etc/apt/apt.conf.d/no-sha1
+       fi
+
+       # most tests just need one signed Release file, not both
+       export APT_DONT_SIGN='Release.gpg'
+
+       if [ -r "${TESTDIRECTORY}/extra-environment" ]; then
+               . "${TESTDIRECTORY}/extra-environment"
+       fi
+

        msgdone "info"
 }
 
        msgdone "info"
 }
 


@@ -446,17 +507,21 @@ configdpkg() {
        rm -f rootdir/etc/apt/apt.conf.d/00foreigndpkg
        if command dpkg --assert-multi-arch >/dev/null 2>&1 ; then
                local ARCHS="$(getarchitectures)"
        rm -f rootdir/etc/apt/apt.conf.d/00foreigndpkg
        if command dpkg --assert-multi-arch >/dev/null 2>&1 ; then
                local ARCHS="$(getarchitectures)"

-               if echo "$ARCHS" | grep -E -q '[^ ]+ [^ ]+'; then
-                       DPKGARCH="$(dpkg --print-architecture)"
-                       for ARCH in ${ARCHS}; do
-                               if [ "${ARCH}" != "${DPKGARCH}" ]; then
-                                       if ! dpkg --add-architecture ${ARCH} >/dev/null 2>&1; then
-                                               # old-style used e.g. in Ubuntu-P – and as it seems travis
-                                               echo "DPKG::options:: \"--foreign-architecture\";" >> rootdir/etc/apt/apt.conf.d/00foreigndpkg
-                                               echo "DPKG::options:: \"${ARCH}\";"  >> rootdir/etc/apt/apt.conf.d/00foreigndpkg
-                                       fi
+               local DPKGARCH="$(dpkg --print-architecture)"
+               # this ensures that even if multi-arch isn't active in the view
+               # of apt, given that dpkg can't be told which arch is native
+               # the arch apt treats as native might be foreign for dpkg
+               for ARCH in ${ARCHS}; do
+                       if [ "${ARCH}" != "${DPKGARCH}" ]; then
+                               if ! dpkg --add-architecture ${ARCH} >/dev/null 2>&1; then
+                                       # old-style used e.g. in Ubuntu-P – and as it seems travis
+                                       echo "DPKG::options:: \"--foreign-architecture\";" >> rootdir/etc/apt/apt.conf.d/00foreigndpkg
+                                       echo "DPKG::options:: \"${ARCH}\";"  >> rootdir/etc/apt/apt.conf.d/00foreigndpkg

                                fi
                                fi

-                       done
+                       fi
+               done
+               # if multi-arch make sure dpkg can detect itself as capable of it
+               if echo "$ARCHS" | grep -E -q '[^ ]+ [^ ]+'; then

                        if [ "0" = "$(dpkg -l dpkg 2> /dev/null | grep '^i' | wc -l)" ]; then
                                # dpkg doesn't really check the version as long as it is fully installed,
                                # but just to be sure we choose one above the required version
                        if [ "0" = "$(dpkg -l dpkg 2> /dev/null | grep '^i' | wc -l)" ]; then
                                # dpkg doesn't really check the version as long as it is fully installed,
                                # but just to be sure we choose one above the required version


@@ -493,34 +558,35 @@ int execvp(const char *file, char *const argv[]) {
        if (chrootdir == NULL || strncmp(file, "/var/lib/dpkg/", strlen("/var/lib/dpkg/")) != 0)
                return func_execvp(file, argv);
        printf("REWRITE execvp call %s into %s\n", file, chrootdir);
        if (chrootdir == NULL || strncmp(file, "/var/lib/dpkg/", strlen("/var/lib/dpkg/")) != 0)
                return func_execvp(file, argv);
        printf("REWRITE execvp call %s into %s\n", file, chrootdir);

-       char newfile[strlen(chrootdir) + strlen(file)];
-       strcpy(newfile, chrootdir);
-       strcat(newfile, file);
+       char *newfile;
+       if (asprintf(&newfile, "%s%s", chrootdir, file) == -1) {
+               perror("asprintf");
+               return -1;
+       }

        char const * const baseadmindir = "/var/lib/dpkg";
        char const * const baseadmindir = "/var/lib/dpkg";

-       char admindir[strlen(chrootdir) + strlen(baseadmindir)];
-       strcpy(admindir, chrootdir);
-       strcat(admindir, baseadmindir);
+       char *admindir;
+       if (asprintf(&admindir, "%s%s", chrootdir, baseadmindir) == -1) {
+               perror("asprintf");
+               return -1;
+       }

        setenv("DPKG_ADMINDIR", admindir, 1);
        return func_execvp(newfile, argv);
 }
 EOF
        setenv("DPKG_ADMINDIR", admindir, 1);
        return func_execvp(newfile, argv);
 }
 EOF

-       testsuccess --nomsg gcc -fPIC -shared -o noopchroot.so noopchroot.c -ldl
-}
-
-configallowinsecurerepositories() {
-    echo "Acquire::AllowInsecureRepositories \"$1\";" >  rootdir/etc/apt/apt.conf.d/allow-insecure-repositories.conf
-
+       testempty --nomsg gcc -Wall -Wextra -fPIC -shared -o noopchroot.so noopchroot.c -ldl

 }
 }

-

 configcompression() {
 configcompression() {

+       if [ "$1" = 'ALL' ]; then
+               configcompression '.' $(aptconfig dump APT::Compressor --format '%t %v%n' | sed -n 's#^Extension \.\(.*\)$#\1#p')
+               return
+       fi
+       local CMD='apthelper cat-file -C'

        while [ -n "$1" ]; do
                case "$1" in
                '.') printf ".\t.\tcat\n";;
        while [ -n "$1" ]; do
                case "$1" in
                '.') printf ".\t.\tcat\n";;

-               'gz') printf "gzip\tgz\tgzip\n";;
-               'bz2') printf "bzip2\tbz2\tbzip2\n";;
-               'lzma') printf "lzma\tlzma\txz --format=lzma\n";;
-               'xz') printf "xz\txz\txz\n";;
-               *) printf "$1\t$1\t$1\n";;
+               'gz') printf "gzip\tgz\t$CMD $1\n";;
+               'bz2') printf "bzip2\tbz2\t$CMD $1\n";;
+               *) printf "$1\t$1\t$CMD $1\n";;

                esac
                shift
        done > "${TMPWORKINGDIRECTORY}/rootdir/etc/testcase-compressor.conf"
                esac
                shift
        done > "${TMPWORKINGDIRECTORY}/rootdir/etc/testcase-compressor.conf"


@@ -543,92 +609,24 @@ confighashes() {
 }
 forcecompressor() {
        COMPRESSOR="$1"
 }
 forcecompressor() {
        COMPRESSOR="$1"

-       COMPRESSOR_CMD="$1"
+       COMPRESS="$1"
+       COMPRESSOR_CMD="apthelper cat-file -C $1"

        case $COMPRESSOR in
        gzip) COMPRESS='gz';;
        bzip2) COMPRESS='bz2';;
        case $COMPRESSOR in
        gzip) COMPRESS='gz';;
        bzip2) COMPRESS='bz2';;

-       lzma) COMPRESS='lzma';;
-       xz) COMPRESS='xz';;
-       *) msgdie "Compressor $COMPRESSOR is unknown to framework, so can't be forced by forcecompressor!";;

        esac
        local CONFFILE="${TMPWORKINGDIRECTORY}/rootdir/etc/apt/apt.conf.d/00force-compressor"
        echo "Acquire::CompressionTypes::Order { \"${COMPRESS}\"; };
        esac
        local CONFFILE="${TMPWORKINGDIRECTORY}/rootdir/etc/apt/apt.conf.d/00force-compressor"
        echo "Acquire::CompressionTypes::Order { \"${COMPRESS}\"; };

-Dir::Bin::uncompressed \"/does/not/exist\";
-Dir::Bin::gzip \"/does/not/exist\";
-Dir::Bin::bzip2 \"/does/not/exist\";
-Dir::Bin::lzma \"/does/not/exist\";
-Dir::Bin::xz \"/does/not/exist\";" > "$CONFFILE"
-       if [ -e "/bin/${COMPRESSOR}" ]; then
-               echo "Dir::Bin::${COMPRESSOR} \"/bin/${COMPRESSOR}\";" >> "$CONFFILE"
-       elif [ -e "/usr/bin/${COMPRESSOR}" ]; then
-               echo "Dir::Bin::${COMPRESSOR} \"/usr/bin/${COMPRESSOR}\";" >> "$CONFFILE"
-       elif [ "${COMPRESSOR}" = 'lzma' ]; then
-               echo 'Dir::Bin::xz "/usr/bin/xz";' >> "$CONFFILE"
-               COMPRESSOR_CMD='xz --format=lzma'
-       else
-               msgtest 'Test for availability of compressor' "${COMPRESSOR}"
-               msgfail "${COMPRESSOR} not available"
-       fi
-}
-
-setupsimplenativepackage() {
-       local NAME="$1"
-       local ARCH="$2"
-       local VERSION="$3"
-       local RELEASE="${4:-unstable}"
-       local DEPENDENCIES="$5"
-       local DESCRIPTION="${6:-"an autogenerated dummy ${NAME}=${VERSION}/${RELEASE}
- If you find such a package installed on your system,
- something went horribly wrong! They are autogenerated
- und used only by testcases and surf no other propose…"}"
-
-       local SECTION="${7:-others}"
-       local DISTSECTION
-       if [ "$SECTION" = "${SECTION#*/}" ]; then
-               DISTSECTION="main"
-       else
-               DISTSECTION="${SECTION%/*}"
-       fi
-       local BUILDDIR=incoming/${NAME}-${VERSION}
-       mkdir -p ${BUILDDIR}/debian/source
-       cd ${BUILDDIR}
-       echo "* most suckless software product ever" > FEATURES
-       test -e debian/copyright || echo "Copyleft by Joe Sixpack $(date +%Y)" > debian/copyright
-       test -e debian/changelog || echo "$NAME ($VERSION) $RELEASE; urgency=low
-
-  * Initial release
-
- -- Joe Sixpack <joe@example.org>  $(date -R)" > debian/changelog
-       test -e debian/control || echo "Source: $NAME
-Section: $SECTION
-Priority: optional
-Maintainer: Joe Sixpack <joe@example.org>
-Build-Depends: debhelper (>= 7)
-Standards-Version: 3.9.1
-
-Package: $NAME" > debian/control
-       if [ "$ARCH" = 'all' ]; then
-               echo "Architecture: all" >> debian/control
-       else
-               echo "Architecture: any" >> debian/control
-       fi
-       test -z "$DEPENDENCIES" || echo "$DEPENDENCIES" >> debian/control
-       echo "Description: $DESCRIPTION" >> debian/control
-
-       test -e debian/compat || echo "7" > debian/compat
-       test -e debian/source/format || echo "3.0 (native)" > debian/source/format
-       test -e debian/rules || cp /usr/share/doc/debhelper/examples/rules.tiny debian/rules
-       cd - > /dev/null
+Dir::Bin::uncompressed \"/does/not/exist\";" > "$CONFFILE"
+       for COMP in $(aptconfig dump 'APT::Compressor' --format '%f%n' | cut -d':' -f 5 | uniq); do
+               if [ -z "$COMP" -o "$COMP" = '.' -o "$COMP" = "$COMPRESSOR" ]; then continue; fi
+               echo "Dir::Bin::${COMP} \"/does/not/exist\";" >> "$CONFFILE"
+               echo "APT::Compressor::${COMP}::Name \"${COMP}-disabled\";" >> "$CONFFILE"
+       done

 }
 
 }
 

-buildsimplenativepackage() {
+_setupsimplenativepackage() {

        local NAME="$1"
        local NAME="$1"

-       local NM
-       if [ "$(echo "$NAME" | cut -c 1-3)" = 'lib' ]; then
-               NM="$(echo "$NAME" | cut -c 1-4)"
-       else
-               NM="$(echo "$NAME" | cut -c 1)"
-       fi

        local ARCH="$2"
        local VERSION="$3"
        local RELEASE="${4:-unstable}"
        local ARCH="$2"
        local VERSION="$3"
        local RELEASE="${4:-unstable}"


@@ -636,7 +634,7 @@ buildsimplenativepackage() {
        local DESCRIPTION="${6:-"an autogenerated dummy ${NAME}=${VERSION}/${RELEASE}
  If you find such a package installed on your system,
  something went horribly wrong! They are autogenerated
        local DESCRIPTION="${6:-"an autogenerated dummy ${NAME}=${VERSION}/${RELEASE}
  If you find such a package installed on your system,
  something went horribly wrong! They are autogenerated

- und used only by testcases and surf no other propose…"}"
+ und used only by testcases and serve no other purpose…"}"

 
        local SECTION="${7:-others}"
        local PRIORITY="${8:-optional}"
 
        local SECTION="${7:-others}"
        local PRIORITY="${8:-optional}"


@@ -650,18 +648,17 @@ buildsimplenativepackage() {
        fi
        local BUILDDIR="${TMPWORKINGDIRECTORY}/incoming/${NAME}-${VERSION}"
 
        fi
        local BUILDDIR="${TMPWORKINGDIRECTORY}/incoming/${NAME}-${VERSION}"
 

-       msgtest "Build source package in version ${VERSION} for ${RELEASE} in ${DISTSECTION}" "$NAME"

        mkdir -p "$BUILDDIR/debian/source"
        echo "* most suckless software product ever" > "${BUILDDIR}/FEATURES"
        echo "#!/bin/sh
 echo '$NAME says \"Hello!\"'" > "${BUILDDIR}/${NAME}"
 
        mkdir -p "$BUILDDIR/debian/source"
        echo "* most suckless software product ever" > "${BUILDDIR}/FEATURES"
        echo "#!/bin/sh
 echo '$NAME says \"Hello!\"'" > "${BUILDDIR}/${NAME}"
 

-       echo "Copyleft by Joe Sixpack $(date +%Y)" > "${BUILDDIR}/debian/copyright"
+       echo "Copyleft by Joe Sixpack $(date -u +%Y)" > "${BUILDDIR}/debian/copyright"

        echo "$NAME ($VERSION) $RELEASE; urgency=low
 
   * Initial release
 
        echo "$NAME ($VERSION) $RELEASE; urgency=low
 
   * Initial release
 

- -- Joe Sixpack <joe@example.org>  $(date -R)" > "${BUILDDIR}/debian/changelog"
+ -- Joe Sixpack <joe@example.org>  $(date -u -R)" > "${BUILDDIR}/debian/changelog"

        {
                echo "Source: $NAME
 Priority: $PRIORITY
        {
                echo "Source: $NAME
 Priority: $PRIORITY


@@ -686,6 +683,37 @@ Package: $NAME"
        } > "${BUILDDIR}/debian/control"
 
        echo '3.0 (native)' > "${BUILDDIR}/debian/source/format"
        } > "${BUILDDIR}/debian/control"
 
        echo '3.0 (native)' > "${BUILDDIR}/debian/source/format"

+}
+
+setupsimplenativepackage() {
+       _setupsimplenativepackage "$@"
+       local NAME="$1"
+       local VERSION="$3"
+       local BUILDDIR="${TMPWORKINGDIRECTORY}/incoming/${NAME}-${VERSION}"
+       test -e "${BUILDDIR}/debian/compat" || echo '7' > "${BUILDDIR}/debian/compat"
+       test -e  "${BUILDDIR}/debian/rules" || cp /usr/share/doc/debhelper/examples/rules.tiny "${BUILDDIR}/debian/rules"
+}
+
+buildsimplenativepackage() {
+       local NAME="$1"
+       local ARCH="$2"
+       local VERSION="$3"
+       local RELEASE="${4:-unstable}"
+       local DEPENDENCIES="$5"
+       local DESCRIPTION="$6"
+       local SECTION="${7:-others}"
+       local PRIORITY="${8:-optional}"
+       local FILE_TREE="$9"
+       local COMPRESS_TYPE="${10:-gzip}"
+       local DISTSECTION
+       if [ "$SECTION" = "${SECTION#*/}" ]; then
+               DISTSECTION="main"
+       else
+               DISTSECTION="${SECTION%/*}"
+       fi
+       local BUILDDIR="${TMPWORKINGDIRECTORY}/incoming/${NAME}-${VERSION}"
+       msgtest "Build source package in version ${VERSION} for ${RELEASE} in ${DISTSECTION}" "$NAME"
+       _setupsimplenativepackage "$@"

        cd "${BUILDDIR}/.."
        testsuccess --nomsg dpkg-source -b ${NAME}-${VERSION}
        cd - >/dev/null
        cd "${BUILDDIR}/.."
        testsuccess --nomsg dpkg-source -b ${NAME}-${VERSION}
        cd - >/dev/null


@@ -719,6 +747,12 @@ Package: $NAME"
                echo "pool/${NAME}_${VERSION}_${arch}.deb" >> "${BUILDDIR}/../${RELEASE}.${DISTSECTION}.pkglist"
        done
 
                echo "pool/${NAME}_${VERSION}_${arch}.deb" >> "${BUILDDIR}/../${RELEASE}.${DISTSECTION}.pkglist"
        done
 

+       local NM
+       if [ "$(echo "$NAME" | cut -c 1-3)" = 'lib' ]; then
+               NM="$(echo "$NAME" | cut -c 1-4)"
+       else
+               NM="$(echo "$NAME" | cut -c 1)"
+       fi

        local CHANGEPATH="${BUILDDIR}/../${DISTSECTION}/${NM}/${NAME}/${NAME}_${VERSION}"
        mkdir -p "$CHANGEPATH"
        cp "${BUILDDIR}/debian/changelog" "$CHANGEPATH"
        local CHANGEPATH="${BUILDDIR}/../${DISTSECTION}/${NM}/${NAME}/${NAME}_${VERSION}"
        mkdir -p "$CHANGEPATH"
        cp "${BUILDDIR}/debian/changelog" "$CHANGEPATH"


@@ -784,7 +818,7 @@ EOF
        for DIST in $(find ./pool/ -maxdepth 1 -name '*.pkglist' -type f | cut -d'/' -f 3 | cut -d'.' -f 1 | sort | uniq); do
                cat <<EOF
 tree "dists/$DIST" {
        for DIST in $(find ./pool/ -maxdepth 1 -name '*.pkglist' -type f | cut -d'/' -f 3 | cut -d'.' -f 1 | sort | uniq); do
                cat <<EOF
 tree "dists/$DIST" {

-       Architectures "$ARCHS source";
+       Architectures "$ARCHS all source";

        FileList "${DIST}.\$(SECTION).pkglist";
        SourceFileList "${DIST}.\$(SECTION).srclist";
        Sections "$(find ./pool/ -maxdepth 1 -name "${DIST}.*.pkglist" -type f | cut -d'/' -f 3 | cut -d'.' -f 2 | sort | uniq | tr '\n' ' ')";
        FileList "${DIST}.\$(SECTION).pkglist";
        SourceFileList "${DIST}.\$(SECTION).srclist";
        Sections "$(find ./pool/ -maxdepth 1 -name "${DIST}.*.pkglist" -type f | cut -d'/' -f 3 | cut -d'.' -f 2 | sort | uniq | tr '\n' ' ')";


@@ -818,7 +852,7 @@ insertpackage() {
        local DESCRIPTION="${7:-"an autogenerated dummy ${NAME}=${VERSION}/${RELEASES}
  If you find such a package installed on your system,
  something went horribly wrong! They are autogenerated
        local DESCRIPTION="${7:-"an autogenerated dummy ${NAME}=${VERSION}/${RELEASES}
  If you find such a package installed on your system,
  something went horribly wrong! They are autogenerated

- und used only by testcases and surf no other propose…"}"
+ und used only by testcases and serve no other purpose…"}"

        local ARCHS=""
        for RELEASE in $(printf '%s' "$RELEASES" | tr ',' '\n'); do
                if [ "$RELEASE" = 'installed' ]; then
        local ARCHS=""
        for RELEASE in $(printf '%s' "$RELEASES" | tr ',' '\n'); do
                if [ "$RELEASE" = 'installed' ]; then


@@ -826,7 +860,7 @@ insertpackage() {
                        continue
                fi
                for arch in $(getarchitecturesfromcommalist "$ARCH"); do
                        continue
                fi
                for arch in $(getarchitecturesfromcommalist "$ARCH"); do

-                       if [ "$arch" = 'all' -o "$arch" = 'none' ]; then
+                       if [ "$arch" = 'none' ]; then

                                ARCHS="$(getarchitectures)"
                        else
                                ARCHS="$arch"
                                ARCHS="$(getarchitectures)"
                        else
                                ARCHS="$arch"


@@ -860,31 +894,33 @@ Description-en: $DESCRIPTION
 }
 
 insertsource() {
 }
 
 insertsource() {

-       local RELEASE="$1"
+       local RELEASES="$1"

        local NAME="$2"
        local ARCH="$3"
        local VERSION="$4"
        local DEPENDENCIES="$5"
        local NAME="$2"
        local ARCH="$3"
        local VERSION="$4"
        local DEPENDENCIES="$5"

-        local BINARY="${6:-$NAME}"
+       local BINARY="${6:-$NAME}"

        local ARCHS=""
        local ARCHS=""

-       local SPATH="aptarchive/dists/${RELEASE}/main/source"
-       mkdir -p $SPATH
-       local FILE="${SPATH}/Sources"
-       local DSCFILE="${NAME}_${VERSION}.dsc"
-       local TARFILE="${NAME}_${VERSION}.tar.gz"
-       echo "Package: $NAME
+       for RELEASE in $(printf '%s' "$RELEASES" | tr ',' '\n'); do
+               local SPATH="aptarchive/dists/${RELEASE}/main/source"
+               mkdir -p $SPATH
+               local FILE="${SPATH}/Sources"
+               local DSCFILE="${NAME}_${VERSION}.dsc"
+               local TARFILE="${NAME}_${VERSION}.tar.gz"
+               echo "Package: $NAME

 Binary: $BINARY
 Version: $VERSION
 Maintainer: Joe Sixpack <joe@example.org>
 Architecture: $ARCH" >> $FILE
 Binary: $BINARY
 Version: $VERSION
 Maintainer: Joe Sixpack <joe@example.org>
 Architecture: $ARCH" >> $FILE

-       test -z "$DEPENDENCIES" || echo "$DEPENDENCIES" >> "$FILE"
-       echo "Files:
+               test -z "$DEPENDENCIES" || echo "$DEPENDENCIES" >> "$FILE"
+               echo "Files:

  $(echo -n "$DSCFILE" | md5sum | cut -d' ' -f 1) $(echo -n "$DSCFILE" | wc -c) "$DSCFILE"
  $(echo -n "$TARFILE" | md5sum | cut -d' ' -f 1) $(echo -n "$TARFILE" | wc -c) "$TARFILE"
 Checksums-Sha256:
  $(echo -n "$DSCFILE" | sha256sum | cut -d' ' -f 1) $(echo -n "$DSCFILE" | wc -c) "$DSCFILE"
  $(echo -n "$TARFILE" | sha256sum | cut -d' ' -f 1) $(echo -n "$TARFILE" | wc -c) "$TARFILE"
 " >> "$FILE"
  $(echo -n "$DSCFILE" | md5sum | cut -d' ' -f 1) $(echo -n "$DSCFILE" | wc -c) "$DSCFILE"
  $(echo -n "$TARFILE" | md5sum | cut -d' ' -f 1) $(echo -n "$TARFILE" | wc -c) "$TARFILE"
 Checksums-Sha256:
  $(echo -n "$DSCFILE" | sha256sum | cut -d' ' -f 1) $(echo -n "$DSCFILE" | wc -c) "$DSCFILE"
  $(echo -n "$TARFILE" | sha256sum | cut -d' ' -f 1) $(echo -n "$TARFILE" | wc -c) "$TARFILE"
 " >> "$FILE"

+       done

 }
 
 insertinstalledpackage() {
 }
 
 insertinstalledpackage() {


@@ -897,7 +933,7 @@ insertinstalledpackage() {
        local DESCRIPTION="${7:-"an autogenerated dummy ${NAME}=${VERSION}/installed
  If you find such a package installed on your system,
  something went horribly wrong! They are autogenerated
        local DESCRIPTION="${7:-"an autogenerated dummy ${NAME}=${VERSION}/installed
  If you find such a package installed on your system,
  something went horribly wrong! They are autogenerated

- und used only by testcases and surf no other propose…"}"
+ und used only by testcases and serve no other purpose…"}"

 
        local FILE='rootdir/var/lib/dpkg/status'
        local INFO='rootdir/var/lib/dpkg/info'
 
        local FILE='rootdir/var/lib/dpkg/status'
        local INFO='rootdir/var/lib/dpkg/info'


@@ -948,7 +984,7 @@ buildaptarchivefromfiles() {
 }
 
 compressfile() {
 }
 
 compressfile() {

-       cat "${TMPWORKINGDIRECTORY}/rootdir/etc/testcase-compressor.conf" | while read compressor extension command; do
+       while read compressor extension command; do

                if [ "$compressor" = '.' ]; then
                        if [ -n "$2" ]; then
                                touch -d "$2" "$1"
                if [ "$compressor" = '.' ]; then
                        if [ -n "$2" ]; then
                                touch -d "$2" "$1"


@@ -959,7 +995,7 @@ compressfile() {
                if [ -n "$2" ]; then
                        touch -d "$2" "${1}.${extension}"
                fi
                if [ -n "$2" ]; then
                        touch -d "$2" "${1}.${extension}"
                fi

-       done
+       done < "${TMPWORKINGDIRECTORY}/rootdir/etc/testcase-compressor.conf"

 }
 
 # can be overridden by testcases for their pleasure
 }
 
 # can be overridden by testcases for their pleasure


@@ -972,6 +1008,7 @@ getcodenamefromsuite() {
 getreleaseversionfromsuite() { true; }
 getlabelfromsuite() { true; }
 getoriginfromsuite() { true; }
 getreleaseversionfromsuite() { true; }
 getlabelfromsuite() { true; }
 getoriginfromsuite() { true; }

+getarchitecturesfromreleasefile() { echo "all $(getarchitectures)"; }

 
 aptftparchiverelease() {
        aptftparchive -qq release "$@" | sed -e '/0 Release$/ d' # remove the self reference
 
 aptftparchiverelease() {
        aptftparchive -qq release "$@" | sed -e '/0 Release$/ d' # remove the self reference


@@ -979,29 +1016,24 @@ aptftparchiverelease() {
 generatereleasefiles() {
        # $1 is the Date header and $2 is the ValidUntil header to be set
        # both should be given in notation date/touch can understand
 generatereleasefiles() {
        # $1 is the Date header and $2 is the ValidUntil header to be set
        # both should be given in notation date/touch can understand

-       msgninfo "\tGenerate Release files… "
+       local DATE="$1"
+       local VALIDUNTIL="$2"

        if [ -e aptarchive/dists ]; then
        if [ -e aptarchive/dists ]; then

+               msgninfo "\tGenerate Release files for dists… "

                for dir in $(find ./aptarchive/dists -mindepth 1 -maxdepth 1 -type d); do
                for dir in $(find ./aptarchive/dists -mindepth 1 -maxdepth 1 -type d); do

+                       local ARCHITECTURES="$(getarchitecturesfromreleasefile "$dir")"

                        local SUITE="$(echo "$dir" | cut -d'/' -f 4)"
                        local CODENAME="$(getcodenamefromsuite $SUITE)"
                        local VERSION="$(getreleaseversionfromsuite $SUITE)"
                        local LABEL="$(getlabelfromsuite $SUITE)"
                        local ORIGIN="$(getoriginfromsuite $SUITE)"
                        local SUITE="$(echo "$dir" | cut -d'/' -f 4)"
                        local CODENAME="$(getcodenamefromsuite $SUITE)"
                        local VERSION="$(getreleaseversionfromsuite $SUITE)"
                        local LABEL="$(getlabelfromsuite $SUITE)"
                        local ORIGIN="$(getoriginfromsuite $SUITE)"

-                       if [ -n "$VERSION" ]; then
-                               VERSION="-o APT::FTPArchive::Release::Version=${VERSION}"
-                       fi
-                       if [ -n "$LABEL" ]; then
-                               LABEL="-o APT::FTPArchive::Release::Label=${LABEL}"
-                       fi
-                       if [ -n "$ORIGIN" ]; then
-                               ORIGIN="-o APT::FTPArchive::Release::Origin=${ORIGIN}"
-                       fi

                        aptftparchiverelease "$dir" \
                                -o APT::FTPArchive::Release::Suite="${SUITE}" \
                                -o APT::FTPArchive::Release::Codename="${CODENAME}" \
                        aptftparchiverelease "$dir" \
                                -o APT::FTPArchive::Release::Suite="${SUITE}" \
                                -o APT::FTPArchive::Release::Codename="${CODENAME}" \

-                               ${LABEL} \
-                               ${ORIGIN} \
-                               ${VERSION} \
+                               -o APT::FTPArchive::Release::Architectures="${ARCHITECTURES}" \
+                               -o APT::FTPArchive::Release::Label="${LABEL}" \
+                               -o APT::FTPArchive::Release::Origin="${ORIGIN}" \
+                               -o APT::FTPArchive::Release::Version="${VERSION}" \

                                > "$dir/Release"
                        if [ "$SUITE" = "experimental" -o "$SUITE" = "experimental2" ]; then
                                sed -i '/^Date: / a\
                                > "$dir/Release"
                        if [ "$SUITE" = "experimental" -o "$SUITE" = "experimental2" ]; then
                                sed -i '/^Date: / a\


@@ -1009,17 +1041,18 @@ NotAutomatic: yes' "$dir/Release"
                        fi
                done
        else
                        fi
                done
        else

+               msgninfo "\tGenerate Release files for flat… "

                aptftparchiverelease ./aptarchive > aptarchive/Release
        fi
                aptftparchiverelease ./aptarchive > aptarchive/Release
        fi

-       if [ -n "$1" -a "$1" != "now" ]; then
+       if [ -n "$DATE" -a "$DATE" != "now" ]; then

                for release in $(find ./aptarchive -name 'Release'); do
                for release in $(find ./aptarchive -name 'Release'); do

-                       sed -i "s/^Date: .*$/Date: $(date -d "$1" '+%a, %d %b %Y %H:%M:%S %Z')/" "$release"
-                       touch -d "$1" "$release"
+                       sed -i "s/^Date: .*$/Date: $(date -u -d "$DATE" -R)/" "$release"
+                       touch -d "$DATE" "$release"

                done
        fi
                done
        fi

-       if [ -n "$2" ]; then
+       if [ -n "$VALIDUNTIL" ]; then

                sed -i "/^Date: / a\
                sed -i "/^Date: / a\

-Valid-Until: $(date -d "$2" '+%a, %d %b %Y %H:%M:%S %Z')" $(find ./aptarchive -name 'Release')
+Valid-Until: $(date -u -d "$VALIDUNTIL" -R)" $(find ./aptarchive -name 'Release')

        fi
        msgdone "info"
 }
        fi
        msgdone "info"
 }


@@ -1075,40 +1108,73 @@ setupaptarchive() {
 }
 
 signreleasefiles() {
 }
 
 signreleasefiles() {

-       local SIGNER="${1:-Joe Sixpack}"
+       local SIGNERS="${1:-Joe Sixpack}"

        local REPODIR="${2:-aptarchive}"
        local REPODIR="${2:-aptarchive}"

-       local KEY="keys/$(echo "$SIGNER" | tr 'A-Z' 'a-z' | sed 's# ##g')"
-       local GPG="aptkey --quiet --keyring ${KEY}.pub --secret-keyring ${KEY}.sec --readonly adv --batch --yes"
-       msgninfo "\tSign archive with $SIGNER key $KEY… "
+       if [ -n "$1" ]; then shift; fi
+       if [ -n "$1" ]; then shift; fi
+       local KEY="keys/$(echo "$SIGNERS" | tr 'A-Z' 'a-z' | tr -d ' ,')"
+       msgninfo "\tSign archive with $SIGNERS key $KEY… "

        local REXKEY='keys/rexexpired'
        local SECEXPIREBAK="${REXKEY}.sec.bak"
        local PUBEXPIREBAK="${REXKEY}.pub.bak"
        local REXKEY='keys/rexexpired'
        local SECEXPIREBAK="${REXKEY}.sec.bak"
        local PUBEXPIREBAK="${REXKEY}.pub.bak"

-       if [ "${SIGNER}" = 'Rex Expired' ]; then
-               # the key is expired, so gpg doesn't allow to sign with and the --faked-system-time
-               # option doesn't exist anymore (and using faketime would add a new obscure dependency)
-               # therefore we 'temporary' make the key not expired and restore a backup after signing
-               cp "${REXKEY}.sec" "$SECEXPIREBAK"
-               cp "${REXKEY}.pub" "$PUBEXPIREBAK"
-               local SECUNEXPIRED="${REXKEY}.sec.unexpired"
-               local PUBUNEXPIRED="${REXKEY}.pub.unexpired"
-               if [ -f "$SECUNEXPIRED" ] && [ -f "$PUBUNEXPIRED" ]; then
-                       cp "$SECUNEXPIRED" "${REXKEY}.sec"
-                       cp "$PUBUNEXPIRED" "${REXKEY}.pub"
-               else
-                       if ! printf "expire\n1w\nsave\n" | $GPG --default-key "$SIGNER" --command-fd 0 --edit-key "${SIGNER}" >setexpire.gpg 2>&1; then
-                               cat setexpire.gpg
-                               exit 1
+       local SIGUSERS=""
+       while [ -n "${SIGNERS%%,*}" ]; do
+               local SIGNER="${SIGNERS%%,*}"
+               if [ "${SIGNERS}" = "${SIGNER}" ]; then
+                       SIGNERS=""
+               fi
+               SIGNERS="${SIGNERS#*,}"
+               # FIXME: This should be the full name, but we can't encode the space properly currently
+               SIGUSERS="${SIGUSERS} -u ${SIGNER#* }"
+               if [ "${SIGNER}" = 'Rex Expired' ]; then
+                       # the key is expired, so gpg doesn't allow to sign with and the --faked-system-time
+                       # option doesn't exist anymore (and using faketime would add a new obscure dependency)
+                       # therefore we 'temporary' make the key not expired and restore a backup after signing
+                       cp "${REXKEY}.sec" "$SECEXPIREBAK"
+                       cp "${REXKEY}.pub" "$PUBEXPIREBAK"
+                       local SECUNEXPIRED="${REXKEY}.sec.unexpired"
+                       local PUBUNEXPIRED="${REXKEY}.pub.unexpired"
+                       if [ -f "$SECUNEXPIRED" ] && [ -f "$PUBUNEXPIRED" ]; then
+                               cp "$SECUNEXPIRED" "${REXKEY}.sec"
+                               cp "$PUBUNEXPIRED" "${REXKEY}.pub"
+                       else
+                               if ! printf "expire\n1w\nsave\n" | aptkey --quiet --keyring "${REXKEY}.pub" --secret-keyring "${REXKEY}.sec" \
+                                       --readonly adv --batch --yes --digest-algo "${APT_TESTS_DIGEST_ALGO:-SHA512}" \
+                                       --default-key "$SIGNER" --command-fd 0 --edit-key "${SIGNER}" >setexpire.gpg 2>&1; then
+                                       cat setexpire.gpg
+                                       exit 1
+                               fi
+                               cp "${REXKEY}.sec" "$SECUNEXPIRED"
+                               cp "${REXKEY}.pub" "$PUBUNEXPIRED"

                        fi
                        fi

-                       cp "${REXKEY}.sec" "$SECUNEXPIRED"
-                       cp "${REXKEY}.pub" "$PUBUNEXPIRED"

                fi
                fi

+               if [ ! -e "${KEY}.pub" ]; then
+                       local K="keys/$(echo "$SIGNER" | tr 'A-Z' 'a-z' | tr -d ' ,')"
+                       cat "${K}.pub" >> "${KEY}.new.pub"
+                       cat "${K}.sec" >> "${KEY}.new.sec"
+               fi
+       done
+       if [ ! -e "${KEY}.pub" ]; then
+               mv "${KEY}.new.pub" "${KEY}.pub"
+               mv "${KEY}.new.sec" "${KEY}.sec"

        fi
        fi

+       local GPG="aptkey --quiet --keyring ${KEY}.pub --secret-keyring ${KEY}.sec --readonly adv --batch --yes --digest-algo ${APT_TESTS_DIGEST_ALGO:-SHA512}"

        for RELEASE in $(find "${REPODIR}/" -name Release); do
        for RELEASE in $(find "${REPODIR}/" -name Release); do

-               $GPG --default-key "$SIGNER" --armor --detach-sign --sign --output "${RELEASE}.gpg" "${RELEASE}"
-               local INRELEASE="$(echo "${RELEASE}" | sed 's#/Release$#/InRelease#')"
-               $GPG --default-key "$SIGNER" --clearsign --output "$INRELEASE" "$RELEASE"

                # we might have set a specific date for the Release file, so copy it
                # we might have set a specific date for the Release file, so copy it

-               touch -d "$(stat --format "%y" ${RELEASE})" "${RELEASE}.gpg" "${INRELEASE}"
+               local DATE="$(stat --format "%y" "${RELEASE}")"
+               if [ "$APT_DONT_SIGN" = 'Release.gpg' ]; then
+                       rm -f "${RELEASE}.gpg"
+               else
+                       testsuccess $GPG "$@" $SIGUSERS --armor --detach-sign --sign --output "${RELEASE}.gpg" "${RELEASE}"
+                       touch -d "$DATE" "${RELEASE}.gpg"
+               fi
+               local INRELEASE="${RELEASE%/*}/InRelease"
+               if [ "$APT_DONT_SIGN" = 'InRelease' ]; then
+                       rm -f "$INRELEASE"
+               else
+                       testsuccess $GPG "$@" $SIGUSERS --clearsign --output "$INRELEASE" "$RELEASE"
+                       touch -d "$DATE" "${INRELEASE}"
+               fi

        done
        if [ -f "$SECEXPIREBAK" ] && [ -f "$PUBEXPIREBAK" ]; then
                mv -f "$SECEXPIREBAK" "${REXKEY}.sec"
        done
        if [ -f "$SECEXPIREBAK" ] && [ -f "$PUBEXPIREBAK" ]; then
                mv -f "$SECEXPIREBAK" "${REXKEY}.sec"


@@ -1118,7 +1184,7 @@ signreleasefiles() {
 }
 
 redatereleasefiles() {
 }
 
 redatereleasefiles() {

-       local DATE="$(date -d "$1" '+%a, %d %b %Y %H:%M:%S %Z')"
+       local DATE="$(date -u -d "$1" -R)"

        for release in $(find aptarchive/ -name 'Release'); do
                sed -i "s/^Date: .*$/Date: ${DATE}/" "$release"
                touch -d "$DATE" "$release"
        for release in $(find aptarchive/ -name 'Release'); do
                sed -i "s/^Date: .*$/Date: ${DATE}/" "$release"
                touch -d "$DATE" "$release"


@@ -1160,8 +1226,8 @@ rewritesourceslist() {
        local APTARCHIVE2="copy://$(readlink -f "${TMPWORKINGDIRECTORY}/aptarchive" | sed 's# #%20#g')"
        for LIST in $(find rootdir/etc/apt/sources.list.d/ -name 'apt-test-*.list'); do
                sed -i $LIST -e "s#$APTARCHIVE#${1}#" -e "s#$APTARCHIVE2#${1}#" \
        local APTARCHIVE2="copy://$(readlink -f "${TMPWORKINGDIRECTORY}/aptarchive" | sed 's# #%20#g')"
        for LIST in $(find rootdir/etc/apt/sources.list.d/ -name 'apt-test-*.list'); do
                sed -i $LIST -e "s#$APTARCHIVE#${1}#" -e "s#$APTARCHIVE2#${1}#" \

-                       -e "s#http://localhost:${APTHTTPPORT}/#${1}#" \
-                       -e "s#https://localhost:${APTHTTPSPORT}/#${1}#"
+                       -e "s#http://[^@]*@\?localhost:${APTHTTPPORT}/\?#${1}#" \
+                       -e "s#https://[^@]*@\?localhost:${APTHTTPSPORT}/\?#${1}#"

        done
 }
 
        done
 }
 


@@ -1190,7 +1256,7 @@ changetowebserver() {
                cd aptarchive
                local LOG="webserver.log"
                if ! aptwebserver --port 0 -o aptwebserver::fork=1 -o aptwebserver::portfile='aptwebserver.port' "$@" >$LOG 2>&1 ; then
                cd aptarchive
                local LOG="webserver.log"
                if ! aptwebserver --port 0 -o aptwebserver::fork=1 -o aptwebserver::portfile='aptwebserver.port' "$@" >$LOG 2>&1 ; then

-                       cat $LOG
+                       cat "$LOG"

                        false
                fi
                waitforpidfile aptwebserver.pid
                        false
                fi
                waitforpidfile aptwebserver.pid


@@ -1206,7 +1272,7 @@ changetowebserver() {
                fi
                cd - > /dev/null
        else
                fi
                cd - > /dev/null
        else

-               msgdie 'You have to build aptwerbserver or install a webserver'
+               msgdie 'You have to build apt from source to have test/interactive-helper/aptwebserver available for tests requiring a webserver'

        fi
        if [ "$REWRTE" != 'yes' ]; then
                rewritesourceslist "http://localhost:${APTHTTPPORT}/"
        fi
        if [ "$REWRTE" != 'yes' ]; then
                rewritesourceslist "http://localhost:${APTHTTPPORT}/"


@@ -1214,7 +1280,7 @@ changetowebserver() {
 }
 
 changetohttpswebserver() {
 }
 
 changetohttpswebserver() {

-       if ! which stunnel4 >/dev/null; then
+       if ! command -v stunnel4 >/dev/null 2>&1; then

                msgdie 'You need to install stunnel4 for https testcases'
        fi
        if [ ! -e "${TMPWORKINGDIRECTORY}/aptarchive/aptwebserver.pid" ]; then
                msgdie 'You need to install stunnel4 for https testcases'
        fi
        if [ ! -e "${TMPWORKINGDIRECTORY}/aptarchive/aptwebserver.pid" ]; then


@@ -1235,7 +1301,7 @@ connect = $APTHTTPPORT
                msgdie 'Could not fork stunnel4 successfully'
        fi
        addtrap 'prefix' "kill ${PID};"
                msgdie 'Could not fork stunnel4 successfully'
        fi
        addtrap 'prefix' "kill ${PID};"

-       APTHTTPSPORT="$(lsof -i | awk "/^stunnel4 / && \$2 == \"${PID}\" {print \$9; exit; }" | cut -d':' -f 2)"
+       APTHTTPSPORT="$(lsof -i -n | awk "/^stunnel4 / && \$2 == \"${PID}\" {print \$9; exit; }" | cut -d':' -f 2)"

        webserverconfig 'aptwebserver::port::https' "$APTHTTPSPORT" "https://localhost:${APTHTTPSPORT}"
        rewritesourceslist "https://localhost:${APTHTTPSPORT}/"
 }
        webserverconfig 'aptwebserver::port::https' "$APTHTTPSPORT" "https://localhost:${APTHTTPSPORT}"
        rewritesourceslist "https://localhost:${APTHTTPSPORT}/"
 }


@@ -1260,7 +1326,7 @@ EOF
        # start with an unmounted disk
        mv "${CD}" "${CD}-unmounted"
        # we don't want the disk to be modifiable
        # start with an unmounted disk
        mv "${CD}" "${CD}-unmounted"
        # we don't want the disk to be modifiable

-       addtrap 'prefix' "chmod -f -R +w \"$PWD/rootdir/media/cdrom/dists/\" \"$PWD/rootdir/media/cdrom-unmounted/dists/\" || true;"
+       addtrap 'prefix' "chmod -f -R +w '$(escape_shell "$PWD/rootdir/media/cdrom/dists/")' '$(escape_shell "$PWD/rootdir/media/cdrom-unmounted/dists/")' || true;"

        chmod -R 555 rootdir/media/cdrom-unmounted/dists
 }
 
        chmod -R 555 rootdir/media/cdrom-unmounted/dists
 }
 


@@ -1325,9 +1391,13 @@ testfileequal() {
 
 testempty() {
        msggroup 'testempty'
 
 testempty() {
        msggroup 'testempty'

-       msgtest "Test for no output of" "$*"
+       if [ "$1" = '--nomsg' ]; then
+               shift
+       else
+               msgtest "Test for no output of" "$*"
+       fi

        local COMPAREFILE="${TMPWORKINGDIRECTORY}/rootdir/tmp/testempty.comparefile"
        local COMPAREFILE="${TMPWORKINGDIRECTORY}/rootdir/tmp/testempty.comparefile"

-       if ("$@" >"$COMPAREFILE" 2>&1 || true) && test ! -s "$COMPAREFILE"; then
+       if "$@" >"$COMPAREFILE" 2>&1 && test ! -s "$COMPAREFILE"; then

                msgpass
        else
                msgfailoutput '' "$COMPAREFILE" "$@"
                msgpass
        else
                msgfailoutput '' "$COMPAREFILE" "$@"


@@ -1412,7 +1482,7 @@ N: No packages found"
        local ARCH="$(getarchitecture 'native')"
        echo "$VIRTUAL" | sed -e "s/:$ARCH//" -e 's/:all//' >"$COMPAREFILE"
        local OUTPUT="${TMPWORKINGDIRECTORY}/rootdir/tmp/testshowvirtual.output"
        local ARCH="$(getarchitecture 'native')"
        echo "$VIRTUAL" | sed -e "s/:$ARCH//" -e 's/:all//' >"$COMPAREFILE"
        local OUTPUT="${TMPWORKINGDIRECTORY}/rootdir/tmp/testshowvirtual.output"

-       testoutputequal "$COMPAREFILE" aptcache show -q=0 "$PACKAGE"
+       testoutputequal "$COMPAREFILE" aptcache show "$PACKAGE"

        msggroup
 }
 
        msggroup
 }
 


@@ -1429,6 +1499,19 @@ testnopackage() {
        fi
        msggroup
 }
        fi
        msggroup
 }

+testnosrcpackage() {
+       msggroup 'testnosrcpackage'
+       msgtest "Test for non-existent source packages" "apt-cache showsrc $*"
+       local SHOWPKG="$(aptcache showsrc "$@" 2>&1 | grep '^Package: ')"
+       if [ -n "$SHOWPKG" ]; then
+               local OUTPUT="${TMPWORKINGDIRECTORY}/rootdir/tmp/testnosrcpackage.output"
+               echo "$SHOWPKG" >"$OUTPUT"
+               msgfailoutput '' "$OUTPUT"
+       else
+               msgpass
+       fi
+       msggroup
+}

 
 testdpkgstatus() {
        msggroup 'testdpkgstatus'
 
 testdpkgstatus() {
        msggroup 'testdpkgstatus'


@@ -1487,17 +1570,26 @@ testmarkedmanual() {
        msggroup
 }
 
        msggroup
 }
 

+catfile() {
+       if [ "${1##*.}" = 'deb' ]; then
+               stat >&2 "$1" || true
+               file >&2 "$1" || true
+       else
+               cat >&2 "$1" || true
+       fi
+}

 msgfailoutput() {
        msgreportheader 'msgfailoutput'
        local MSG="$1"
        local OUTPUT="$2"
        shift 2
 msgfailoutput() {
        msgreportheader 'msgfailoutput'
        local MSG="$1"
        local OUTPUT="$2"
        shift 2

-       if [ "$1" = 'grep' ]; then
+       local CMD="$1"
+       if [ "$1" = 'grep' -o "$1" = 'tail' -o "$1" = 'head' ]; then

                echo >&2
                while [ -n "$2" ]; do shift; done
                echo "#### Complete file: $1 ####"
                echo >&2
                while [ -n "$2" ]; do shift; done
                echo "#### Complete file: $1 ####"

-               cat >&2 "$1" || true
-               echo '#### grep output ####'
+               catfile "$1"
+               echo "#### $CMD output ####"

        elif [ "$1" = 'test' ]; then
                echo >&2
                # doesn't support ! or non-file flags
        elif [ "$1" = 'test' ]; then
                echo >&2
                # doesn't support ! or non-file flags


@@ -1506,9 +1598,12 @@ msgfailoutput() {
                        if expr match "$1" "$FILEFLAGS" >/dev/null; then
                                echo "#### stat(2) of file: $2 ####"
                                stat "$2" || true
                        if expr match "$1" "$FILEFLAGS" >/dev/null; then
                                echo "#### stat(2) of file: $2 ####"
                                stat "$2" || true

-                               if test -e "$2"; then
+                               if test -d "$2"; then
+                                       echo "#### The directory contains: $2 ####"
+                                       ls >&2 "$2" || true
+                               elif test -e "$2"; then

                                        echo "#### Complete file: $2 ####"
                                        echo "#### Complete file: $2 ####"

-                                       cat >&2 "$2" || true
+                                       catfile "$2"

                                fi
                        fi
                }
                                fi
                        fi
                }


@@ -1518,24 +1613,35 @@ msgfailoutput() {
                        msgfailoutputstatfile "$2" "$3"
                done
                echo '#### test output ####'
                        msgfailoutputstatfile "$2" "$3"
                done
                echo '#### test output ####'

+       elif [ "$1" = 'cmp' ]; then
+               echo >&2
+               while [ -n "$2" ]; do
+                       echo "#### Complete file: $2 ####"
+                       catfile "$2"
+                       shift
+               done
+               echo '#### cmp output ####'

        fi
        fi

-       cat >&2 "$OUTPUT"
+       catfile "$OUTPUT"

        msgfail "$MSG"
 }
 
        msgfail "$MSG"
 }
 

-testsuccess() {
-       msggroup 'testsuccess'
+testsuccesswithglobalerror() {
+       local TYPE="$1"
+       local ERRORS="$2"
+       shift 2
+       msggroup "$TYPE"

        if [ "$1" = '--nomsg' ]; then
                shift
        else
                msgtest 'Test for successful execution of' "$*"
        fi
        if [ "$1" = '--nomsg' ]; then
                shift
        else
                msgtest 'Test for successful execution of' "$*"
        fi

-       local OUTPUT="${TMPWORKINGDIRECTORY}/rootdir/tmp/testsuccess.output"
+       local OUTPUT="${TMPWORKINGDIRECTORY}/rootdir/tmp/${TYPE}.output"

        if "$@" >"${OUTPUT}" 2>&1; then
                if expr match "$1" '^apt.*' >/dev/null; then
                        if grep -q -E ' runtime error: ' "$OUTPUT"; then
                                msgfailoutput 'compiler detected undefined behavior' "$OUTPUT" "$@"
        if "$@" >"${OUTPUT}" 2>&1; then
                if expr match "$1" '^apt.*' >/dev/null; then
                        if grep -q -E ' runtime error: ' "$OUTPUT"; then
                                msgfailoutput 'compiler detected undefined behavior' "$OUTPUT" "$@"

-                       elif grep -E '^[WE]: ' "$OUTPUT" > "${TMPWORKINGDIRECTORY}/rootdir/tmp/checkforwarnings.output" 2>&1; then
+                       elif grep -E "^[${ERRORS}]: " "$OUTPUT" > "${TMPWORKINGDIRECTORY}/rootdir/tmp/checkforwarnings.output" 2>&1; then

                                if [ "$IGNORE_PTY_NOT_MOUNTED" = '1' ]; then
                                        if echo 'E: Can not write log (Is /dev/pts mounted?) - posix_openpt (2: No such file or directory)' \
                                                | cmp - "${TMPWORKINGDIRECTORY}/rootdir/tmp/checkforwarnings.output" >/dev/null 2>&1; then
                                if [ "$IGNORE_PTY_NOT_MOUNTED" = '1' ]; then
                                        if echo 'E: Can not write log (Is /dev/pts mounted?) - posix_openpt (2: No such file or directory)' \
                                                | cmp - "${TMPWORKINGDIRECTORY}/rootdir/tmp/checkforwarnings.output" >/dev/null 2>&1; then


@@ -1546,6 +1652,12 @@ testsuccess() {
                                else
                                        msgfailoutput 'successful run, but output contains warnings/errors' "$OUTPUT" "$@"
                                fi
                                else
                                        msgfailoutput 'successful run, but output contains warnings/errors' "$OUTPUT" "$@"
                                fi

+                       elif [ "$TYPE" = 'testsuccesswithnotice' ]; then
+                               if grep -q -E "^N: " "$OUTPUT"; then
+                                       msgpass
+                               else
+                                       msgfailoutput 'successful run, but output had no notices' "$OUTPUT" "$@"
+                               fi

                        else
                                msgpass
                        fi
                        else
                                msgpass
                        fi


@@ -1556,9 +1668,15 @@ testsuccess() {
                local EXITCODE=$?
                msgfailoutput "exitcode $EXITCODE" "$OUTPUT" "$@"
        fi
                local EXITCODE=$?
                msgfailoutput "exitcode $EXITCODE" "$OUTPUT" "$@"
        fi

-       aptautotest 'testsuccess' "$@"
+       aptautotest "$TYPE" "$@"

        msggroup
 }
        msggroup
 }

+testsuccesswithnotice() {
+       testsuccesswithglobalerror 'testsuccesswithnotice' 'WE' "$@"
+}
+testsuccess() {
+       testsuccesswithglobalerror 'testsuccess' 'NWE' "$@"
+}

 testwarning() {
        msggroup 'testwarning'
        if [ "$1" = '--nomsg' ]; then
 testwarning() {
        msggroup 'testwarning'
        if [ "$1" = '--nomsg' ]; then


@@ -1603,8 +1721,9 @@ testfailure() {
                local EXITCODE=$?
                if expr match "$1" '^apt.*' >/dev/null; then
                        if [ "$1" = 'aptkey' ]; then
                local EXITCODE=$?
                if expr match "$1" '^apt.*' >/dev/null; then
                        if [ "$1" = 'aptkey' ]; then

-                               if grep -q -E " Can't check signature: " "$OUTPUT" || \
-                                       grep -q -E " BAD signature from " "$OUTPUT"; then
+                               if grep -q " Can't check signature: 
+ BAD signature from 
+ signature could not be verified" "$OUTPUT"; then

                                        msgpass
                                else
                                        msgfailoutput "run failed with exitcode ${EXITCODE}, but no signature error" "$OUTPUT" "$@"
                                        msgpass
                                else
                                        msgfailoutput "run failed with exitcode ${EXITCODE}, but no signature error" "$OUTPUT" "$@"


@@ -1630,22 +1749,41 @@ testfailure() {
 
 testreturnstateequal() {
        local STATE="$1"
 
 testreturnstateequal() {
        local STATE="$1"

-       msggroup "${STATE}equal"
-       if [ "$2" != '--nomsg' ]; then
-               local CMP="$2"
-               shift 2
-               "$STATE" "$@"
-               testfileequal "${TMPWORKINGDIRECTORY}/rootdir/tmp/${STATE}.output" "$CMP"
-       else
-               local CMP="$3"
+       if [ "$STATE" = 'testsuccesswithglobalerror' ]; then
+               local STATE="$2"
+               local TYPE="$3"

                shift 3
                shift 3

-               "$STATE" --nomsg "$@"
-               testfileequal "${TMPWORKINGDIRECTORY}/rootdir/tmp/${STATE}.output" "$CMP"
+               msggroup "${STATE}equal"
+               if [ "$1" != '--nomsg' ]; then
+                       local CMP="$1"
+                       shift
+                       testsuccesswithglobalerror "$STATE" "$TYPE" "$@"
+                       testfileequal "${TMPWORKINGDIRECTORY}/rootdir/tmp/${STATE}.output" "$CMP"
+               else
+                       local CMP="$2"
+                       shift 2
+                       testsuccesswithglobalerror "$STATE" "$TYPE" "$@"
+                       testfileequal "${TMPWORKINGDIRECTORY}/rootdir/tmp/${STATE}.output" "$CMP"
+               fi
+       else
+               msggroup "${STATE}equal"
+               if [ "$2" != '--nomsg' ]; then
+                       local CMP="$2"
+                       shift 2
+                       "$STATE" "$@"
+                       testfileequal "${TMPWORKINGDIRECTORY}/rootdir/tmp/${STATE}.output" "$CMP"
+               else
+                       local CMP="$3"
+                       shift 3
+                       "$STATE" --nomsg "$@"
+                       testfileequal "${TMPWORKINGDIRECTORY}/rootdir/tmp/${STATE}.output" "$CMP"
+               fi

        fi
        msggroup
 }
 testsuccessequal() {
        fi
        msggroup
 }
 testsuccessequal() {

-       testreturnstateequal 'testsuccess' "$@"
+       # we compare output, so we know perfectly well about N:
+       testreturnstateequal 'testsuccesswithglobalerror' 'testsuccess' 'WE' "$@"

 }
 testwarningequal() {
        testreturnstateequal 'testwarning' "$@"
 }
 testwarningequal() {
        testreturnstateequal 'testwarning' "$@"


@@ -1661,7 +1799,18 @@ testfailuremsg() {
        testfailure "$@"
        msgtest 'Check that the output of the previous failed command has expected' 'failures and warnings'
        local COMPAREFILE="${TMPWORKINGDIRECTORY}/rootdir/tmp/testfailuremsg.comparefile"
        testfailure "$@"
        msgtest 'Check that the output of the previous failed command has expected' 'failures and warnings'
        local COMPAREFILE="${TMPWORKINGDIRECTORY}/rootdir/tmp/testfailuremsg.comparefile"

-       grep '^\(W\|E\):' "${TMPWORKINGDIRECTORY}/rootdir/tmp/testfailure.output" > "$COMPAREFILE" 2>&1 || true
+       grep '^\(W\|E\|N\):' "${TMPWORKINGDIRECTORY}/rootdir/tmp/testfailure.output" > "$COMPAREFILE" 2>&1 || true
+       testoutputequal "$COMPAREFILE" echo "$CMP"
+       msggroup
+}
+testwarningmsg() {
+       msggroup 'testwarningmsg'
+       local CMP="$1"
+       shift
+       testwarning "$@"
+       msgtest 'Check that the output of the previous warned command has expected' 'warnings'
+       local COMPAREFILE="${TMPWORKINGDIRECTORY}/rootdir/tmp/testwarningmsg.comparefile"
+       grep '^\(W\|E\|N\):' "${TMPWORKINGDIRECTORY}/rootdir/tmp/testwarning.output" > "$COMPAREFILE" 2>&1 || true

        testoutputequal "$COMPAREFILE" echo "$CMP"
        msggroup
 }
        testoutputequal "$COMPAREFILE" echo "$CMP"
        msggroup
 }


@@ -1712,12 +1861,37 @@ testwebserverlaststatuscode() {
        msggroup
 }
 
        msggroup
 }
 

+mapkeynametokeyid() {
+       while [ -n "$1" ]; do
+               case "$1" in
+                       *Joe*|*Sixpack*|newarchive) echo '5A90D141DBAC8DAE';;
+                       *Rex*|*Expired*) echo '4BC0A39C27CE74F9';;
+                       *Marvin*|*Paranoid*) echo 'E8525D47528144E2';;
+                       oldarchive) echo 'FDD2DB85F68C85A3';;
+                       *) echo 'UNKNOWN KEY';;
+               esac
+               shift
+       done
+}
+testaptkeys() {
+       local OUTPUT="${TMPWORKINGDIRECTORY}/rootdir/tmp/aptkeylist.output"
+       if ! aptkey list --with-colon | grep '^pub' | cut -d':' -f 5 > "$OUTPUT"; then
+               echo -n > "$OUTPUT"
+       fi
+       testfileequal "$OUTPUT" "$(mapkeynametokeyid "$@")"
+}
+

 pause() {
        echo "STOPPED execution. Press enter to continue"
        local IGNORE
        read IGNORE
 }
 
 pause() {
        echo "STOPPED execution. Press enter to continue"
        local IGNORE
        read IGNORE
 }
 

+logcurrentarchivedirectory() {
+       find "${TMPWORKINGDIRECTORY}/aptarchive/dists" -type f | while read line; do
+               stat --format '%U:%G:%a:%n' "$line"
+       done | sort > "${TMPWORKINGDIRECTORY}/rootdir/var/log/aptgetupdate.before.lst"
+}

 listcurrentlistsdirectory() {
        {
                find rootdir/var/lib/apt/lists -maxdepth 1 -type d | while read line; do
 listcurrentlistsdirectory() {
        {
                find rootdir/var/lib/apt/lists -maxdepth 1 -type d | while read line; do


@@ -1728,12 +1902,19 @@ listcurrentlistsdirectory() {
                done
        } | sort
 }
                done
        } | sort
 }

+forallsupportedcompressors() {
+       rm -f "${TMPWORKINGDIRECTORY}/rootdir/etc/apt/apt.conf.d/00force-compressor"
+       for COMP in $(aptconfig dump 'APT::Compressor' --format '%f%n' | cut -d':' -f 5 | uniq); do
+               if [ -z "$COMP" -o "$COMP" = '.' ]; then continue; fi
+               "$@" "$COMP"
+       done
+}

 
 ### convenience hacks ###
 mkdir() {
        # creating some directories by hand is a tedious task, so make it look simple
 
 ### convenience hacks ###
 mkdir() {
        # creating some directories by hand is a tedious task, so make it look simple

-       if [ "$*" = '-p rootdir/var/lib/apt/lists' ] || [ "$*" = "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt/lists" ] ||
-          [ "$*" = '-p rootdir/var/lib/apt/lists/partial' ] || [ "$*" = "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt/lists/partial" ]; then
+       local PARAMS="$*"
+       if [ "$PARAMS" != "${PARAMS#*rootdir/var/lib/apt/lists}" ]; then

                # only the last directory created by mkdir is effected by the -m !
                command mkdir -m 755 -p "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt"
                command mkdir -m 755 -p "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt/lists"
                # only the last directory created by mkdir is effected by the -m !
                command mkdir -m 755 -p "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt"
                command mkdir -m 755 -p "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt/lists"


@@ -1751,12 +1932,20 @@ mkdir() {
 ### general things about commands executed without writing the test every time.
 
 aptautotest() {
 ### general things about commands executed without writing the test every time.
 
 aptautotest() {

+       if [ $# -lt 3 ]; then return; fi

        local TESTCALL="$1"
        local CMD="$2"
        local FIRSTOPT="$3"
        local TESTCALL="$1"
        local CMD="$2"
        local FIRSTOPT="$3"

-       local AUTOTEST="aptautotest_$(echo "${CMD##*/}_${FIRSTOPT}" | tr -d '-')"
+       shift 2
+       for i in "$@"; do
+               if ! expr match "$i" '^-' >/dev/null 2>&1; then
+                       FIRSTOPT="$i"
+                       break
+               fi
+       done
+       shift
+       local AUTOTEST="aptautotest_$(echo "${CMD##*/}_${FIRSTOPT}" | tr -d -c 'A-za-z0-9')"

        if command -v $AUTOTEST >/dev/null; then
        if command -v $AUTOTEST >/dev/null; then

-               shift 3

                # save and restore the *.output files from other tests
                # as we might otherwise override them in these automatic tests
                rm -rf "${TMPWORKINGDIRECTORY}/rootdir/tmp-before"
                # save and restore the *.output files from other tests
                # as we might otherwise override them in these automatic tests
                rm -rf "${TMPWORKINGDIRECTORY}/rootdir/tmp-before"


@@ -1789,6 +1978,10 @@ aptautotest_aptget_update() {
                # failure cases can retain partial files and such
                testempty find "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt/lists/partial" -mindepth 1 ! \( -name 'lock' -o -name '*.FAILED' \)
        fi
                # failure cases can retain partial files and such
                testempty find "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt/lists/partial" -mindepth 1 ! \( -name 'lock' -o -name '*.FAILED' \)
        fi

+       if [ -s "${TMPWORKINGDIRECTORY}/rootdir/var/log/aptgetupdate.before.lst" ]; then
+               testfileequal "${TMPWORKINGDIRECTORY}/rootdir/var/log/aptgetupdate.before.lst" \
+                       "$(find "${TMPWORKINGDIRECTORY}/aptarchive/dists" -type f | while read line; do stat --format '%U:%G:%a:%n' "$line"; done | sort)"
+       fi

 }
 aptautotest_apt_update() { aptautotest_aptget_update "$@"; }
 aptautotest_aptcdrom_add() { aptautotest_aptget_update "$@"; }
 }
 aptautotest_apt_update() { aptautotest_aptget_update "$@"; }
 aptautotest_aptcdrom_add() { aptautotest_aptget_update "$@"; }


@@ -1809,3 +2002,11 @@ aptautotest_aptget_purge() { testaptautotestnodpkgwarning "$@"; }
 aptautotest_apt_install() { testaptautotestnodpkgwarning "$@"; }
 aptautotest_apt_remove() { testaptautotestnodpkgwarning "$@"; }
 aptautotest_apt_purge() { testaptautotestnodpkgwarning "$@"; }
 aptautotest_apt_install() { testaptautotestnodpkgwarning "$@"; }
 aptautotest_apt_remove() { testaptautotestnodpkgwarning "$@"; }
 aptautotest_apt_purge() { testaptautotestnodpkgwarning "$@"; }

+
+testaptmarknodefaultsections() {
+       testfailure grep '^Auto-Installed: 0$' "${TMPWORKINGDIRECTORY}/rootdir/var/lib/apt/extended_states"
+}
+aptautotest_aptmark_auto() { testaptmarknodefaultsections "$@"; }
+aptautotest_aptmark_manual() { testaptmarknodefaultsections "$@"; }
+aptautotest_aptget_markauto() { testaptmarknodefaultsections "$@"; }
+aptautotest_aptget_markmanual() { testaptmarknodefaultsections "$@"; }