From 2ffef795b5aed20b6fc2fba3951ff8f5c97cef5a Mon Sep 17 00:00:00 2001

From: Jeffrey Cody <jcody@redhat.com>

Date: Tue, 28 Aug 2018 21:08:17 +0200

Subject: [PATCH 04/29] iotests: Add failure matching to common.qemu

RH-Author: Jeffrey Cody <jcody@redhat.com>

Message-id: <7850ea2daac60087a2cd5e300f8b7042b167ef24.1535490170.git.jcody@redhat.com>

Patchwork-id: 81955

O-Subject: [RHEL-7.6 qemu-kvm-rhev PATCH 2/3] iotests: Add failure matching to common.qemu

Bugzilla: 1605026

RH-Acked-by: Max Reitz <mreitz@redhat.com>

RH-Acked-by: John Snow <jsnow@redhat.com>

RH-Acked-by: Miroslav Rezanina <mrezanin@redhat.com>

From: Max Reitz <mreitz@redhat.com>

Currently, common.qemu only allows to match for results indicating

success.  The only way to fail is by provoking a timeout.  However,

sometimes we do have a defined failure output and can match for that,

which saves us from having to wait for the timeout in case of failure.

Because failure can sometimes just result in a _notrun in the test, it

is actually important to care about being able to fail quickly.

Also, sometimes we simply do not get any specific output in case of

success.  The only way to handle this currently would be to define an

error message as the string to look for, which means that actual success

results in a timeout.  This is really bad because it unnecessarily slows

down a succeeding test.

Therefore, this patch adds a new parameter $success_or_failure to

_timed_wait_for and _send_qemu_cmd.  Setting this to a non-empty string

makes both commands expect two match parameters: If the first matches,

the function succeeds.  If the second matches, the function fails.

Signed-off-by: Max Reitz <mreitz@redhat.com>

Message-id: 20180406151731.4285-2-mreitz@redhat.com

Signed-off-by: Max Reitz <mreitz@redhat.com>

(cherry picked from commit 81c6ddf49a76a663cea16c07a07d51b67c853209)

Signed-off-by: Jeff Cody <jcody@redhat.com>

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 tests/qemu-iotests/common.qemu | 58 +++++++++++++++++++++++++++++++++++++-----

 1 file changed, 51 insertions(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/common.qemu b/tests/qemu-iotests/common.qemu

index 85f66b8..f285484 100644

--- a/tests/qemu-iotests/common.qemu

+++ b/tests/qemu-iotests/common.qemu

@@ -52,11 +52,29 @@ _in_fd=4

 # response is not echoed out.

 # If $mismatch_only is set, only non-matching responses will

 # be echoed.

+#

+# If $success_or_failure is set, the meaning of the arguments is

+# changed as follows:

+# $2: A string to search for in the response; if found, this indicates

+#     success and ${QEMU_STATUS[$1]} is set to 0.

+# $3: A string to search for in the response; if found, this indicates

+#     failure and the test is either aborted (if $qemu_error_no_exit

+#     is not set) or ${QEMU_STATUS[$1]} is set to -1 (otherwise).

 function _timed_wait_for()

 {

     local h=${1}

     shift

+    if [ -z "${success_or_failure}" ]; then

+        success_match=${*}

+        failure_match=

+    else

+        success_match=${1}

+        failure_match=${2}

+    fi

+

+    timeout=yes

+

     QEMU_STATUS[$h]=0

     while IFS= read -t ${QEMU_COMM_TIMEOUT} resp <&${QEMU_OUT[$h]}

     do

@@ -64,10 +82,18 @@ function _timed_wait_for()

             echo "${resp}" | _filter_testdir | _filter_qemu \

                            | _filter_qemu_io | _filter_qmp | _filter_hmp

         fi

-        grep -q "${*}" < <(echo "${resp}")

+        if [ -n "${failure_match}" ]; then

+            grep -q "${failure_match}" < <(echo "${resp}")

+            if [ $? -eq 0 ]; then

+                timeout=

+                break

+            fi

+        fi

+        grep -q "${success_match}" < <(echo "${resp}")

         if [ $? -eq 0 ]; then

             return

-        elif [ -z "${silent}" ] && [ -n "${mismatch_only}" ]; then

+        fi

+        if [ -z "${silent}" ] && [ -n "${mismatch_only}" ]; then

             echo "${resp}" | _filter_testdir | _filter_qemu \

                            | _filter_qemu_io | _filter_qmp | _filter_hmp

         fi

@@ -75,8 +101,12 @@ function _timed_wait_for()

     done

     QEMU_STATUS[$h]=-1

     if [ -z "${qemu_error_no_exit}" ]; then

-        echo "Timeout waiting for ${*} on handle ${h}"

-        exit 1  # Timeout means the test failed

+        if [ -n "${timeout}" ]; then

+            echo "Timeout waiting for ${success_match} on handle ${h}"

+        else

+            echo "Wrong response matching ${failure_match} on handle ${h}"

+        fi

+        exit 1  # Timeout or wrong match mean the test failed

     fi

 }

@@ -96,6 +126,11 @@ function _timed_wait_for()

 # If $qemu_error_no_exit is set, then even if the expected response

 # is not seen, we will not exit.  $QEMU_STATUS[$1] will be set it -1 in

 # that case.

+#

+# If $success_or_failure is set, then the last two strings are the

+# strings the response will be scanned for.  The first of the two

+# indicates success, the latter indicates failure.  Failure is handled

+# like a timeout.

 function _send_qemu_cmd()

 {

     local h=${1}

@@ -109,14 +144,23 @@ function _send_qemu_cmd()

         use_error="no"

     fi

     # This array element extraction is done to accommodate pathnames with spaces

-    cmd=${@: 1:${#@}-1}

-    shift $(($# - 1))

+    if [ -z "${success_or_failure}" ]; then

+        cmd=${@: 1:${#@}-1}

+        shift $(($# - 1))

+    else

+        cmd=${@: 1:${#@}-2}

+        shift $(($# - 2))

+    fi

     while [ ${count} -gt 0 ]

     do

         echo "${cmd}" >&${QEMU_IN[${h}]}

         if [ -n "${1}" ]; then

-            qemu_error_no_exit=${use_error} _timed_wait_for ${h} "${1}"

+            if [ -z "${success_or_failure}" ]; then

+                qemu_error_no_exit=${use_error} _timed_wait_for ${h} "${1}"

+            else

+                qemu_error_no_exit=${use_error} _timed_wait_for ${h} "${1}" "${2}"

+            fi

             if [ ${QEMU_STATUS[$h]} -eq 0 ]; then

                 return

             fi

-- 

1.8.3.1