From nobody Tue Feb 10 10:03:32 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=yandex-team.ru ARC-Seal: i=1; a=rsa-sha256; t=1676467660; cv=none; d=zohomail.com; s=zohoarc; b=NoJTcC/Luu4612hQ1xdoU6n3mCpmzzyRd2cED+Axp1jXkDybIPFXdMBLlS7aJ1HqtVq/tJIaNia8naGFqiLrj4mfCjTiSTdTxibVmAUhogiAD6BJmnnh5dqN756enN4FSHvhG1tiJulHj8XLMerbsa12hA58ZHD+X6Qszt2NQSk= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1676467660; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=W8VMqSWNsJbBrwLoCP47TIaTrFhfu1Pu37lzTQ6L7VU=; b=E38BidJ7KTI98rAhr8aNM1PDGpGBFws3XFKLqiY9PUAYw28Flg6zEKPoife7I0ZN98mUU1K/9/TkymEu0XmvzD4Uc0kNq1xtHcWGFRxmP5De6S/SgpcLa8CVkzWC7ZOXrmZx8X0zqxkocqHMFTcktKDvhtWZ/mD25EKdv91kfgU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1676467660936182.94791140088785; Wed, 15 Feb 2023 05:27:40 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pSHo9-0003Pb-77; Wed, 15 Feb 2023 08:26:49 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pSHo6-0003Cc-BI; Wed, 15 Feb 2023 08:26:46 -0500 Received: from forwardcorp1a.mail.yandex.net ([178.154.239.72]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pSHo0-0006Gb-RY; Wed, 15 Feb 2023 08:26:46 -0500 Received: from vla5-b2806cb321eb.qloud-c.yandex.net (vla5-b2806cb321eb.qloud-c.yandex.net [IPv6:2a02:6b8:c18:3e0d:0:640:b280:6cb3]) by forwardcorp1a.mail.yandex.net (Yandex) with ESMTP id 429F76007E; Wed, 15 Feb 2023 16:26:13 +0300 (MSK) Received: from vsementsov-win.yandex-team.ru (unknown [2a02:6b8:b081:b4bf::1:2e]) by vla5-b2806cb321eb.qloud-c.yandex.net (smtpcorp/Yandex) with ESMTPSA id nPk8g80UxeA1-HSt0umOu; Wed, 15 Feb 2023 16:26:11 +0300 X-Yandex-Fwd: 1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yandex-team.ru; s=default; t=1676467571; bh=W8VMqSWNsJbBrwLoCP47TIaTrFhfu1Pu37lzTQ6L7VU=; h=Message-Id:Date:In-Reply-To:Cc:Subject:References:To:From; b=Ok9ROVJ6ZfaFkRz3Lu3hMn9U5IkLZgyxIql0o65j71SaY6riQCNdarGqd2qLP1oIO Fxbx7/9wB7bb+Divwm6VPpkW6XTCwBeSh+E4ryVjlO9pK3rfY9iX/OnJUyROYI63qc ktS0JDevnVJHrQk6rEqjfd0VCzUWTAAxi1nDm1Js= Authentication-Results: vla5-b2806cb321eb.qloud-c.yandex.net; dkim=pass header.i=@yandex-team.ru From: Vladimir Sementsov-Ogievskiy To: qemu-block@nongnu.org Cc: qemu-devel@nongnu.org, vsementsov@yandex-team.ru, jsnow@redhat.com, crosa@redhat.com, kwolf@redhat.com, hreitz@redhat.com Subject: [PATCH v5 16/16] python: use vm.cmd() instead of vm.qmp() where appropriate Date: Wed, 15 Feb 2023 16:25:47 +0300 Message-Id: <20230215132547.1620575-17-vsementsov@yandex-team.ru> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230215132547.1620575-1-vsementsov@yandex-team.ru> References: <20230215132547.1620575-1-vsementsov@yandex-team.ru> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=178.154.239.72; envelope-from=vsementsov@yandex-team.ru; helo=forwardcorp1a.mail.yandex.net X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @yandex-team.ru) X-ZM-MESSAGEID: 1676467662330100003 Content-Type: text/plain; charset="utf-8" In many cases we just want an effect of qmp command and want to raise on failure. Use vm.cmd() method which does exactly this. Signed-off-by: Vladimir Sementsov-Ogievskiy --- tests/avocado/vnc.py | 16 +- tests/qemu-iotests/030 | 168 +++--- tests/qemu-iotests/040 | 172 +++---- tests/qemu-iotests/041 | 483 ++++++++---------- tests/qemu-iotests/045 | 15 +- tests/qemu-iotests/055 | 62 +-- tests/qemu-iotests/056 | 77 ++- tests/qemu-iotests/093 | 42 +- tests/qemu-iotests/118 | 225 ++++---- tests/qemu-iotests/124 | 102 ++-- tests/qemu-iotests/129 | 14 +- tests/qemu-iotests/132 | 5 +- tests/qemu-iotests/139 | 45 +- tests/qemu-iotests/147 | 31 +- tests/qemu-iotests/151 | 57 +-- tests/qemu-iotests/152 | 10 +- tests/qemu-iotests/155 | 55 +- tests/qemu-iotests/165 | 8 +- tests/qemu-iotests/196 | 3 +- tests/qemu-iotests/205 | 6 +- tests/qemu-iotests/218 | 105 ++-- tests/qemu-iotests/245 | 245 ++++----- tests/qemu-iotests/264 | 31 +- tests/qemu-iotests/281 | 21 +- tests/qemu-iotests/295 | 15 +- tests/qemu-iotests/296 | 15 +- tests/qemu-iotests/298 | 13 +- tests/qemu-iotests/300 | 54 +- tests/qemu-iotests/iotests.py | 9 +- .../tests/export-incoming-iothread | 6 +- .../qemu-iotests/tests/graph-changes-while-io | 6 +- tests/qemu-iotests/tests/image-fleecing | 3 +- .../tests/migrate-bitmaps-postcopy-test | 31 +- tests/qemu-iotests/tests/migrate-bitmaps-test | 47 +- .../qemu-iotests/tests/migrate-during-backup | 41 +- .../qemu-iotests/tests/migration-permissions | 9 +- .../tests/mirror-ready-cancel-error | 74 ++- tests/qemu-iotests/tests/mirror-top-perms | 16 +- tests/qemu-iotests/tests/nbd-multiconn | 12 +- tests/qemu-iotests/tests/reopen-file | 3 +- .../qemu-iotests/tests/stream-error-on-reset | 6 +- 41 files changed, 951 insertions(+), 1407 deletions(-) diff --git a/tests/avocado/vnc.py b/tests/avocado/vnc.py index aeeefc70be..862c8996a8 100644 --- a/tests/avocado/vnc.py +++ b/tests/avocado/vnc.py @@ -88,9 +88,8 @@ def test_change_password(self): self.vm.add_args('-nodefaults', '-S', '-vnc', ':0,password=3Don') self.vm.launch() self.assertTrue(self.vm.qmp('query-vnc')['return']['enabled']) - set_password_response =3D self.vm.qmp('change-vnc-password', - password=3D'new_password') - self.assertEqual(set_password_response['return'], {}) + self.vm.cmd('change-vnc-password', + password=3D'new_password') =20 def test_change_listen(self): a, b, c =3D find_free_ports(3) @@ -105,12 +104,11 @@ def test_change_listen(self): self.assertFalse(check_connect(b)) self.assertFalse(check_connect(c)) =20 - res =3D self.vm.qmp('display-update', type=3D'vnc', - addresses=3D[{'type': 'inet', 'host': VNC_ADDR, - 'port': str(b)}, - {'type': 'inet', 'host': VNC_ADDR, - 'port': str(c)}]) - self.assertEqual(res['return'], {}) + self.vm.cmd('display-update', type=3D'vnc', + addresses=3D[{'type': 'inet', 'host': VNC_ADDR, + 'port': str(b)}, + {'type': 'inet', 'host': VNC_ADDR, + 'port': str(c)}]) self.assertEqual(self.vm.qmp('query-vnc')['return']['service'], st= r(b)) self.assertFalse(check_connect(a)) self.assertTrue(check_connect(b)) diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030 index 98595d47fe..0e6a39d103 100755 --- a/tests/qemu-iotests/030 +++ b/tests/qemu-iotests/030 @@ -56,8 +56,7 @@ class TestSingleDrive(iotests.QMPTestCase): def test_stream(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 self.wait_until_completed() =20 @@ -77,8 +76,7 @@ class TestSingleDrive(iotests.QMPTestCase): qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', mid_img).std= out, 'image file map matches backing file before streaming') =20 - result =3D self.vm.qmp('block-stream', device=3D'mid', job_id=3D's= tream-mid') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'mid', job_id=3D'stream-mid') =20 self.wait_until_completed(drive=3D'stream-mid') =20 @@ -94,8 +92,7 @@ class TestSingleDrive(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 self.pause_job('drive0', wait=3DFalse) self.vm.resume_drive('drive0') @@ -108,8 +105,7 @@ class TestSingleDrive(iotests.QMPTestCase): result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) =20 - result =3D self.vm.qmp('block-job-resume', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 self.wait_until_completed() =20 @@ -129,8 +125,7 @@ class TestSingleDrive(iotests.QMPTestCase): '-f', iotests.imgfmt, '-rU', '-c', 'map', test_img).stdout =20 # This is a no-op: no data should ever be copied from the base ima= ge - result =3D self.vm.qmp('block-stream', device=3D'drive0', base=3Dm= id_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0', base=3Dmid_img) =20 self.wait_until_completed() =20 @@ -144,8 +139,7 @@ class TestSingleDrive(iotests.QMPTestCase): def test_stream_partial(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0', base=3Db= acking_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0', base=3Dbacking_img) =20 self.wait_until_completed() =20 @@ -172,24 +166,22 @@ class TestSingleDrive(iotests.QMPTestCase): qemu_img('create', '-f', iotests.imgfmt, ro_top_path, str(self.image_len)) =20 - result =3D self.vm.qmp('blockdev-add', - node_name=3D'ro-top', - driver=3Diotests.imgfmt, - read_only=3DTrue, - file=3D{ - 'driver': 'file', - 'filename': ro_top_path, - 'read-only': True - }, - backing=3D'mid') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3D'ro-top', + driver=3Diotests.imgfmt, + read_only=3DTrue, + file=3D{ + 'driver': 'file', + 'filename': ro_top_path, + 'read-only': True + }, + backing=3D'mid') =20 result =3D self.vm.qmp('block-stream', job_id=3D'stream', device=3D'ro-top', base_node=3D'base') self.assert_qmp(result, 'error/desc', 'Block node is read-only= ') =20 - result =3D self.vm.qmp('blockdev-del', node_name=3D'ro-top') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'ro-top') =20 =20 class TestParallelOps(iotests.QMPTestCase): @@ -254,10 +246,9 @@ class TestParallelOps(iotests.QMPTestCase): node_name =3D 'node%d' % i job_id =3D 'stream-%s' % node_name pending_jobs.append(job_id) - result =3D self.vm.qmp('block-stream', device=3Dnode_name, - job_id=3Djob_id, bottom=3Df'node{i-1}', - speed=3D1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3Dnode_name, + job_id=3Djob_id, bottom=3Df'node{i-1}', + speed=3D1024) =20 # Do this in reverse: After unthrottling them, some jobs may finish # before we have unthrottled all of them. This will drain their @@ -269,8 +260,7 @@ class TestParallelOps(iotests.QMPTestCase): # Starting from the top (i.e. in reverse) does not have this probl= em: # When a job finishes, the ones below it are not advanced. for job in reversed(pending_jobs): - result =3D self.vm.qmp('block-job-set-speed', device=3Djob, sp= eed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3Djob, speed=3D0) =20 # Wait for all jobs to be finished. while len(pending_jobs) > 0: @@ -297,10 +287,9 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # Set a speed limit to make sure that this job blocks the rest - result =3D self.vm.qmp('block-stream', device=3D'node4', - job_id=3D'stream-node4', base=3Dself.imgs[1], - filter_node_name=3D'stream-filter', speed=3D1= 024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'node4', + job_id=3D'stream-node4', base=3Dself.imgs[1], + filter_node_name=3D'stream-filter', speed=3D1024*1024) =20 result =3D self.vm.qmp('block-stream', device=3D'node5', job_id=3D= 'stream-node5', base=3Dself.imgs[2]) self.assert_qmp(result, 'error/desc', @@ -328,8 +317,7 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_qmp(result, 'error/desc', "Node 'node2' is busy: block device is in use by block job: st= ream") =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'stream-nod= e4', speed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'stream-node4', speed= =3D0) =20 self.wait_until_completed(drive=3D'stream-node4') self.assert_no_active_block_jobs() @@ -341,8 +329,7 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # Set a speed limit to make sure that this job blocks the rest - result =3D self.vm.qmp('block-commit', device=3D'drive0', top=3Dse= lf.imgs[5], base=3Dself.imgs[3], job_id=3D'commit-node3', speed=3D1024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', top=3Dself.imgs[5],= base=3Dself.imgs[3], job_id=3D'commit-node3', speed=3D1024*1024) =20 result =3D self.vm.qmp('block-stream', device=3D'node3', job_id=3D= 'stream-node3') self.assert_qmp(result, 'error/desc', @@ -365,8 +352,7 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_qmp(result, 'error/desc', "Node 'drive0' is busy: block device is in use by block job: c= ommit") =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'commit-nod= e3', speed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'commit-node3', speed= =3D0) =20 self.wait_until_completed(drive=3D'commit-node3') =20 @@ -377,23 +363,20 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # Set a speed limit to make sure that this job blocks the rest - result =3D self.vm.qmp('block-commit', device=3D'drive0', base=3Ds= elf.imgs[3], job_id=3D'commit-drive0', speed=3D1024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', base=3Dself.imgs[3]= , job_id=3D'commit-drive0', speed=3D1024*1024) =20 result =3D self.vm.qmp('block-stream', device=3D'node5', base=3Dse= lf.imgs[3], job_id=3D'stream-node6') self.assert_qmp(result, 'error/desc', "Node 'node5' is busy: block device is in use by block job: co= mmit") =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'commit-dri= ve0', speed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'commit-drive0', speed= =3D0) =20 event =3D self.vm.event_wait(name=3D'BLOCK_JOB_READY') self.assert_qmp(event, 'data/device', 'commit-drive0') self.assert_qmp(event, 'data/type', 'commit') self.assert_qmp_absent(event, 'data/error') =20 - result =3D self.vm.qmp('block-job-complete', device=3D'commit-driv= e0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-complete', device=3D'commit-drive0') =20 self.wait_until_completed(drive=3D'commit-drive0') =20 @@ -404,18 +387,16 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # Commit from node2 into node0 - result =3D self.vm.qmp('block-commit', device=3D'drive0', - top=3Dself.imgs[2], base=3Dself.imgs[0], - filter_node_name=3D'commit-filter', speed=3D1= 024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', + top=3Dself.imgs[2], base=3Dself.imgs[0], + filter_node_name=3D'commit-filter', speed=3D1024*1024) =20 # Stream from node2 into node4 result =3D self.vm.qmp('block-stream', device=3D'node4', base_node= =3D'node2', job_id=3D'node4') self.assert_qmp(result, 'error/desc', "Cannot freeze 'backing' link to 'commit-filter'") =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D0) =20 self.wait_until_completed() self.assert_no_active_block_jobs() @@ -428,18 +409,15 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # Commit from node2 into node0 - result =3D self.vm.qmp('block-commit', device=3D'drive0', - top_node=3D'node2', base_node=3D'node0', - filter_node_name=3D'commit-filter', speed=3D1= 024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', + top_node=3D'node2', base_node=3D'node0', + filter_node_name=3D'commit-filter', speed=3D1024*1024) =20 # Stream from node2 into node4 - result =3D self.vm.qmp('block-stream', device=3D'node4', - base_node=3D'commit-filter', job_id=3D'node4') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'node4', + base_node=3D'commit-filter', job_id=3D'node4') =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D0) =20 self.vm.run_job(job=3D'drive0', auto_dismiss=3DTrue) self.vm.run_job(job=3D'node4', auto_dismiss=3DTrue) @@ -458,12 +436,10 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # Stream from node0 into node2 - result =3D self.vm.qmp('block-stream', device=3D'node2', base_node= =3D'node0', job_id=3D'node2') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'node2', base_node=3D'node0',= job_id=3D'node2') =20 # Commit from the active layer into node3 - result =3D self.vm.qmp('block-commit', device=3D'drive0', base=3Ds= elf.imgs[3]) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', base=3Dself.imgs[3]) =20 # Wait for all jobs to be finished. pending_jobs =3D ['node2', 'drive0'] @@ -490,16 +466,13 @@ class TestParallelOps(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # Stream from node0 into node4 - result =3D self.vm.qmp('block-stream', device=3D'node4', base_node= =3D'node0', job_id=3D'node4', speed=3D1024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'node4', base_node=3D'node0',= job_id=3D'node4', speed=3D1024*1024) =20 # Commit from the active layer into node5 - result =3D self.vm.qmp('block-commit', device=3D'drive0', base=3Ds= elf.imgs[5], speed=3D1024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', base=3Dself.imgs[5]= , speed=3D1024*1024) =20 for job in ['drive0', 'node4']: - result =3D self.vm.qmp('block-job-set-speed', device=3Djob, sp= eed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3Djob, speed=3D0) =20 # Wait for all jobs to be finished. pending_jobs =3D ['node4', 'drive0'] @@ -549,8 +522,7 @@ class TestParallelOps(iotests.QMPTestCase): "'base' and 'base-node' cannot be specified at the same time") =20 # Success: the base node is a backing file of the top node - result =3D self.vm.qmp('block-stream', device=3D'node4', base_node= =3D'node2', job_id=3D'stream') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'node4', base_node=3D'node2',= job_id=3D'stream') =20 self.wait_until_completed(drive=3D'stream') =20 @@ -606,8 +578,7 @@ class TestQuorum(iotests.QMPTestCase): =20 self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'node0', job_id=3D= 'stream-node0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'node0', job_id=3D'stream-nod= e0') =20 self.wait_until_completed(drive=3D'stream-node0') =20 @@ -636,8 +607,7 @@ class TestSmallerBackingFile(iotests.QMPTestCase): def test_stream(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 self.wait_until_completed() =20 @@ -694,8 +664,7 @@ class TestEIO(TestErrors): def test_report(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 completed =3D False error =3D False @@ -722,8 +691,7 @@ class TestEIO(TestErrors): def test_ignore(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0', on_error= =3D'ignore') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0', on_error=3D'ignore') =20 error =3D False completed =3D False @@ -756,8 +724,7 @@ class TestEIO(TestErrors): def test_stop(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0', on_error= =3D'stop') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0', on_error=3D'stop') =20 error =3D False completed =3D False @@ -779,8 +746,7 @@ class TestEIO(TestErrors): self.assert_qmp(result, 'return[0]/offset', self.STREA= M_BUFFER_SIZE) self.assert_qmp(result, 'return[0]/io-status', 'failed= ') =20 - result =3D self.vm.qmp('block-job-resume', device=3D'd= rive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 result =3D self.vm.qmp('query-block-jobs') if result =3D=3D {'return': []}: @@ -806,8 +772,7 @@ class TestEIO(TestErrors): def test_enospc(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0', on_error= =3D'enospc') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0', on_error=3D'enospc') =20 completed =3D False error =3D False @@ -852,8 +817,7 @@ class TestENOSPC(TestErrors): def test_enospc(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0', on_error= =3D'enospc') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0', on_error=3D'enospc') =20 error =3D False completed =3D False @@ -875,8 +839,7 @@ class TestENOSPC(TestErrors): self.assert_qmp(result, 'return[0]/offset', self.STREA= M_BUFFER_SIZE) self.assert_qmp(result, 'return[0]/io-status', 'nospac= e') =20 - result =3D self.vm.qmp('block-job-resume', device=3D'd= rive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 result =3D self.vm.qmp('query-block-jobs') if result =3D=3D {'return': []}: @@ -921,8 +884,7 @@ class TestStreamStop(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 time.sleep(0.1) events =3D self.vm.get_qmp_events(wait=3DFalse) @@ -955,11 +917,9 @@ class TestSetSpeed(iotests.QMPTestCase): def perf_test_throughput(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D8 * 1024 * 1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D8 * = 1024 * 1024) =20 self.wait_until_completed() =20 @@ -969,16 +929,14 @@ class TestSetSpeed(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 # Default speed is 0 result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/device', 'drive0') self.assert_qmp(result, 'return[0]/speed', 0) =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D8 * 1024 * 1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D8 * = 1024 * 1024) =20 # Ensure the speed we set was accepted result =3D self.vm.qmp('query-block-jobs') @@ -989,8 +947,7 @@ class TestSetSpeed(iotests.QMPTestCase): self.vm.pause_drive('drive0') =20 # Check setting speed in block-stream works - result =3D self.vm.qmp('block-stream', device=3D'drive0', speed=3D= 4 * 1024 * 1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0', speed=3D4 * 1024 * = 1024) =20 result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/device', 'drive0') @@ -1007,8 +964,7 @@ class TestSetSpeed(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp('block-stream', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', device=3D'drive0') =20 result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D-1) self.assert_qmp(result, 'error/desc', "Parameter 'speed' expects a= non-negative value") diff --git a/tests/qemu-iotests/040 b/tests/qemu-iotests/040 index 46a4ec9bde..fe20d3dce9 100755 --- a/tests/qemu-iotests/040 +++ b/tests/qemu-iotests/040 @@ -61,17 +61,14 @@ class ImageCommitTestCase(iotests.QMPTestCase): def run_commit_test(self, top, base, need_ready=3DFalse, node_names=3D= False): self.assert_no_active_block_jobs() if node_names: - result =3D self.vm.qmp('block-commit', device=3D'drive0', top_= node=3Dtop, base_node=3Dbase) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', top_node=3Dtop,= base_node=3Dbase) else: - result =3D self.vm.qmp('block-commit', device=3D'drive0', top= =3Dtop, base=3Dbase) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', top=3Dtop, base= =3Dbase) self.wait_for_complete(need_ready) =20 def run_default_commit_test(self): self.assert_no_active_block_jobs() - result =3D self.vm.qmp('block-commit', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0') self.wait_for_complete() =20 class TestSingleDrive(ImageCommitTestCase): @@ -118,38 +115,30 @@ class TestSingleDrive(ImageCommitTestCase): =20 @iotests.skip_if_unsupported(['throttle']) def test_commit_with_filter_and_quit(self): - result =3D self.vm.qmp('object-add', qom_type=3D'throttle-group', = id=3D'tg') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', qom_type=3D'throttle-group', id=3D'tg') =20 # Add a filter outside of the backing chain - result =3D self.vm.qmp('blockdev-add', driver=3D'throttle', node_n= ame=3D'filter', throttle_group=3D'tg', file=3D'mid') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', driver=3D'throttle', node_name=3D'filt= er', throttle_group=3D'tg', file=3D'mid') =20 - result =3D self.vm.qmp('block-commit', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0') =20 # Quit immediately, thus forcing a simultaneous cancel of the # block job and a bdrv_drain_all() - result =3D self.vm.qmp('quit') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('quit') =20 # Same as above, but this time we add the filter after starting the job @iotests.skip_if_unsupported(['throttle']) def test_commit_plus_filter_and_quit(self): - result =3D self.vm.qmp('object-add', qom_type=3D'throttle-group', = id=3D'tg') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', qom_type=3D'throttle-group', id=3D'tg') =20 - result =3D self.vm.qmp('block-commit', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0') =20 # Add a filter outside of the backing chain - result =3D self.vm.qmp('blockdev-add', driver=3D'throttle', node_n= ame=3D'filter', throttle_group=3D'tg', file=3D'mid') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', driver=3D'throttle', node_name=3D'filt= er', throttle_group=3D'tg', file=3D'mid') =20 # Quit immediately, thus forcing a simultaneous cancel of the # block job and a bdrv_drain_all() - result =3D self.vm.qmp('quit') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('quit') =20 def test_device_not_found(self): result =3D self.vm.qmp('block-commit', device=3D'nonexistent', top= =3D'%s' % mid_img) @@ -226,8 +215,7 @@ class TestSingleDrive(ImageCommitTestCase): def test_top_node_in_wrong_chain(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('blockdev-add', driver=3D'null-co', node_na= me=3D'null') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', driver=3D'null-co', node_name=3D'null') =20 result =3D self.vm.qmp('block-commit', device=3D'drive0', top_node= =3D'null', base_node=3D'base') self.assert_qmp(result, 'error/class', 'GenericError') @@ -240,11 +228,9 @@ class TestSingleDrive(ImageCommitTestCase): return =20 self.assert_no_active_block_jobs() - result =3D self.vm.qmp('block-commit', device=3D'drive0', top=3Dmi= d_img, - base=3Dbacking_img, speed=3D(self.image_len /= / 4)) - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('device_del', id=3D'scsi0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', top=3Dmid_img, + base=3Dbacking_img, speed=3D(self.image_len // 4)) + self.vm.cmd('device_del', id=3D'scsi0') =20 cancelled =3D False deleted =3D False @@ -270,9 +256,8 @@ class TestSingleDrive(ImageCommitTestCase): return =20 self.assert_no_active_block_jobs() - result =3D self.vm.qmp('block-commit', device=3D'drive0', top=3Dmi= d_img, - base=3Dbacking_img, speed=3D(self.image_len /= / 4)) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', top=3Dmid_img, + base=3Dbacking_img, speed=3D(self.image_len // 4)) =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/file', test_img) @@ -407,8 +392,7 @@ class TestSetSpeed(ImageCommitTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp('block-commit', device=3D'drive0', top=3Dmi= d_img, speed=3D1024 * 1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0', top=3Dmid_img, spee= d=3D1024 * 1024) =20 # Ensure the speed we set was accepted result =3D self.vm.qmp('query-block-jobs') @@ -481,8 +465,7 @@ class TestErrorHandling(iotests.QMPTestCase): os.remove(backing_img) =20 def blockdev_add(self, **kwargs): - result =3D self.vm.qmp('blockdev-add', **kwargs) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', **kwargs) =20 def add_block_nodes(self, base_debug=3DNone, mid_debug=3DNone, top_deb= ug=3DNone): self.blockdev_add(node_name=3D'base-file', driver=3D'file', @@ -528,11 +511,9 @@ class TestErrorHandling(iotests.QMPTestCase): completed =3D True elif ev['event'] =3D=3D 'BLOCK_JOB_ERROR': if error_pauses_job: - result =3D self.vm.qmp('block-job-resume', device=3D'j= ob0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'job0') elif ev['event'] =3D=3D 'BLOCK_JOB_READY': - result =3D self.vm.qmp('block-job-complete', device=3D'job= 0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-complete', device=3D'job0') else: self.fail("Unexpected event: %s" % ev) log.append(iotests.filter_qmp_event(ev)) @@ -595,11 +576,10 @@ class TestErrorHandling(iotests.QMPTestCase): self.add_block_nodes(top_debug=3Dtop_debug, mid_debug=3Dmid_debug, base_debug=3Dbase_debug) =20 - result =3D self.vm.qmp('block-commit', job_id=3D'job0', device=3D'= top-fmt', - top_node=3D'top-fmt' if active else 'mid-fmt', - base_node=3D'mid-fmt' if active else 'base-fm= t', - on_error=3Don_error) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', job_id=3D'job0', device=3D'top-fmt', + top_node=3D'top-fmt' if active else 'mid-fmt', + base_node=3D'mid-fmt' if active else 'base-fmt', + on_error=3Don_error) =20 def testActiveReadErrorReport(self): self.prepare_and_start_job('report', top_event=3D'read_aio') @@ -771,10 +751,9 @@ class TestCommitWithFilters(iotests.QMPTestCase): self.vm =3D iotests.VM().add_device('virtio-scsi,id=3Dvio-scsi') self.vm.launch() =20 - result =3D self.vm.qmp('object-add', qom_type=3D'throttle-group', = id=3D'tg') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', qom_type=3D'throttle-group', id=3D'tg') =20 - result =3D self.vm.qmp('blockdev-add', { + self.vm.cmd('blockdev-add', { 'node-name': 'top-filter', 'driver': 'throttle', 'throttle-group': 'tg', @@ -816,7 +795,6 @@ class TestCommitWithFilters(iotests.QMPTestCase): } } }) - self.assert_qmp(result, 'return', {}) =20 def tearDown(self): self.vm.shutdown() @@ -833,13 +811,12 @@ class TestCommitWithFilters(iotests.QMPTestCase): return self.vm.node_info(node)['image']['filename'] =20 def test_filterless_commit(self): - result =3D self.vm.qmp('block-commit', - job_id=3D'commit', - device=3D'top-filter', - top_node=3D'cow-2', - base_node=3D'cow-1', - backing_file=3Dself.img1) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', + job_id=3D'commit', + device=3D'top-filter', + top_node=3D'cow-2', + base_node=3D'cow-1', + backing_file=3Dself.img1) self.wait_until_completed(drive=3D'commit') =20 self.assertIsNotNone(self.vm.node_info('cow-3')) @@ -850,13 +827,12 @@ class TestCommitWithFilters(iotests.QMPTestCase): self.pattern_files[2] =3D self.img1 =20 def test_commit_through_filter(self): - result =3D self.vm.qmp('block-commit', - job_id=3D'commit', - device=3D'top-filter', - top_node=3D'cow-1', - base_node=3D'cow-0', - backing_file=3Dself.img0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', + job_id=3D'commit', + device=3D'top-filter', + top_node=3D'cow-1', + base_node=3D'cow-0', + backing_file=3Dself.img0) self.wait_until_completed(drive=3D'commit') =20 self.assertIsNotNone(self.vm.node_info('cow-2')) @@ -871,9 +847,8 @@ class TestCommitWithFilters(iotests.QMPTestCase): # Add a device, so the commit job finds a parent it can change # to point to the base node (so we can test that top-filter is # dropped from the graph) - result =3D self.vm.qmp('device_add', id=3D'drv0', driver=3D'scsi-h= d', - bus=3D'vio-scsi.0', drive=3D'top-filter') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', id=3D'drv0', driver=3D'scsi-hd', + bus=3D'vio-scsi.0', drive=3D'top-filter') =20 # Try to release our reference to top-filter; that should not # work because drv0 uses it @@ -881,16 +856,14 @@ class TestCommitWithFilters(iotests.QMPTestCase): self.assert_qmp(result, 'error/class', 'GenericError') self.assert_qmp(result, 'error/desc', 'Node top-filter is in use') =20 - result =3D self.vm.qmp('block-commit', - job_id=3D'commit', - device=3D'top-filter', - base_node=3D'cow-2') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', + job_id=3D'commit', + device=3D'top-filter', + base_node=3D'cow-2') self.complete_and_wait(drive=3D'commit') =20 # Try to release our reference to top-filter again - result =3D self.vm.qmp('blockdev-del', node_name=3D'top-filter') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'top-filter') =20 self.assertIsNone(self.vm.node_info('top-filter')) self.assertIsNone(self.vm.node_info('cow-3')) @@ -905,12 +878,11 @@ class TestCommitWithFilters(iotests.QMPTestCase): self.pattern_files[3] =3D self.img2 =20 def test_filtered_active_commit_without_filter(self): - result =3D self.vm.qmp('block-commit', - job_id=3D'commit', - device=3D'top-filter', - top_node=3D'cow-3', - base_node=3D'cow-2') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', + job_id=3D'commit', + device=3D'top-filter', + top_node=3D'cow-3', + base_node=3D'cow-2') self.complete_and_wait(drive=3D'commit') =20 self.assertIsNotNone(self.vm.node_info('top-filter')) @@ -935,23 +907,22 @@ class TestCommitWithOverriddenBacking(iotests.QMPTest= Case): self.vm.launch() =20 # Use base_b instead of base_a as the backing of top - result =3D self.vm.qmp('blockdev-add', { - 'node-name': 'top', - 'driver': iotests.imgfmt, - 'file': { - 'driver': 'file', - 'filename': self.img_top - }, - 'backing': { - 'node-name': 'base', - 'driver': iotests.imgfmt, - 'file': { - 'driver': 'file', - 'filename': self.img_base_b - } - } - }) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', { + 'node-name': 'top', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img_top + }, + 'backing': { + 'node-name': 'base', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img_base_b + } + } + }) =20 def tearDown(self): self.vm.shutdown() @@ -971,11 +942,10 @@ class TestCommitWithOverriddenBacking(iotests.QMPTest= Case): def test_commit_to_b(self): # Try committing to base_b (which should work, since that is # actually top's backing image) - result =3D self.vm.qmp('block-commit', - job_id=3D'commit', - device=3D'top', - base=3Dself.img_base_b) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', + job_id=3D'commit', + device=3D'top', + base=3Dself.img_base_b) =20 self.vm.event_wait('BLOCK_JOB_READY') self.vm.qmp('block-job-complete', device=3D'commit') diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041 index 3aef42aec8..98d17b1388 100755 --- a/tests/qemu-iotests/041 +++ b/tests/qemu-iotests/041 @@ -65,9 +65,8 @@ class TestSingleDrive(iotests.QMPTestCase): def test_complete(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + target=3Dself.qmp_target) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -79,9 +78,8 @@ class TestSingleDrive(iotests.QMPTestCase): def test_cancel(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + target=3Dself.qmp_target) =20 self.cancel_and_wait(force=3DTrue) result =3D self.vm.qmp('query-block') @@ -90,9 +88,8 @@ class TestSingleDrive(iotests.QMPTestCase): def test_cancel_after_ready(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + target=3Dself.qmp_target) =20 self.wait_ready_and_cancel() result =3D self.vm.qmp('query-block') @@ -104,9 +101,8 @@ class TestSingleDrive(iotests.QMPTestCase): def test_pause(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + target=3Dself.qmp_target) =20 self.pause_job('drive0') =20 @@ -117,8 +113,7 @@ class TestSingleDrive(iotests.QMPTestCase): result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) =20 - result =3D self.vm.qmp('block-job-resume', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 self.complete_and_wait() self.vm.shutdown() @@ -129,9 +124,8 @@ class TestSingleDrive(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 # A small buffer is rounded up automatically - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - buf_size=3D4096, target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + buf_size=3D4096, target=3Dself.qmp_target) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -145,9 +139,8 @@ class TestSingleDrive(iotests.QMPTestCase): =20 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=3D%d,= size=3D%d' % (self.image_len, self.image_len), target_img) - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - buf_size=3D65536, mode=3D'existing', target= =3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + buf_size=3D65536, mode=3D'existing', target=3Dself.qmp= _target) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -162,9 +155,8 @@ class TestSingleDrive(iotests.QMPTestCase): qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=3D%d,= backing_file=3D%s' % (self.image_len, backing_img), '-F', 'raw', target_img) - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - mode=3D'existing', target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + mode=3D'existing', target=3Dself.qmp_target) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -178,9 +170,8 @@ class TestSingleDrive(iotests.QMPTestCase): def test_implicit_node(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp(self.qmp_cmd, device=3D'drive0', sync=3D'fu= ll', - target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, device=3D'drive0', sync=3D'full', + target=3Dself.qmp_target) =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/file', test_img) @@ -236,8 +227,7 @@ class TestSingleBlockdev(TestSingleDrive): args =3D {'driver': iotests.imgfmt, 'node-name': self.qmp_target, 'file': { 'filename': target_img, 'driver': 'file' } } - result =3D self.vm.qmp("blockdev-add", args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd("blockdev-add", args) =20 def test_mirror_to_self(self): result =3D self.vm.qmp(self.qmp_cmd, job_id=3D'job0', @@ -254,10 +244,9 @@ class TestSingleBlockdev(TestSingleDrive): result =3D self.vm.qmp('block_resize', node_name=3Dnode, size= =3D65536) self.assert_qmp(result, 'error/class', 'GenericError') =20 - result =3D self.vm.qmp(self.qmp_cmd, job_id=3D'job0', device=3D'dr= ive0', - sync=3D'full', target=3Dself.qmp_target, - auto_finalize=3DFalse, auto_dismiss=3DFalse) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, job_id=3D'job0', device=3D'drive0', + sync=3D'full', target=3Dself.qmp_target, + auto_finalize=3DFalse, auto_dismiss=3DFalse) =20 result =3D self.vm.run_job('job0', auto_finalize=3DFalse, pre_finalize=3Dpre_finalize) @@ -270,14 +259,12 @@ class TestSingleBlockdev(TestSingleDrive): self.do_test_resize(None, self.qmp_target) =20 def do_test_target_size(self, size): - result =3D self.vm.qmp('block_resize', node_name=3Dself.qmp_target, - size=3Dsize) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block_resize', node_name=3Dself.qmp_target, + size=3Dsize) =20 - result =3D self.vm.qmp(self.qmp_cmd, job_id=3D'job0', - device=3D'drive0', sync=3D'full', auto_dismis= s=3DFalse, - target=3Dself.qmp_target) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.qmp_cmd, job_id=3D'job0', + device=3D'drive0', sync=3D'full', auto_dismiss=3DFalse, + target=3Dself.qmp_target) =20 result =3D self.vm.run_job('job0') self.assertEqual(result, 'Source and target image have different s= izes') @@ -337,9 +324,8 @@ class TestMirrorNoBacking(iotests.QMPTestCase): =20 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=3D%s' % backing_img, '-F', 'raw', tar= get_img) - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - mode=3D'existing', target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + mode=3D'existing', target=3Dtarget_img) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -353,9 +339,8 @@ class TestMirrorNoBacking(iotests.QMPTestCase): =20 qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=3D%s' % backing_img, '-F', 'raw', tar= get_img) - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - mode=3D'existing', target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + mode=3D'existing', target=3Dtarget_img) =20 self.wait_ready_and_cancel() result =3D self.vm.qmp('query-block') @@ -374,9 +359,8 @@ class TestMirrorNoBacking(iotests.QMPTestCase): % (TestMirrorNoBacking.image_len, target_backing_i= mg), '-F', iotests.imgfmt, target_img) =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - mode=3D'existing', target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + mode=3D'existing', target=3Dtarget_img) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -409,9 +393,8 @@ class TestMirrorResized(iotests.QMPTestCase): def test_complete_top(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= top', - target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'top', + target=3Dtarget_img) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -423,9 +406,8 @@ class TestMirrorResized(iotests.QMPTestCase): def test_complete_full(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img) =20 self.complete_and_wait() result =3D self.vm.qmp('query-block') @@ -488,9 +470,8 @@ new_state =3D "1" def test_report_read(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img) =20 completed =3D False error =3D False @@ -516,9 +497,8 @@ new_state =3D "1" def test_ignore_read(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img, on_source_error=3D'ignor= e') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img, on_source_error=3D'ignore') =20 event =3D self.vm.get_qmp_event(wait=3DTrue) while event['event'] =3D=3D 'JOB_STATUS_CHANGE': @@ -541,10 +521,9 @@ new_state =3D "1" qemu_img('create', '-f', iotests.imgfmt, '-ocluster_size=3D131072,backing_file=3D%s' %(backing_img= ), '-F', 'raw', target_img) - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= top', - on_source_error=3D'ignore', - mode=3D'existing', target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'top', + on_source_error=3D'ignore', + mode=3D'existing', target=3Dtarget_img) =20 event =3D self.vm.get_qmp_event(wait=3DTrue) while event['event'] =3D=3D 'JOB_STATUS_CHANGE': @@ -568,9 +547,8 @@ new_state =3D "1" def test_stop_read(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img, on_source_error=3D'stop') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img, on_source_error=3D'stop') =20 error =3D False ready =3D False @@ -590,8 +568,7 @@ new_state =3D "1" self.assert_qmp(result, 'return[0]/status', 'paused') self.assert_qmp(result, 'return[0]/io-status', 'failed= ') =20 - result =3D self.vm.qmp('block-job-resume', device=3D'd= rive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') error =3D True elif event['event'] =3D=3D 'BLOCK_JOB_READY': self.assertTrue(error, 'job completed unexpectedly') @@ -656,9 +633,8 @@ new_state =3D "1" def test_report_write(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - mode=3D'existing', target=3Dself.target_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + mode=3D'existing', target=3Dself.target_img) =20 completed =3D False error =3D False @@ -682,10 +658,9 @@ new_state =3D "1" def test_ignore_write(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - mode=3D'existing', target=3Dself.target_img, - on_target_error=3D'ignore') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + mode=3D'existing', target=3Dself.target_img, + on_target_error=3D'ignore') =20 event =3D self.vm.event_wait(name=3D'BLOCK_JOB_ERROR') self.assertEqual(event['event'], 'BLOCK_JOB_ERROR') @@ -698,10 +673,9 @@ new_state =3D "1" def test_stop_write(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - mode=3D'existing', target=3Dself.target_img, - on_target_error=3D'stop') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + mode=3D'existing', target=3Dself.target_img, + on_target_error=3D'stop') =20 error =3D False ready =3D False @@ -721,8 +695,7 @@ new_state =3D "1" self.assert_qmp(result, 'return[0]/status', 'paused') self.assert_qmp(result, 'return[0]/io-status', 'failed= ') =20 - result =3D self.vm.qmp('block-job-resume', device=3D'd= rive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 result =3D self.vm.qmp('query-block-jobs') self.assertIn(result['return'][0]['status'], ['running= ', 'ready']) @@ -755,17 +728,15 @@ class TestSetSpeed(iotests.QMPTestCase): def test_set_speed(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img) =20 # Default speed is 0 result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/device', 'drive0') self.assert_qmp(result, 'return[0]/speed', 0) =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D8 * 1024 * 1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D8 * = 1024 * 1024) =20 # Ensure the speed we set was accepted result =3D self.vm.qmp('query-block-jobs') @@ -775,9 +746,8 @@ class TestSetSpeed(iotests.QMPTestCase): self.wait_ready_and_cancel() =20 # Check setting speed in drive-mirror works - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img, speed=3D4*1024*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img, speed=3D4*1024*1024) =20 result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/device', 'drive0') @@ -794,9 +764,8 @@ class TestSetSpeed(iotests.QMPTestCase): =20 self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img) =20 result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D-1) self.assert_qmp(result, 'error/class', 'GenericError') @@ -811,13 +780,12 @@ class TestUnbackedSource(iotests.QMPTestCase): str(TestUnbackedSource.image_len)) self.vm =3D iotests.VM() self.vm.launch() - result =3D self.vm.qmp('blockdev-add', node_name=3D'drive0', - driver=3Diotests.imgfmt, - file=3D{ - 'driver': 'file', - 'filename': test_img, - }) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', node_name=3D'drive0', + driver=3Diotests.imgfmt, + file=3D{ + 'driver': 'file', + 'filename': test_img, + }) =20 def tearDown(self): self.vm.shutdown() @@ -826,28 +794,25 @@ class TestUnbackedSource(iotests.QMPTestCase): =20 def test_absolute_paths_full(self): self.assert_no_active_block_jobs() - result =3D self.vm.qmp('drive-mirror', job_id=3D'drive0', device= =3D'drive0', - sync=3D'full', target=3Dtarget_img, - mode=3D'absolute-paths') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'drive0', device=3D'drive0', + sync=3D'full', target=3Dtarget_img, + mode=3D'absolute-paths') self.complete_and_wait() self.assert_no_active_block_jobs() =20 def test_absolute_paths_top(self): self.assert_no_active_block_jobs() - result =3D self.vm.qmp('drive-mirror', job_id=3D'drive0', device= =3D'drive0', - sync=3D'top', target=3Dtarget_img, - mode=3D'absolute-paths') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'drive0', device=3D'drive0', + sync=3D'top', target=3Dtarget_img, + mode=3D'absolute-paths') self.complete_and_wait() self.assert_no_active_block_jobs() =20 def test_absolute_paths_none(self): self.assert_no_active_block_jobs() - result =3D self.vm.qmp('drive-mirror', job_id=3D'drive0', device= =3D'drive0', - sync=3D'none', target=3Dtarget_img, - mode=3D'absolute-paths') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'drive0', device=3D'drive0', + sync=3D'none', target=3Dtarget_img, + mode=3D'absolute-paths') self.complete_and_wait() self.assert_no_active_block_jobs() =20 @@ -857,14 +822,12 @@ class TestUnbackedSource(iotests.QMPTestCase): qemu_io('-c', 'write -P 42 0 64k', target_img) =20 self.assert_no_active_block_jobs() - result =3D self.vm.qmp('drive-mirror', job_id=3D'drive0', device= =3D'drive0', - sync=3D'full', target=3Dtarget_img, mode=3D'e= xisting') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'drive0', device=3D'drive0', + sync=3D'full', target=3Dtarget_img, mode=3D'existing') self.complete_and_wait() self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('blockdev-del', node_name=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'drive0') =20 self.assertTrue(iotests.compare_images(test_img, target_img), 'target image does not match source after mirrorin= g') @@ -874,26 +837,22 @@ class TestUnbackedSource(iotests.QMPTestCase): str(self.image_len)) qemu_io('-c', 'write -P 42 0 64k', target_img) =20 - result =3D self.vm.qmp('blockdev-add', node_name=3D'target', - driver=3Diotests.imgfmt, - file=3D{ - 'driver': 'file', - 'filename': target_img, - }) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', node_name=3D'target', + driver=3Diotests.imgfmt, + file=3D{ + 'driver': 'file', + 'filename': target_img, + }) =20 self.assert_no_active_block_jobs() - result =3D self.vm.qmp('blockdev-mirror', job_id=3D'drive0', devic= e=3D'drive0', - sync=3D'full', target=3D'target') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-mirror', job_id=3D'drive0', device=3D'drive0= ', + sync=3D'full', target=3D'target') self.complete_and_wait() self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('blockdev-del', node_name=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'drive0') =20 - result =3D self.vm.qmp('blockdev-del', node_name=3D'target') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'target') =20 self.assertTrue(iotests.compare_images(test_img, target_img), 'target image does not match source after mirrorin= g') @@ -918,10 +877,9 @@ class TestGranularity(iotests.QMPTestCase): =20 def test_granularity(self): self.assert_no_active_block_jobs() - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', - sync=3D'full', target=3Dtarget_img, - mode=3D'absolute-paths', granularity=3D8192) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', + sync=3D'full', target=3Dtarget_img, + mode=3D'absolute-paths', granularity=3D8192) =20 event =3D self.vm.get_qmp_event(wait=3D60.0) while event['event'] =3D=3D 'JOB_STATUS_CHANGE': @@ -963,8 +921,7 @@ class TestRepairQuorum(iotests.QMPTestCase): #assemble the quorum block device from the individual files args =3D { "driver": "quorum", "node-name": "quorum0", "vote-threshold": 2, "children": [ "img0", "img1", "img2"= ] } - result =3D self.vm.qmp("blockdev-add", args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd("blockdev-add", args) =20 =20 def tearDown(self): @@ -978,10 +935,9 @@ class TestRepairQuorum(iotests.QMPTestCase): pass =20 def test_complete(self): - result =3D self.vm.qmp('drive-mirror', job_id=3D'job0', device=3D'= quorum0', - sync=3D'full', node_name=3D"repair0", replace= s=3D"img1", - target=3Dquorum_repair_img, format=3Diotests.= imgfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'job0', device=3D'quorum0', + sync=3D'full', node_name=3D"repair0", replaces=3D"img1= ", + target=3Dquorum_repair_img, format=3Diotests.imgfmt) =20 self.complete_and_wait(drive=3D"job0") self.assert_has_block_node("repair0", quorum_repair_img) @@ -991,10 +947,9 @@ class TestRepairQuorum(iotests.QMPTestCase): 'target image does not match source after mirrorin= g') =20 def test_cancel(self): - result =3D self.vm.qmp('drive-mirror', job_id=3D'job0', device=3D'= quorum0', - sync=3D'full', node_name=3D"repair0", replace= s=3D"img1", - target=3Dquorum_repair_img, format=3Diotests.= imgfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'job0', device=3D'quorum0', + sync=3D'full', node_name=3D"repair0", replaces=3D"img1= ", + target=3Dquorum_repair_img, format=3Diotests.imgfmt) =20 self.cancel_and_wait(drive=3D"job0", force=3DTrue) # here we check that the last registered quorum file has not been @@ -1002,10 +957,9 @@ class TestRepairQuorum(iotests.QMPTestCase): self.assert_has_block_node(None, quorum_img3) =20 def test_cancel_after_ready(self): - result =3D self.vm.qmp('drive-mirror', job_id=3D'job0', device=3D'= quorum0', - sync=3D'full', node_name=3D"repair0", replace= s=3D"img1", - target=3Dquorum_repair_img, format=3Diotests.= imgfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'job0', device=3D'quorum0', + sync=3D'full', node_name=3D"repair0", replaces=3D"img1= ", + target=3Dquorum_repair_img, format=3Diotests.imgfmt) =20 self.wait_ready_and_cancel(drive=3D"job0") # here we check that the last registered quorum file has not been @@ -1016,10 +970,9 @@ class TestRepairQuorum(iotests.QMPTestCase): 'target image does not match source after mirrorin= g') =20 def test_pause(self): - result =3D self.vm.qmp('drive-mirror', job_id=3D'job0', device=3D'= quorum0', - sync=3D'full', node_name=3D"repair0", replace= s=3D"img1", - target=3Dquorum_repair_img, format=3Diotests.= imgfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'job0', device=3D'quorum0', + sync=3D'full', node_name=3D"repair0", replaces=3D"img1= ", + target=3Dquorum_repair_img, format=3Diotests.imgfmt) =20 self.pause_job('job0') =20 @@ -1030,8 +983,7 @@ class TestRepairQuorum(iotests.QMPTestCase): result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) =20 - result =3D self.vm.qmp('block-job-resume', device=3D'job0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'job0') =20 self.complete_and_wait(drive=3D"job0") self.vm.shutdown() @@ -1084,20 +1036,18 @@ class TestRepairQuorum(iotests.QMPTestCase): self.assert_qmp(result, 'error/class', 'GenericError') =20 def test_after_a_quorum_snapshot(self): - result =3D self.vm.qmp('blockdev-snapshot-sync', node_name=3D'img1= ', - snapshot_file=3Dquorum_snapshot_file, - snapshot_node_name=3D"snap1") - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-snapshot-sync', node_name=3D'img1', + snapshot_file=3Dquorum_snapshot_file, + snapshot_node_name=3D"snap1") =20 result =3D self.vm.qmp('drive-mirror', job_id=3D'job0', device=3D'= quorum0', sync=3D'full', node_name=3D'repair0', replace= s=3D"img1", target=3Dquorum_repair_img, format=3Diotests.= imgfmt) self.assert_qmp(result, 'error/class', 'GenericError') =20 - result =3D self.vm.qmp('drive-mirror', job_id=3D'job0', device=3D'= quorum0', - sync=3D'full', node_name=3D'repair0', replace= s=3D"snap1", - target=3Dquorum_repair_img, format=3Diotests.= imgfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'job0', device=3D'quorum0', + sync=3D'full', node_name=3D'repair0', replaces=3D"snap= 1", + target=3Dquorum_repair_img, format=3Diotests.imgfmt) =20 self.complete_and_wait('job0') self.assert_has_block_node("repair0", quorum_repair_img) @@ -1108,15 +1058,13 @@ class TestRepairQuorum(iotests.QMPTestCase): Check that we cannot replace a Quorum child when it has other parents. """ - result =3D self.vm.qmp('nbd-server-start', - addr=3D{ - 'type': 'unix', - 'data': {'path': nbd_sock_path} - }) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('nbd-server-start', + addr=3D{ + 'type': 'unix', + 'data': {'path': nbd_sock_path} + }) =20 - result =3D self.vm.qmp('nbd-server-add', device=3D'img1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('nbd-server-add', device=3D'img1') =20 result =3D self.vm.qmp('drive-mirror', job_id=3D'mirror', device= =3D'quorum0', sync=3D'full', node_name=3D'repair0', replace= s=3D'img1', @@ -1131,20 +1079,17 @@ class TestRepairQuorum(iotests.QMPTestCase): The same as test_with_other_parent(), but add the NBD server only when the mirror job is already running. """ - result =3D self.vm.qmp('nbd-server-start', - addr=3D{ - 'type': 'unix', - 'data': {'path': nbd_sock_path} - }) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('nbd-server-start', + addr=3D{ + 'type': 'unix', + 'data': {'path': nbd_sock_path} + }) =20 - result =3D self.vm.qmp('drive-mirror', job_id=3D'mirror', device= =3D'quorum0', - sync=3D'full', node_name=3D'repair0', replace= s=3D'img1', - target=3Dquorum_repair_img, format=3Diotests.= imgfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', job_id=3D'mirror', device=3D'quorum0', + sync=3D'full', node_name=3D'repair0', replaces=3D'img1= ', + target=3Dquorum_repair_img, format=3Diotests.imgfmt) =20 - result =3D self.vm.qmp('nbd-server-add', device=3D'img1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('nbd-server-add', device=3D'img1') =20 # The full error message goes to stderr, we will check it later self.complete_and_wait('mirror', @@ -1200,9 +1145,8 @@ class TestOrphanedSource(iotests.QMPTestCase): def test_success(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('blockdev-mirror', job_id=3D'job', device= =3D'src', - sync=3D'full', target=3D'dest') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-mirror', job_id=3D'job', device=3D'src', + sync=3D'full', target=3D'dest') =20 self.complete_and_wait('job') =20 @@ -1218,27 +1162,24 @@ class TestOrphanedSource(iotests.QMPTestCase): =20 # Unshare consistent-read on the target # (The mirror job does not care) - result =3D self.vm.qmp('blockdev-add', - driver=3D'blkdebug', - node_name=3D'dest-perm', - image=3D'dest', - unshare_child_perms=3D['consistent-read']) - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('blockdev-mirror', job_id=3D'job', device= =3D'src', - sync=3D'full', target=3D'dest', - filter_node_name=3D'mirror-filter') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + driver=3D'blkdebug', + node_name=3D'dest-perm', + image=3D'dest', + unshare_child_perms=3D['consistent-read']) + + self.vm.cmd('blockdev-mirror', job_id=3D'job', device=3D'src', + sync=3D'full', target=3D'dest', + filter_node_name=3D'mirror-filter') =20 # Require consistent-read on the source # (We can only add this node once the job has started, or it # will complain that it does not want to run on non-root nodes) - result =3D self.vm.qmp('blockdev-add', - driver=3D'blkdebug', - node_name=3D'src-perm', - image=3D'src', - take_child_perms=3D['consistent-read']) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + driver=3D'blkdebug', + node_name=3D'src-perm', + image=3D'src', + take_child_perms=3D['consistent-read']) =20 # While completing, mirror will attempt to replace src by # dest, which must fail because src-perm requires @@ -1278,26 +1219,23 @@ class TestReplaces(iotests.QMPTestCase): """ Check that we can replace filter nodes. """ - result =3D self.vm.qmp('blockdev-add', { - 'driver': 'copy-on-read', - 'node-name': 'filter0', - 'file': { - 'driver': 'copy-on-read', - 'node-name': 'filter1', - 'file': { - 'driver': 'null-co' - } - } - }) - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('blockdev-add', - node_name=3D'target', driver=3D'null-co') - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('blockdev-mirror', job_id=3D'mirror', devic= e=3D'filter0', - target=3D'target', sync=3D'full', replaces=3D= 'filter1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', { + 'driver': 'copy-on-read', + 'node-name': 'filter0', + 'file': { + 'driver': 'copy-on-read', + 'node-name': 'filter1', + 'file': { + 'driver': 'null-co' + } + } + }) + + self.vm.cmd('blockdev-add', + node_name=3D'target', driver=3D'null-co') + + self.vm.cmd('blockdev-mirror', job_id=3D'mirror', device=3D'filter= 0', + target=3D'target', sync=3D'full', replaces=3D'filter1') =20 self.complete_and_wait('mirror') =20 @@ -1319,16 +1257,15 @@ class TestFilters(iotests.QMPTestCase): self.vm =3D iotests.VM().add_device('virtio-scsi,id=3Dvio-scsi') self.vm.launch() =20 - result =3D self.vm.qmp('blockdev-add', { - 'node-name': 'target', - 'driver': iotests.imgfmt, - 'file': { - 'driver': 'file', - 'filename': target_img - }, - 'backing': None - }) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', { + 'node-name': 'target', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': target_img + }, + 'backing': None + }) =20 self.filterless_chain =3D { 'node-name': 'source', @@ -1355,19 +1292,17 @@ class TestFilters(iotests.QMPTestCase): os.remove(backing_img) =20 def test_cor(self): - result =3D self.vm.qmp('blockdev-add', { - 'node-name': 'filter', - 'driver': 'copy-on-read', - 'file': self.filterless_chain - }) - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'filter', - target=3D'target', - sync=3D'top') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', { + 'node-name': 'filter', + 'driver': 'copy-on-read', + 'file': self.filterless_chain + }) + + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'filter', + target=3D'target', + sync=3D'top') =20 self.complete_and_wait('mirror') =20 @@ -1384,23 +1319,20 @@ class TestFilters(iotests.QMPTestCase): assert target_map[1]['depth'] =3D=3D 0 =20 def test_implicit_mirror_filter(self): - result =3D self.vm.qmp('blockdev-add', self.filterless_chain) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', self.filterless_chain) =20 # We need this so we can query from above the mirror node - result =3D self.vm.qmp('device_add', - driver=3D'scsi-hd', - id=3D'virtio', - bus=3D'vio-scsi.0', - drive=3D'source') - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'source', - target=3D'target', - sync=3D'top') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', + driver=3D'scsi-hd', + id=3D'virtio', + bus=3D'vio-scsi.0', + drive=3D'source') + + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'source', + target=3D'target', + sync=3D'top') =20 # The mirror filter is now an implicit node, so it should be # invisible when querying the backing chain @@ -1418,24 +1350,21 @@ class TestFilters(iotests.QMPTestCase): def test_explicit_mirror_filter(self): # Same test as above, but this time we give the mirror filter # a node-name so it will not be invisible - result =3D self.vm.qmp('blockdev-add', self.filterless_chain) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', self.filterless_chain) =20 # We need this so we can query from above the mirror node - result =3D self.vm.qmp('device_add', - driver=3D'scsi-hd', - id=3D'virtio', - bus=3D'vio-scsi.0', - drive=3D'source') - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'source', - target=3D'target', - sync=3D'top', - filter_node_name=3D'mirror-filter') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', + driver=3D'scsi-hd', + id=3D'virtio', + bus=3D'vio-scsi.0', + drive=3D'source') + + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'source', + target=3D'target', + sync=3D'top', + filter_node_name=3D'mirror-filter') =20 # With a node-name given to it, the mirror filter should now # be visible diff --git a/tests/qemu-iotests/045 b/tests/qemu-iotests/045 index 45eb239baa..a341f21cd7 100755 --- a/tests/qemu-iotests/045 +++ b/tests/qemu-iotests/045 @@ -77,8 +77,7 @@ class TestFdSets(iotests.QMPTestCase): self.vm.shutdown() =20 def test_remove_fdset(self): - result =3D self.vm.qmp('remove-fd', fdset_id=3D2) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('remove-fd', fdset_id=3D2) result =3D self.vm.qmp('query-fdsets') self.assert_qmp(result, 'return[0]/fdset-id', 1) self.assert_qmp(result, 'return[1]/fdset-id', 0) @@ -90,8 +89,7 @@ class TestFdSets(iotests.QMPTestCase): def test_remove_fd(self): result =3D self.vm.qmp('query-fdsets') fd_image3 =3D result['return'][0]['fds'][0]['fd'] - result =3D self.vm.qmp('remove-fd', fdset_id=3D2, fd=3Dfd_image3) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('remove-fd', fdset_id=3D2, fd=3Dfd_image3) result =3D self.vm.qmp('query-fdsets') self.assert_qmp(result, 'return[0]/fdset-id', 2) self.assert_qmp(result, 'return[1]/fdset-id', 1) @@ -151,8 +149,7 @@ class TestSCMFd(iotests.QMPTestCase): =20 def test_getfd(self): self._send_fd_by_SCM() - result =3D self.vm.qmp('getfd', fdname=3D'image0:r') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('getfd', fdname=3D'image0:r') =20 def test_getfd_invalid_fdname(self): self._send_fd_by_SCM() @@ -163,10 +160,8 @@ class TestSCMFd(iotests.QMPTestCase): =20 def test_closefd(self): self._send_fd_by_SCM() - result =3D self.vm.qmp('getfd', fdname=3D'image0:r') - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('closefd', fdname=3D'image0:r') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('getfd', fdname=3D'image0:r') + self.vm.cmd('closefd', fdname=3D'image0:r') =20 def test_closefd_fd_not_found(self): fdname =3D 'image0:r' diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055 index 5d6b607051..d8372b5598 100755 --- a/tests/qemu-iotests/055 +++ b/tests/qemu-iotests/055 @@ -69,8 +69,7 @@ class TestSingleDrive(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp(cmd, device=3D'drive0', target=3Dtarget, sy= nc=3D'full') - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', target=3Dtarget, sync=3D'full') =20 event =3D self.cancel_and_wait(resume=3DTrue) self.assert_qmp(event, 'data/type', 'backup') @@ -85,9 +84,8 @@ class TestSingleDrive(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp(cmd, device=3D'drive0', - target=3Dtarget, sync=3D'full') - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', + target=3Dtarget, sync=3D'full') =20 self.pause_job('drive0', wait=3DFalse) self.vm.resume_drive('drive0') @@ -100,8 +98,7 @@ class TestSingleDrive(iotests.QMPTestCase): result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) =20 - result =3D self.vm.qmp('block-job-resume', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 self.wait_until_completed() =20 @@ -123,10 +120,9 @@ class TestSingleDrive(iotests.QMPTestCase): result =3D self.vm.qmp('block_resize', node_name=3Dnode, size= =3D65536) self.assert_qmp(result, 'error/class', 'GenericError') =20 - result =3D self.vm.qmp('blockdev-backup', job_id=3D'job0', device= =3D'drive0', - target=3D'drive1', sync=3D'full', auto_finali= ze=3DFalse, - auto_dismiss=3DFalse) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-backup', job_id=3D'job0', device=3D'drive0', + target=3D'drive1', sync=3D'full', auto_finalize=3DFals= e, + auto_dismiss=3DFalse) =20 self.vm.run_job('job0', auto_finalize=3DFalse, pre_finalize=3Dpre_= finalize) =20 @@ -137,8 +133,7 @@ class TestSingleDrive(iotests.QMPTestCase): self.do_test_resize_blockdev_backup('drive1', 'target') =20 def do_test_target_size(self, size): - result =3D self.vm.qmp('block_resize', device=3D'drive1', size=3Ds= ize) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block_resize', device=3D'drive1', size=3Dsize) =20 result =3D self.vm.qmp('blockdev-backup', job_id=3D'job0', device= =3D'drive0', target=3D'drive1', sync=3D'full') @@ -219,16 +214,14 @@ class TestSetSpeed(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp(cmd, device=3D'drive0', target=3Dtarget, sy= nc=3D'full') - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', target=3Dtarget, sync=3D'full') =20 # Default speed is 0 result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/device', 'drive0') self.assert_qmp(result, 'return[0]/speed', 0) =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D8 * 1024 * 1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D8 * = 1024 * 1024) =20 # Ensure the speed we set was accepted result =3D self.vm.qmp('query-block-jobs') @@ -240,9 +233,8 @@ class TestSetSpeed(iotests.QMPTestCase): =20 # Check setting speed option works self.vm.pause_drive('drive0') - result =3D self.vm.qmp(cmd, device=3D'drive0', - target=3Dtarget, sync=3D'full', speed=3D4*102= 4*1024) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', + target=3Dtarget, sync=3D'full', speed=3D4*1024*1024) =20 result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/device', 'drive0') @@ -267,9 +259,8 @@ class TestSetSpeed(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp(cmd, device=3D'drive0', - target=3Dtarget, sync=3D'full') - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', + target=3Dtarget, sync=3D'full') =20 result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D-1) self.assert_qmp(result, 'error/class', 'GenericError') @@ -306,7 +297,7 @@ class TestSingleTransaction(iotests.QMPTestCase): def do_test_cancel(self, cmd, target): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('transaction', actions=3D[{ + self.vm.cmd('transaction', actions=3D[{ 'type': cmd, 'data': { 'device': 'drive0', 'target': target, @@ -315,8 +306,6 @@ class TestSingleTransaction(iotests.QMPTestCase): } ]) =20 - self.assert_qmp(result, 'return', {}) - event =3D self.cancel_and_wait() self.assert_qmp(event, 'data/type', 'backup') =20 @@ -329,7 +318,7 @@ class TestSingleTransaction(iotests.QMPTestCase): def do_test_pause(self, cmd, target, image): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('transaction', actions=3D[{ + self.vm.cmd('transaction', actions=3D[{ 'type': cmd, 'data': { 'device': 'drive0', 'target': target, @@ -337,12 +326,10 @@ class TestSingleTransaction(iotests.QMPTestCase): 'speed': 64 * 1024 }, } ]) - self.assert_qmp(result, 'return', {}) =20 self.pause_job('drive0', wait=3DFalse) =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D0) =20 self.pause_wait('drive0') =20 @@ -353,8 +340,7 @@ class TestSingleTransaction(iotests.QMPTestCase): result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) =20 - result =3D self.vm.qmp('block-job-resume', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 self.wait_until_completed() =20 @@ -519,8 +505,7 @@ class TestCompressedToQcow2(iotests.QMPTestCase): =20 self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp(cmd, device=3D'drive0', sync=3D'full', comp= ress=3DTrue, **args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', sync=3D'full', compress=3DTrue= , **args) =20 self.wait_until_completed() =20 @@ -545,8 +530,7 @@ class TestCompressedToQcow2(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp(cmd, device=3D'drive0', sync=3D'full', comp= ress=3DTrue, **args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', sync=3D'full', compress=3DTrue= , **args) =20 event =3D self.cancel_and_wait(resume=3DTrue) self.assert_qmp(event, 'data/type', 'backup') @@ -568,8 +552,7 @@ class TestCompressedToQcow2(iotests.QMPTestCase): self.assert_no_active_block_jobs() =20 self.vm.pause_drive('drive0') - result =3D self.vm.qmp(cmd, device=3D'drive0', sync=3D'full', comp= ress=3DTrue, **args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, device=3D'drive0', sync=3D'full', compress=3DTrue= , **args) =20 self.pause_job('drive0', wait=3DFalse) self.vm.resume_drive('drive0') @@ -582,8 +565,7 @@ class TestCompressedToQcow2(iotests.QMPTestCase): result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) =20 - result =3D self.vm.qmp('block-job-resume', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') =20 self.wait_until_completed() =20 diff --git a/tests/qemu-iotests/056 b/tests/qemu-iotests/056 index bef865eec4..808ea6b48a 100755 --- a/tests/qemu-iotests/056 +++ b/tests/qemu-iotests/056 @@ -75,9 +75,8 @@ class TestSyncModesNoneAndTop(iotests.QMPTestCase): =20 def test_complete_top(self): self.assert_no_active_block_jobs() - result =3D self.vm.qmp('drive-backup', device=3D'drive0', sync=3D'= top', - format=3Diotests.imgfmt, target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-backup', device=3D'drive0', sync=3D'top', + format=3Diotests.imgfmt, target=3Dtarget_img) =20 self.wait_until_completed(check_offset=3DFalse) =20 @@ -89,9 +88,8 @@ class TestSyncModesNoneAndTop(iotests.QMPTestCase): def test_cancel_sync_none(self): self.assert_no_active_block_jobs() =20 - result =3D self.vm.qmp('drive-backup', device=3D'drive0', - sync=3D'none', target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-backup', device=3D'drive0', + sync=3D'none', target=3Dtarget_img) time.sleep(1) self.vm.hmp_qemu_io('drive0', 'write -P0x5e 0 512') self.vm.hmp_qemu_io('drive0', 'aio_flush') @@ -115,18 +113,15 @@ class TestBeforeWriteNotifier(iotests.QMPTestCase): =20 def test_before_write_notifier(self): self.vm.pause_drive("drive0") - result =3D self.vm.qmp('drive-backup', device=3D'drive0', - sync=3D'full', target=3Dtarget_img, - format=3D"file", speed=3D1) - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('block-job-pause', device=3D"drive0") - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-backup', device=3D'drive0', + sync=3D'full', target=3Dtarget_img, + format=3D"file", speed=3D1) + self.vm.cmd('block-job-pause', device=3D"drive0") # Speed is low enough that this must be an uncopied range, which w= ill # trigger the before write notifier self.vm.hmp_qemu_io('drive0', 'aio_write -P 1 512512 512') self.vm.resume_drive("drive0") - result =3D self.vm.qmp('block-job-resume', device=3D"drive0") - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-resume', device=3D"drive0") event =3D self.cancel_and_wait() self.assert_qmp(event, 'data/type', 'backup') =20 @@ -191,8 +186,7 @@ class BackupTest(iotests.QMPTestCase): self.qmp_backup_and_wait(device=3D'drive0', format=3Diotests.imgfm= t, sync=3D'full', target=3Dself.ref_img, auto_dismiss=3DFalse) - res =3D self.vm.qmp('block-job-dismiss', id=3D'drive0') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-dismiss', id=3D'drive0') =20 # Now to the test backup: We simulate the following guest # writes: @@ -211,11 +205,9 @@ class BackupTest(iotests.QMPTestCase): ('66', '1M', '1M')]) =20 # Let the job complete - res =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', spee= d=3D0) - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D0) self.qmp_backup_wait('drive0') - res =3D self.vm.qmp('block-job-dismiss', id=3D'drive0') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-dismiss', id=3D'drive0') =20 self.assertTrue(iotests.compare_images(self.ref_img, self.dest_img= ), 'target image does not match reference image') @@ -237,8 +229,7 @@ class BackupTest(iotests.QMPTestCase): auto_dismiss=3DFalse) res =3D self.vm.qmp('query-block-jobs') self.assert_qmp(res, 'return[0]/status', 'concluded') - res =3D self.vm.qmp('block-job-dismiss', id=3D'drive0') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-dismiss', id=3D'drive0') res =3D self.vm.qmp('query-block-jobs') self.assert_qmp(res, 'return', []) =20 @@ -263,8 +254,7 @@ class BackupTest(iotests.QMPTestCase): auto_dismiss=3DFalse) self.assertEqual(res, False) # OK, dismiss the zombie. - res =3D self.vm.qmp('block-job-dismiss', id=3D'drive0') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-dismiss', id=3D'drive0') res =3D self.vm.qmp('query-block-jobs') self.assert_qmp(res, 'return', []) # Ensure it's really gone. @@ -281,23 +271,22 @@ class BackupTest(iotests.QMPTestCase): ('0x55', '8M', '352k'), ('0x78', '15872k', '1M'))) # Add destination node via blkdebug - res =3D self.vm.qmp('blockdev-add', - node_name=3D'target0', - driver=3Diotests.imgfmt, - file=3D{ - 'driver': 'blkdebug', - 'image': { - 'driver': 'file', - 'filename': self.dest_img - }, - 'inject-error': [{ - 'event': 'write_aio', - 'errno': 5, - 'immediately': False, - 'once': True - }], - }) - self.assert_qmp(res, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3D'target0', + driver=3Diotests.imgfmt, + file=3D{ + 'driver': 'blkdebug', + 'image': { + 'driver': 'file', + 'filename': self.dest_img + }, + 'inject-error': [{ + 'event': 'write_aio', + 'errno': 5, + 'immediately': False, + 'once': True + }], + }) =20 res =3D self.qmp_backup(cmd=3D'blockdev-backup', device=3D'drive0', target=3D'target0', @@ -323,8 +312,7 @@ class BackupTest(iotests.QMPTestCase): res =3D self.vm.qmp('query-block-jobs') self.assert_qmp(res, 'return[0]/status', 'paused') # OK, unstick job and move forward. - res =3D self.vm.qmp('block-job-resume', device=3D'drive0') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-resume', device=3D'drive0') # And now we need to wait for it to conclude; res =3D self.qmp_backup_wait(device=3D'drive0') self.assertTrue(res) @@ -332,8 +320,7 @@ class BackupTest(iotests.QMPTestCase): # Job should now be languishing: res =3D self.vm.qmp('query-block-jobs') self.assert_qmp(res, 'return[0]/status', 'concluded') - res =3D self.vm.qmp('block-job-dismiss', id=3D'drive0') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-dismiss', id=3D'drive0') res =3D self.vm.qmp('query-block-jobs') self.assert_qmp(res, 'return', []) =20 diff --git a/tests/qemu-iotests/093 b/tests/qemu-iotests/093 index 93274dc8cb..4f9e224e8a 100755 --- a/tests/qemu-iotests/093 +++ b/tests/qemu-iotests/093 @@ -55,8 +55,7 @@ class ThrottleTestCase(iotests.QMPTestCase): # Set the I/O throttling parameters to all drives for i in range(0, ndrives): params['device'] =3D 'drive%d' % i - result =3D self.vm.qmp("block_set_io_throttle", conv_keys=3DFa= lse, **params) - self.assert_qmp(result, 'return', {}) + self.vm.cmd("block_set_io_throttle", conv_keys=3DFalse, **para= ms) =20 def do_test_throttle(self, ndrives, seconds, params, first_drive =3D 0= ): def check_limit(limit, num): @@ -253,8 +252,7 @@ class ThrottleTestCase(iotests.QMPTestCase): # drive1 remains in the group with a throttled request. params['bps_rd'] =3D 0 params['device'] =3D 'drive0' - result =3D self.vm.qmp("block_set_io_throttle", conv_keys=3DFalse,= **params) - self.assert_qmp(result, 'return', {}) + self.vm.cmd("block_set_io_throttle", conv_keys=3DFalse, **params) =20 # Removing the I/O limits from drive0 drains its two pending reque= sts. # The read request in drive1 is still throttled. @@ -286,8 +284,7 @@ class ThrottleTestGroupNames(iotests.QMPTestCase): =20 def set_io_throttle(self, device, params): params["device"] =3D device - result =3D self.vm.qmp("block_set_io_throttle", conv_keys=3DFalse,= **params) - self.assert_qmp(result, 'return', {}) + self.vm.cmd("block_set_io_throttle", conv_keys=3DFalse, **params) =20 def verify_name(self, device, name): result =3D self.vm.qmp("query-block") @@ -379,23 +376,19 @@ class ThrottleTestRemovableMedia(iotests.QMPTestCase): =20 def test_removable_media(self): # Add a couple of dummy nodes named cd0 and cd1 - result =3D self.vm.qmp("blockdev-add", driver=3D"null-co", - read_zeroes=3DTrue, node_name=3D"cd0") - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp("blockdev-add", driver=3D"null-co", - read_zeroes=3DTrue, node_name=3D"cd1") - self.assert_qmp(result, 'return', {}) + self.vm.cmd("blockdev-add", driver=3D"null-co", + read_zeroes=3DTrue, node_name=3D"cd0") + self.vm.cmd("blockdev-add", driver=3D"null-co", + read_zeroes=3DTrue, node_name=3D"cd1") =20 # Attach a CD drive with cd0 inserted - result =3D self.vm.qmp("device_add", driver=3D"scsi-cd", - id=3D"dev0", drive=3D"cd0") - self.assert_qmp(result, 'return', {}) + self.vm.cmd("device_add", driver=3D"scsi-cd", + id=3D"dev0", drive=3D"cd0") =20 # Set I/O limits args =3D { "id": "dev0", "iops": 100, "iops_rd": 0, "iops_wr": 0, "bps": 50, "bps_rd": 0, "bps_wr": 0 } - result =3D self.vm.qmp("block_set_io_throttle", conv_keys=3DFalse,= **args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd("block_set_io_throttle", conv_keys=3DFalse, **args) =20 # Check that the I/O limits have been set result =3D self.vm.qmp("query-block") @@ -403,12 +396,9 @@ class ThrottleTestRemovableMedia(iotests.QMPTestCase): self.assert_qmp(result, 'return[0]/inserted/bps', 50) =20 # Now eject cd0 and insert cd1 - result =3D self.vm.qmp("blockdev-open-tray", id=3D'dev0') - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp("blockdev-remove-medium", id=3D'dev0') - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp("blockdev-insert-medium", id=3D'dev0', node= _name=3D'cd1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd("blockdev-open-tray", id=3D'dev0') + self.vm.cmd("blockdev-remove-medium", id=3D'dev0') + self.vm.cmd("blockdev-insert-medium", id=3D'dev0', node_name=3D'cd= 1') =20 # Check that the I/O limits are still the same result =3D self.vm.qmp("query-block") @@ -416,16 +406,14 @@ class ThrottleTestRemovableMedia(iotests.QMPTestCase): self.assert_qmp(result, 'return[0]/inserted/bps', 50) =20 # Eject cd1 - result =3D self.vm.qmp("blockdev-remove-medium", id=3D'dev0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd("blockdev-remove-medium", id=3D'dev0') =20 # Check that we can't set limits if the device has no medium result =3D self.vm.qmp("block_set_io_throttle", conv_keys=3DFalse,= **args) self.assert_qmp(result, 'error/class', 'GenericError') =20 # Remove the CD drive - result =3D self.vm.qmp("device_del", id=3D'dev0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd("device_del", id=3D'dev0') =20 =20 if __name__ =3D=3D '__main__': diff --git a/tests/qemu-iotests/118 b/tests/qemu-iotests/118 index cae52ffa5e..10dc47459f 100755 --- a/tests/qemu-iotests/118 +++ b/tests/qemu-iotests/118 @@ -74,11 +74,9 @@ class ChangeBaseClass(iotests.QMPTestCase): class GeneralChangeTestsBaseClass(ChangeBaseClass): =20 def test_blockdev_change_medium(self): - result =3D self.vm.qmp('blockdev-change-medium', - id=3Dself.device_name, filename=3Dnew_img, - format=3Diotests.imgfmt) - - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', + id=3Dself.device_name, filename=3Dnew_img, + format=3Diotests.imgfmt) =20 self.wait_for_open() self.wait_for_close() @@ -89,8 +87,7 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/image/filename', new_i= mg) =20 def test_eject(self): - result =3D self.vm.qmp('eject', id=3Dself.device_name, force=3DTru= e) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('eject', id=3Dself.device_name, force=3DTrue) =20 self.wait_for_open() =20 @@ -100,8 +97,7 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp_absent(result, 'return[0]/inserted') =20 def test_tray_eject_change(self): - result =3D self.vm.qmp('eject', id=3Dself.device_name, force=3DTru= e) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('eject', id=3Dself.device_name, force=3DTrue) =20 self.wait_for_open() =20 @@ -110,9 +106,8 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp(result, 'return[0]/tray_open', True) self.assert_qmp_absent(result, 'return[0]/inserted') =20 - result =3D self.vm.qmp('blockdev-change-medium', id=3Dself.device_= name, - filename=3Dnew_img, format=3Diotests.imgfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', id=3Dself.device_name, + filename=3Dnew_img, format=3Diotests.imgfmt) =20 self.wait_for_close() =20 @@ -122,9 +117,8 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/image/filename', new_i= mg) =20 def test_tray_open_close(self): - result =3D self.vm.qmp('blockdev-open-tray', - id=3Dself.device_name, force=3DTrue) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-open-tray', + id=3Dself.device_name, force=3DTrue) =20 self.wait_for_open() =20 @@ -136,8 +130,7 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): else: self.assert_qmp(result, 'return[0]/inserted/image/filename', o= ld_img) =20 - result =3D self.vm.qmp('blockdev-close-tray', id=3Dself.device_nam= e) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-close-tray', id=3Dself.device_name) =20 if self.has_real_tray or not self.was_empty: self.wait_for_close() @@ -151,8 +144,7 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/image/filename', o= ld_img) =20 def test_tray_eject_close(self): - result =3D self.vm.qmp('eject', id=3Dself.device_name, force=3DTru= e) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('eject', id=3Dself.device_name, force=3DTrue) =20 self.wait_for_open() =20 @@ -161,8 +153,7 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp(result, 'return[0]/tray_open', True) self.assert_qmp_absent(result, 'return[0]/inserted') =20 - result =3D self.vm.qmp('blockdev-close-tray', id=3Dself.device_nam= e) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-close-tray', id=3Dself.device_name) =20 self.wait_for_close() =20 @@ -172,9 +163,8 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp_absent(result, 'return[0]/inserted') =20 def test_tray_open_change(self): - result =3D self.vm.qmp('blockdev-open-tray', id=3Dself.device_name, - force=3DTrue) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-open-tray', id=3Dself.device_name, + force=3DTrue) =20 self.wait_for_open() =20 @@ -186,10 +176,9 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): else: self.assert_qmp(result, 'return[0]/inserted/image/filename', o= ld_img) =20 - result =3D self.vm.qmp('blockdev-change-medium', id=3Dself.device_= name, - filename=3Dnew_img, - format=3Diotests.im= gfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', id=3Dself.device_name, + filename=3Dnew_img, + format=3Diotests.imgfmt) =20 self.wait_for_close() =20 @@ -199,17 +188,15 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/image/filename', new_i= mg) =20 def test_cycle(self, read_only_node=3DFalse): - result =3D self.vm.qmp('blockdev-add', - node_name=3D'new', - driver=3Diotests.imgfmt, - read_only=3Dread_only_node, - file=3D{'filename': new_img, - 'driver': 'file'}) - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('blockdev-open-tray', - id=3Dself.device_name, force=3DTrue) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3D'new', + driver=3Diotests.imgfmt, + read_only=3Dread_only_node, + file=3D{'filename': new_img, + 'driver': 'file'}) + + self.vm.cmd('blockdev-open-tray', + id=3Dself.device_name, force=3DTrue) =20 self.wait_for_open() =20 @@ -221,26 +208,23 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): else: self.assert_qmp(result, 'return[0]/inserted/image/filename', o= ld_img) =20 - result =3D self.vm.qmp('blockdev-remove-medium', - id=3Dself.device_name) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-remove-medium', + id=3Dself.device_name) =20 result =3D self.vm.qmp('query-block') if self.has_real_tray: self.assert_qmp(result, 'return[0]/tray_open', True) self.assert_qmp_absent(result, 'return[0]/inserted') =20 - result =3D self.vm.qmp('blockdev-insert-medium', - id=3Dself.device_name, node_name=3D'new') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-insert-medium', + id=3Dself.device_name, node_name=3D'new') =20 result =3D self.vm.qmp('query-block') if self.has_real_tray: self.assert_qmp(result, 'return[0]/tray_open', True) self.assert_qmp(result, 'return[0]/inserted/image/filename', new_i= mg) =20 - result =3D self.vm.qmp('blockdev-close-tray', id=3Dself.device_nam= e) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-close-tray', id=3Dself.device_name) =20 self.wait_for_close() =20 @@ -253,9 +237,8 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): self.test_cycle(True) =20 def test_close_on_closed(self): - result =3D self.vm.qmp('blockdev-close-tray', id=3Dself.device_nam= e) # Should be a no-op - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-close-tray', id=3Dself.device_name) self.assertEqual(self.vm.get_qmp_events(wait=3DFalse), []) =20 def test_remove_on_closed(self): @@ -269,12 +252,11 @@ class GeneralChangeTestsBaseClass(ChangeBaseClass): if not self.has_real_tray: return =20 - result =3D self.vm.qmp('blockdev-add', - node_name=3D'new', - driver=3Diotests.imgfmt, - file=3D{'filename': new_img, - 'driver': 'file'}) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3D'new', + driver=3Diotests.imgfmt, + file=3D{'filename': new_img, + 'driver': 'file'}) =20 result =3D self.vm.qmp('blockdev-insert-medium', id=3Dself.device_= name, node_name=3D'new') @@ -307,15 +289,13 @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass= ): os.remove(new_img) =20 def test_insert_on_filled(self): - result =3D self.vm.qmp('blockdev-add', - node_name=3D'new', - driver=3Diotests.imgfmt, - file=3D{'filename': new_img, - 'driver': 'file'}) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3D'new', + driver=3Diotests.imgfmt, + file=3D{'filename': new_img, + 'driver': 'file'}) =20 - result =3D self.vm.qmp('blockdev-open-tray', id=3Dself.device_name) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-open-tray', id=3Dself.device_name) =20 self.wait_for_open() =20 @@ -344,14 +324,12 @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass): os.remove(new_img) =20 def test_remove_on_empty(self): - result =3D self.vm.qmp('blockdev-open-tray', id=3Dself.device_name) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-open-tray', id=3Dself.device_name) =20 self.wait_for_open() =20 - result =3D self.vm.qmp('blockdev-remove-medium', id=3Dself.device_= name) # Should be a no-op - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-remove-medium', id=3Dself.device_name) =20 # Do this in a function to avoid leaking variables like case into the glob= al # name space (otherwise tests would be run for the abstract base classes) @@ -399,11 +377,10 @@ class TestChangeReadOnly(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/ro', True) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-change-medium', id=3Dself.device_= name, - filename=3Dnew_img, - format=3Diotests.im= gfmt, - read_only_mode=3D'r= etain') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', id=3Dself.device_name, + filename=3Dnew_img, + format=3Diotests.imgfmt, + read_only_mode=3D'retain') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', True) @@ -419,11 +396,10 @@ class TestChangeReadOnly(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/ro', True) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-change-medium', id=3Dself.device_= name, - filename=3Dnew_img, - format=3Diotests.im= gfmt, - read_only_mode=3D'r= etain') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', id=3Dself.device_name, + filename=3Dnew_img, + format=3Diotests.imgfmt, + read_only_mode=3D'retain') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', True) @@ -462,12 +438,11 @@ class TestChangeReadOnly(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/ro', True) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-change-medium', - id=3Dself.device_name, - filename=3Dnew_img, - format=3Diotests.imgfmt, - read_only_mode=3D'read-write') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', + id=3Dself.device_name, + filename=3Dnew_img, + format=3Diotests.imgfmt, + read_only_mode=3D'read-write') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', False) @@ -483,12 +458,11 @@ class TestChangeReadOnly(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/ro', False) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-change-medium', - id=3Dself.device_name, - filename=3Dnew_img, - format=3Diotests.imgfmt, - read_only_mode=3D'read-only') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', + id=3Dself.device_name, + filename=3Dnew_img, + format=3Diotests.imgfmt, + read_only_mode=3D'read-only') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', True) @@ -503,12 +477,11 @@ class TestChangeReadOnly(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/ro', False) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-change-medium', - id=3Dself.device_name, - filename=3Dnew_img, - format=3Diotests.imgfmt, - read_only_mode=3D'read-only') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', + id=3Dself.device_name, + filename=3Dnew_img, + format=3Diotests.imgfmt, + read_only_mode=3D'read-only') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', True) @@ -546,11 +519,10 @@ class TestChangeReadOnly(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/ro', True) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-change-medium', id=3Dself.device_= name, - filename=3Dnew_img, - format=3Diotests.im= gfmt, - read_only_mode=3D'r= etain') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-change-medium', id=3Dself.device_name, + filename=3Dnew_img, + format=3Diotests.imgfmt, + read_only_mode=3D'retain') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', True) @@ -587,27 +559,24 @@ class TestChangeReadOnly(ChangeBaseClass): self.assert_qmp(result, 'return[0]/inserted/ro', False) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-add', - node_name=3D'new', - driver=3Diotests.imgfmt, - read_only=3DTrue, - file=3D{'filename': new_img, - 'driver': 'file'}) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3D'new', + driver=3Diotests.imgfmt, + read_only=3DTrue, + file=3D{'filename': new_img, + 'driver': 'file'}) =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', False) self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) =20 - result =3D self.vm.qmp('blockdev-remove-medium', id=3Dself.device_= name) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-remove-medium', id=3Dself.device_name) =20 result =3D self.vm.qmp('query-block') self.assert_qmp_absent(result, 'return[0]/inserted') =20 - result =3D self.vm.qmp('blockdev-insert-medium', id=3Dself.device_= name, - node_name=3D'new') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-insert-medium', id=3Dself.device_name, + node_name=3D'new') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/ro', True) @@ -638,22 +607,19 @@ class TestBlockJobsAfterCycle(ChangeBaseClass): =20 # For device-less BBs, calling blockdev-open-tray or blockdev-clos= e-tray # is not necessary - result =3D self.vm.qmp('blockdev-remove-medium', id=3Dself.device_= name) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-remove-medium', id=3Dself.device_name) =20 result =3D self.vm.qmp('query-block') self.assert_qmp_absent(result, 'return[0]/inserted') =20 - result =3D self.vm.qmp('blockdev-add', - node_name=3D'node0', - driver=3Diotests.imgfmt, - file=3D{'filename': old_img, - 'driver': 'file'}) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3D'node0', + driver=3Diotests.imgfmt, + file=3D{'filename': old_img, + 'driver': 'file'}) =20 - result =3D self.vm.qmp('blockdev-insert-medium', id=3Dself.device_= name, - node_name=3D'node0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-insert-medium', id=3Dself.device_name, + node_name=3D'node0') =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/image/filename', old_i= mg) @@ -670,10 +636,9 @@ class TestBlockJobsAfterCycle(ChangeBaseClass): @iotests.skip_for_formats(('vpc', 'parallels', 'qcow', 'vdi', 'vmdk', = 'raw', 'vhdx')) def test_snapshot_and_commit(self): - result =3D self.vm.qmp('blockdev-snapshot-sync', device=3D'drive0', - snapshot_file=3Dnew= _img, - format=3Diotests.im= gfmt) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-snapshot-sync', device=3D'drive0', + snapshot_file=3Dnew_img, + format=3Diotests.imgfmt) =20 result =3D self.vm.qmp('query-block') self.assert_qmp(result, 'return[0]/inserted/image/filename', new_i= mg) @@ -681,16 +646,14 @@ class TestBlockJobsAfterCycle(ChangeBaseClass): 'return[0]/inserted/image/backing-image/filename', old_img) =20 - result =3D self.vm.qmp('block-commit', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'drive0') =20 self.vm.event_wait(name=3D'BLOCK_JOB_READY') =20 result =3D self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/device', 'drive0') =20 - result =3D self.vm.qmp('block-job-complete', device=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-complete', device=3D'drive0') =20 self.vm.event_wait(name=3D'BLOCK_JOB_COMPLETED') =20 diff --git a/tests/qemu-iotests/124 b/tests/qemu-iotests/124 index 845ab5303c..b2f4328e34 100755 --- a/tests/qemu-iotests/124 +++ b/tests/qemu-iotests/124 @@ -24,6 +24,7 @@ import os import iotests from iotests import try_remove +from qemu.qmp.qmp_client import ExecuteError =20 =20 def io_write_patterns(img, patterns): @@ -141,8 +142,7 @@ class TestIncrementalBackupBase(iotests.QMPTestCase): =20 =20 def do_qmp_backup(self, error=3D'Input/output error', **kwargs): - res =3D self.vm.qmp('drive-backup', **kwargs) - self.assert_qmp(res, 'return', {}) + self.vm.cmd('drive-backup', **kwargs) return self.wait_qmp_backup(kwargs['device'], error) =20 =20 @@ -201,9 +201,8 @@ class TestIncrementalBackupBase(iotests.QMPTestCase): def add_bitmap(self, name, drive, **kwargs): bitmap =3D Bitmap(name, drive) self.bitmaps.append(bitmap) - result =3D self.vm.qmp('block-dirty-bitmap-add', node=3Ddrive['id'= ], - name=3Dbitmap.name, **kwargs) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-dirty-bitmap-add', node=3Ddrive['id'], + name=3Dbitmap.name, **kwargs) return bitmap =20 =20 @@ -388,13 +387,12 @@ class TestIncrementalBackup(TestIncrementalBackupBase= ): ('0x64', '32736k', '64k'))) bitmap1 =3D self.add_bitmap('bitmap1', drive0) =20 - result =3D self.vm.qmp('transaction', actions=3D[ + self.vm.cmd('transaction', actions=3D[ transaction_bitmap_clear(bitmap0.drive['id'], bitmap0.name), transaction_bitmap_clear(bitmap1.drive['id'], bitmap1.name), transaction_drive_backup(drive0['id'], drive0['backup'], sync=3D'full', format=3Ddrive0['fmt']) ]) - self.assert_qmp(result, 'return', {}) self.wait_until_completed(drive0['id']) self.files.append(drive0['backup']) =20 @@ -417,7 +415,7 @@ class TestIncrementalBackup(TestIncrementalBackupBase): ('0xcd', '32M', '124k'))) =20 # Create a blkdebug interface to this img as 'drive1' - result =3D self.vm.qmp('blockdev-add', + self.vm.cmd('blockdev-add', node_name=3Ddrive1['id'], driver=3Ddrive1['fmt'], file=3D{ @@ -440,7 +438,6 @@ class TestIncrementalBackup(TestIncrementalBackupBase): }], } ) - self.assert_qmp(result, 'return', {}) =20 # Create bitmaps and full backups for both drives drive0 =3D self.drives[0] @@ -475,9 +472,8 @@ class TestIncrementalBackup(TestIncrementalBackupBase): format=3Ddrive1['fmt'], mode=3D'exist= ing', bitmap=3Ddr1bm0.name) ] - result =3D self.vm.qmp('transaction', actions=3Dtransaction, - properties=3D{'completion-mode': 'grouped'} ) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('transaction', actions=3Dtransaction, + properties=3D{'completion-mode': 'grouped'} ) =20 # Observe that drive0's backup is cancelled and drive1 completes w= ith # an error. @@ -504,9 +500,8 @@ class TestIncrementalBackup(TestIncrementalBackupBase): target1 =3D self.prepare_backup(dr1bm0) =20 # Re-run the exact same transaction. - result =3D self.vm.qmp('transaction', actions=3Dtransaction, - properties=3D{'completion-mode':'grouped'}) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('transaction', actions=3Dtransaction, + properties=3D{'completion-mode':'grouped'}) =20 # Both should complete successfully this time. self.assertTrue(self.wait_qmp_backup(drive0['id'])) @@ -567,7 +562,7 @@ class TestIncrementalBackup(TestIncrementalBackupBase): The granularity must always be a power of 2. ''' self.assert_no_active_block_jobs() - self.assertRaises(AssertionError, self.add_bitmap, + self.assertRaises(ExecuteError, self.add_bitmap, 'bitmap0', self.drives[0], granularity=3D64000) =20 @@ -585,9 +580,8 @@ class TestIncrementalBackup(TestIncrementalBackupBase): =20 self.add_bitmap('bitmap0', self.drives[0]) =20 - res =3D self.vm.qmp('block_resize', device=3Dself.drives[0]['id'], - size=3D(65 * 1048576)) - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block_resize', device=3Dself.drives[0]['id'], + size=3D(65 * 1048576)) =20 # Dirty the image past the old end self.vm.hmp_qemu_io(self.drives[0]['id'], 'write 64M 64k') @@ -617,7 +611,7 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBack= upBase): ''' =20 drive0 =3D self.drives[0] - result =3D self.vm.qmp('blockdev-add', + self.vm.cmd('blockdev-add', node_name=3Ddrive0['id'], driver=3Ddrive0['fmt'], file=3D{ @@ -640,7 +634,6 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBack= upBase): }], } ) - self.assert_qmp(result, 'return', {}) =20 self.create_anchor_backup(drive0) self.add_bitmap('bitmap0', drive0) @@ -668,29 +661,28 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBa= ckupBase): drive0 =3D self.drives[0] # NB: The blkdebug script here looks for a "flush, read" pattern. # The flush occurs in hmp_io_writes, and the read during the block= job. - result =3D self.vm.qmp('blockdev-add', - node_name=3Ddrive0['id'], - driver=3Ddrive0['fmt'], - file=3D{ - 'driver': 'blkdebug', - 'image': { - 'driver': 'file', - 'filename': drive0['file'] - }, - 'set-state': [{ - 'event': 'flush_to_disk', - 'state': 1, - 'new_state': 2 - }], - 'inject-error': [{ - 'event': 'read_aio', - 'errno': 5, - 'state': 2, - 'immediately': False, - 'once': True - }], - }) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + node_name=3Ddrive0['id'], + driver=3Ddrive0['fmt'], + file=3D{ + 'driver': 'blkdebug', + 'image': { + 'driver': 'file', + 'filename': drive0['file'] + }, + 'set-state': [{ + 'event': 'flush_to_disk', + 'state': 1, + 'new_state': 2 + }], + 'inject-error': [{ + 'event': 'read_aio', + 'errno': 5, + 'state': 2, + 'immediately': False, + 'once': True + }], + }) self.create_anchor_backup(drive0) bitmap =3D self.add_bitmap('bitmap0', drive0) =20 @@ -711,16 +703,15 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBa= ckupBase): # Start backup parent, _ =3D bitmap.last_target() target =3D self.prepare_backup(bitmap, parent) - res =3D self.vm.qmp('drive-backup', - job_id=3Dbitmap.drive['id'], - device=3Dbitmap.drive['id'], - sync=3D'incremental', - bitmap=3Dbitmap.name, - format=3Dbitmap.drive['fmt'], - target=3Dtarget, - mode=3D'existing', - on_source_error=3D'stop') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('drive-backup', + job_id=3Dbitmap.drive['id'], + device=3Dbitmap.drive['id'], + sync=3D'incremental', + bitmap=3Dbitmap.name, + format=3Dbitmap.drive['fmt'], + target=3Dtarget, + mode=3D'existing', + on_source_error=3D'stop') =20 # Wait for the error event =3D self.vm.event_wait(name=3D"BLOCK_JOB_ERROR", @@ -739,8 +730,7 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBack= upBase): })) =20 # Resume and check incremental backup for consistency - res =3D self.vm.qmp('block-job-resume', device=3Dbitmap.drive['id'= ]) - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-resume', device=3Dbitmap.drive['id']) self.wait_qmp_backup(bitmap.drive['id']) =20 # Bitmap Status Check diff --git a/tests/qemu-iotests/129 b/tests/qemu-iotests/129 index e1536ee3c3..97773cd96d 100755 --- a/tests/qemu-iotests/129 +++ b/tests/qemu-iotests/129 @@ -55,11 +55,9 @@ class TestStopWithBlockJob(iotests.QMPTestCase): def do_test_stop(self, cmd, **args): """Test 'stop' while block job is running on a throttled drive. The 'stop' command shouldn't drain the job""" - result =3D self.vm.qmp(cmd, **args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(cmd, **args) =20 - result =3D self.vm.qmp("stop") - self.assert_qmp(result, 'return', {}) + self.vm.cmd("stop") result =3D self.vm.qmp("query-block-jobs") =20 self.assert_qmp(result, 'return[0]/status', 'running') @@ -87,7 +85,7 @@ class TestStopWithBlockJob(iotests.QMPTestCase): iotests.qemu_img('create', '-f', iotests.imgfmt, self.overlay_img, '1G') =20 - result =3D self.vm.qmp('blockdev-add', { + self.vm.cmd('blockdev-add', { 'node-name': 'overlay', 'driver': iotests.imgfmt, 'file': { @@ -95,11 +93,9 @@ class TestStopWithBlockJob(iotests.QMPTestCase): 'filename': self.overlay_img } }) - self.assert_qmp(result, 'return', {}) =20 - result =3D self.vm.qmp('blockdev-snapshot', - node=3D'source', overlay=3D'overlay') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-snapshot', + node=3D'source', overlay=3D'overlay') =20 self.do_test_stop('block-commit', device=3D'drive0', top_node=3D's= ource') =20 diff --git a/tests/qemu-iotests/132 b/tests/qemu-iotests/132 index 367ea08036..12a64b3d95 100755 --- a/tests/qemu-iotests/132 +++ b/tests/qemu-iotests/132 @@ -47,9 +47,8 @@ class TestSingleDrive(iotests.QMPTestCase): pass =20 def test_mirror_discard(self): - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + target=3Dtarget_img) self.vm.hmp_qemu_io('drive0', 'discard 0 64k') self.complete_and_wait('drive0') self.vm.shutdown() diff --git a/tests/qemu-iotests/139 b/tests/qemu-iotests/139 index 178b1ee230..ebb4cd62b6 100755 --- a/tests/qemu-iotests/139 +++ b/tests/qemu-iotests/139 @@ -58,8 +58,7 @@ class TestBlockdevDel(iotests.QMPTestCase): 'file': {'driver': 'file', 'node-name': file_node, 'filename': base_img}} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) self.checkBlockDriverState(node) self.checkBlockDriverState(file_node) =20 @@ -73,8 +72,7 @@ class TestBlockdevDel(iotests.QMPTestCase): 'backing': None, 'file': {'driver': 'file', 'filename': new_img}} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) self.checkBlockDriverState(node) =20 # Delete a BlockDriverState @@ -89,17 +87,14 @@ class TestBlockdevDel(iotests.QMPTestCase): =20 # Add a device model def addDeviceModel(self, device, backend, driver =3D 'virtio-blk'): - result =3D self.vm.qmp('device_add', id =3D device, - driver =3D driver, drive =3D backend) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', id =3D device, + driver =3D driver, drive =3D backend) =20 # Delete a device model def delDeviceModel(self, device, is_virtio_blk =3D True): - result =3D self.vm.qmp('device_del', id =3D device) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_del', id =3D device) =20 - result =3D self.vm.qmp('system_reset') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('system_reset') =20 if is_virtio_blk: device_path =3D '/machine/peripheral/%s/virtio-backend' % devi= ce @@ -126,9 +121,8 @@ class TestBlockdevDel(iotests.QMPTestCase): # Insert a BlockDriverState def insertDrive(self, device, node): self.checkBlockDriverState(node) - result =3D self.vm.qmp('blockdev-insert-medium', - id =3D device, node_name =3D node) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-insert-medium', + id =3D device, node_name =3D node) self.checkBlockDriverState(node) =20 # Create a snapshot using 'blockdev-snapshot-sync' @@ -139,8 +133,7 @@ class TestBlockdevDel(iotests.QMPTestCase): 'snapshot-file': new_img, 'snapshot-node-name': overlay, 'format': iotests.imgfmt} - result =3D self.vm.qmp('blockdev-snapshot-sync', conv_keys=3DFalse= , **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-snapshot-sync', conv_keys=3DFalse, **opts) self.checkBlockDriverState(node) self.checkBlockDriverState(overlay) =20 @@ -148,9 +141,8 @@ class TestBlockdevDel(iotests.QMPTestCase): def createSnapshot(self, node, overlay): self.checkBlockDriverState(node) self.checkBlockDriverState(overlay) - result =3D self.vm.qmp('blockdev-snapshot', - node =3D node, overlay =3D overlay) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-snapshot', + node =3D node, overlay =3D overlay) self.checkBlockDriverState(node) self.checkBlockDriverState(overlay) =20 @@ -163,14 +155,12 @@ class TestBlockdevDel(iotests.QMPTestCase): 'node-name': new_node, 'sync': 'top', 'format': iotests.imgfmt} - result =3D self.vm.qmp('drive-mirror', conv_keys=3DFalse, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', conv_keys=3DFalse, **opts) self.checkBlockDriverState(new_node) =20 # Complete an existing block job def completeBlockJob(self, id, node_before, node_after): - result =3D self.vm.qmp('block-job-complete', device=3Did) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-complete', device=3Did) self.wait_until_completed(id) =20 # Add a BlkDebug node @@ -186,8 +176,7 @@ class TestBlockdevDel(iotests.QMPTestCase): opts =3D {'driver': 'blkdebug', 'node-name': debug, 'image': image} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) self.checkBlockDriverState(node) self.checkBlockDriverState(debug) =20 @@ -211,8 +200,7 @@ class TestBlockdevDel(iotests.QMPTestCase): 'node-name': blkverify, 'test': node_0, 'raw': node_1} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) self.checkBlockDriverState(test) self.checkBlockDriverState(raw) self.checkBlockDriverState(blkverify) @@ -235,8 +223,7 @@ class TestBlockdevDel(iotests.QMPTestCase): 'node-name': quorum, 'vote-threshold': 1, 'children': [ child_0, child_1 ]} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) self.checkBlockDriverState(child0) self.checkBlockDriverState(child1) self.checkBlockDriverState(quorum) diff --git a/tests/qemu-iotests/147 b/tests/qemu-iotests/147 index 08111c5108..6d6f077a14 100755 --- a/tests/qemu-iotests/147 +++ b/tests/qemu-iotests/147 @@ -58,8 +58,7 @@ class NBDBlockdevAddBase(iotests.QMPTestCase): def client_test(self, filename, address, export=3DNone, node_name=3D'nbd-blockdev', delete=3DTrue): bao =3D self.blockdev_add_options(address, export, node_name) - result =3D self.vm.qmp('blockdev-add', bao) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', bao) =20 found =3D False result =3D self.vm.qmp('query-named-block-nodes') @@ -75,8 +74,7 @@ class NBDBlockdevAddBase(iotests.QMPTestCase): self.assertTrue(found) =20 if delete: - result =3D self.vm.qmp('blockdev-del', node_name=3Dnode_name) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3Dnode_name) =20 =20 class QemuNBD(NBDBlockdevAddBase): @@ -158,17 +156,14 @@ class BuiltinNBD(NBDBlockdevAddBase): self.assert_qmp(result, 'return', {}) =20 if export_name is None: - result =3D self.server.qmp('nbd-server-add', device=3D'nbd-exp= ort') - self.assert_qmp(result, 'return', {}) + self.server.cmd('nbd-server-add', device=3D'nbd-export') else: - result =3D self.server.qmp('nbd-server-add', device=3D'nbd-exp= ort', - name=3Dexport_name) - self.assert_qmp(result, 'return', {}) + self.server.cmd('nbd-server-add', device=3D'nbd-export', + name=3Dexport_name) =20 if export_name2 is not None: - result =3D self.server.qmp('nbd-server-add', device=3D'nbd-exp= ort', - name=3Dexport_name2) - self.assert_qmp(result, 'return', {}) + self.server.cmd('nbd-server-add', device=3D'nbd-export', + name=3Dexport_name2) =20 return True =20 @@ -176,8 +171,7 @@ class BuiltinNBD(NBDBlockdevAddBase): self.assertTrue(self._try_server_up(address, export_name, export_n= ame2)) =20 def _server_down(self): - result =3D self.server.qmp('nbd-server-stop') - self.assert_qmp(result, 'return', {}) + self.server.cmd('nbd-server-stop') =20 def do_test_inet(self, export_name=3DNone): while True: @@ -219,10 +213,8 @@ class BuiltinNBD(NBDBlockdevAddBase): flatten_sock_addr(address), 'exp1', 'node1', Fals= e) self.client_test('nbd://localhost:%i/%s' % (nbd_port, 'exp2'), flatten_sock_addr(address), 'exp2', 'node2', Fals= e) - result =3D self.vm.qmp('blockdev-del', node_name=3D'node1') - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('blockdev-del', node_name=3D'node2') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'node1') + self.vm.cmd('blockdev-del', node_name=3D'node2') self._server_down() =20 def test_inet6(self): @@ -273,8 +265,7 @@ class BuiltinNBD(NBDBlockdevAddBase): result =3D self.vm.send_fd_scm(fd=3Dsockfd.fileno()) self.assertEqual(result, 0, 'Failed to send socket FD') =20 - result =3D self.vm.qmp('getfd', fdname=3D'nbd-fifo') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('getfd', fdname=3D'nbd-fifo') =20 address =3D { 'type': 'fd', 'data': { 'str': 'nbd-fifo' } } diff --git a/tests/qemu-iotests/151 b/tests/qemu-iotests/151 index 668d0c1e9c..d8c444ef35 100755 --- a/tests/qemu-iotests/151 +++ b/tests/qemu-iotests/151 @@ -79,14 +79,13 @@ class TestActiveMirror(iotests.QMPTestCase): self.vm.hmp_qemu_io('source', 'aio_write -z %i 1M' % offset) =20 # Start the block job - result =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - filter_node_name=3D'mirror-node', - device=3D'source-node', - target=3D'target-node', - sync=3D'full', - copy_mode=3D'write-blocking') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + filter_node_name=3D'mirror-node', + device=3D'source-node', + target=3D'target-node', + sync=3D'full', + copy_mode=3D'write-blocking') =20 # Start some more requests for offset in range(3 * self.image_len // 8, 5 * self.image_len //= 8, 1024 * 1024): @@ -125,23 +124,21 @@ class TestActiveMirror(iotests.QMPTestCase): result =3D self.vm.hmp_qemu_io('source', 'write -P 1 0 2M') =20 # Start the block job (very slowly) - result =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - filter_node_name=3D'mirror-node', - device=3D'source-node', - target=3D'target-node', - sync=3D'full', - copy_mode=3D'write-blocking', - buf_size=3D(1048576 // 4), - speed=3D1) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + filter_node_name=3D'mirror-node', + device=3D'source-node', + target=3D'target-node', + sync=3D'full', + copy_mode=3D'write-blocking', + buf_size=3D(1048576 // 4), + speed=3D1) =20 # Start an unaligned request to a dirty area result =3D self.vm.hmp_qemu_io('source', 'write -P 2 %i 1' % (1048= 576 + 42)) =20 # Let the job finish - result =3D self.vm.qmp('block-job-set-speed', device=3D'mirror', s= peed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'mirror', speed=3D0) self.complete_and_wait(drive=3D'mirror') =20 self.potential_writes_in_flight =3D False @@ -151,15 +148,14 @@ class TestActiveMirror(iotests.QMPTestCase): result =3D self.vm.hmp_qemu_io('source', 'write -P 1 0 2M') =20 # Start the block job (very slowly) - result =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - filter_node_name=3D'mirror-node', - device=3D'source-node', - target=3D'target-node', - sync=3D'full', - copy_mode=3D'write-blocking', - speed=3D1) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + filter_node_name=3D'mirror-node', + device=3D'source-node', + target=3D'target-node', + sync=3D'full', + copy_mode=3D'write-blocking', + speed=3D1) =20 self.vm.hmp_qemu_io('source', 'break write_aio A') self.vm.hmp_qemu_io('source', 'aio_write 0 1M') # 1 @@ -190,8 +186,7 @@ class TestActiveMirror(iotests.QMPTestCase): # After resuming 4, one of 2 and 3 goes first and set in_flight_bi= tmap, # so the other will wait for it. =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'mirror', s= peed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'mirror', speed=3D0) self.complete_and_wait(drive=3D'mirror') =20 self.potential_writes_in_flight =3D False diff --git a/tests/qemu-iotests/152 b/tests/qemu-iotests/152 index b73a0d08a2..197bea9e77 100755 --- a/tests/qemu-iotests/152 +++ b/tests/qemu-iotests/152 @@ -41,18 +41,16 @@ class TestUnaligned(iotests.QMPTestCase): pass =20 def test_unaligned(self): - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - granularity=3D65536, target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + granularity=3D65536, target=3Dtarget_img) self.complete_and_wait() self.vm.shutdown() self.assertEqual(iotests.image_size(test_img), iotests.image_size(= target_img), "Target size doesn't match source when granularit= y when unaligend") =20 def test_unaligned_with_update(self): - result =3D self.vm.qmp('drive-mirror', device=3D'drive0', sync=3D'= full', - granularity=3D65536, target=3Dtarget_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('drive-mirror', device=3D'drive0', sync=3D'full', + granularity=3D65536, target=3Dtarget_img) self.wait_ready() self.vm.hmp_qemu_io('drive0', 'write 0 512') self.complete_and_wait(wait_ready=3DFalse) diff --git a/tests/qemu-iotests/155 b/tests/qemu-iotests/155 index 0c073fd61b..38eacb4127 100755 --- a/tests/qemu-iotests/155 +++ b/tests/qemu-iotests/155 @@ -110,8 +110,7 @@ class BaseClass(iotests.QMPTestCase): elif self.target_blockdev_backing: options['backing'] =3D self.target_blockdev_backing =20 - result =3D self.vm.qmp('blockdev-add', options) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', options) =20 def tearDown(self): self.vm.shutdown() @@ -178,20 +177,18 @@ class MirrorBaseClass(BaseClass): =20 def runMirror(self, sync): if self.cmd =3D=3D 'blockdev-mirror': - result =3D self.vm.qmp(self.cmd, job_id=3D'mirror-job', device= =3D'source', - sync=3Dsync, target=3D'target', - auto_finalize=3DFalse) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.cmd, job_id=3D'mirror-job', device=3D'source', + sync=3Dsync, target=3D'target', + auto_finalize=3DFalse) else: if self.existing: mode =3D 'existing' else: mode =3D 'absolute-paths' - result =3D self.vm.qmp(self.cmd, job_id=3D'mirror-job', device= =3D'source', - sync=3Dsync, target=3Dtarget_img, - format=3Diotests.imgfmt, mode=3Dmode, - node_name=3D'target', auto_finalize=3DFal= se) - self.assert_qmp(result, 'return', {}) + self.vm.cmd(self.cmd, job_id=3D'mirror-job', device=3D'source', + sync=3Dsync, target=3Dtarget_img, + format=3Diotests.imgfmt, mode=3Dmode, + node_name=3D'target', auto_finalize=3DFalse) =20 self.vm.run_job('mirror-job', auto_finalize=3DFalse, pre_finalize=3Dself.openBacking, auto_dismiss=3DTr= ue) @@ -258,16 +255,14 @@ class TestBlockdevMirrorReopen(MirrorBaseClass): =20 def openBacking(self): if not self.target_open_with_backing: - result =3D self.vm.qmp('blockdev-add', node_name=3D"backing", - driver=3D"null-co") - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('blockdev-reopen', options=3D[{ - 'node-name': "target", - 'driver': iotests.imgfmt, - 'file': "target-file", - 'backing': "backing" - }]) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', node_name=3D"backing", + driver=3D"null-co") + self.vm.cmd('blockdev-reopen', options=3D[{ + 'node-name': "target", + 'driver': iotests.imgfmt, + 'file': "target-file", + 'backing': "backing" + }]) =20 class TestBlockdevMirrorReopenIothread(TestBlockdevMirrorReopen): use_iothread =3D True @@ -281,12 +276,10 @@ class TestBlockdevMirrorSnapshot(MirrorBaseClass): =20 def openBacking(self): if not self.target_open_with_backing: - result =3D self.vm.qmp('blockdev-add', node_name=3D"backing", - driver=3D"null-co") - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('blockdev-snapshot', node=3D"backing", - overlay=3D"target") - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', node_name=3D"backing", + driver=3D"null-co") + self.vm.cmd('blockdev-snapshot', node=3D"backing", + overlay=3D"target") =20 class TestBlockdevMirrorSnapshotIothread(TestBlockdevMirrorSnapshot): use_iothread =3D True @@ -295,14 +288,12 @@ class TestCommit(BaseClass): existing =3D False =20 def testCommit(self): - result =3D self.vm.qmp('block-commit', job_id=3D'commit-job', - device=3D'source', base=3Dback1_img) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', job_id=3D'commit-job', + device=3D'source', base=3Dback1_img) =20 self.vm.event_wait('BLOCK_JOB_READY') =20 - result =3D self.vm.qmp('block-job-complete', device=3D'commit-job') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-complete', device=3D'commit-job') =20 self.vm.event_wait('BLOCK_JOB_COMPLETED') =20 diff --git a/tests/qemu-iotests/165 b/tests/qemu-iotests/165 index e3ef28e2ee..b24907a62f 100755 --- a/tests/qemu-iotests/165 +++ b/tests/qemu-iotests/165 @@ -116,9 +116,8 @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase): sha256_2 =3D self.getSha256() assert sha256_1 !=3D sha256_2 # Otherwise, it's not very interesti= ng. =20 - result =3D self.vm.qmp('block-dirty-bitmap-clear', node=3D'drive0', - name=3D'bitmap0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-dirty-bitmap-clear', node=3D'drive0', + name=3D'bitmap0') =20 # Start with regions1 =20 @@ -137,7 +136,7 @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase): assert sha256_1 =3D=3D self.getSha256() =20 # Reopen to RW - result =3D self.vm.qmp('blockdev-reopen', options=3D[{ + self.vm.cmd('blockdev-reopen', options=3D[{ 'node-name': 'node0', 'driver': iotests.imgfmt, 'file': { @@ -146,7 +145,6 @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase): }, 'read-only': False }]) - self.assert_qmp(result, 'return', {}) =20 # Check that bitmap is reopened to RW and we can write to it. self.writeRegions(regions2) diff --git a/tests/qemu-iotests/196 b/tests/qemu-iotests/196 index 27c1629be3..e5105b1354 100755 --- a/tests/qemu-iotests/196 +++ b/tests/qemu-iotests/196 @@ -45,8 +45,7 @@ class TestInvalidateAutoclear(iotests.QMPTestCase): self.vm_b.add_incoming("exec: cat '" + migfile + "'") =20 def test_migration(self): - result =3D self.vm_a.qmp('migrate', uri=3D'exec:cat>' + migfile) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate', uri=3D'exec:cat>' + migfile) self.assertNotEqual(self.vm_a.event_wait("STOP"), None) =20 with open(disk, 'r+b') as f: diff --git a/tests/qemu-iotests/205 b/tests/qemu-iotests/205 index 15f798288a..2370e1a138 100755 --- a/tests/qemu-iotests/205 +++ b/tests/qemu-iotests/205 @@ -44,10 +44,8 @@ class TestNbdServerRemove(iotests.QMPTestCase): } } =20 - result =3D self.vm.qmp('nbd-server-start', addr=3Daddress) - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('nbd-server-add', device=3D'drive0', name= =3D'exp') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('nbd-server-start', addr=3Daddress) + self.vm.cmd('nbd-server-add', device=3D'drive0', name=3D'exp') =20 def tearDown(self): self.vm.shutdown() diff --git a/tests/qemu-iotests/218 b/tests/qemu-iotests/218 index 5e74c55b6a..81aa68806f 100755 --- a/tests/qemu-iotests/218 +++ b/tests/qemu-iotests/218 @@ -41,34 +41,30 @@ iotests.script_initialize(supported_fmts=3D['qcow2', 'r= aw']) def start_mirror(vm, speed=3DNone, buf_size=3DNone): vm.launch() =20 - ret =3D vm.qmp('blockdev-add', - node_name=3D'source', - driver=3D'null-co', - size=3D1048576) - assert ret['return'] =3D=3D {} - - ret =3D vm.qmp('blockdev-add', - node_name=3D'target', - driver=3D'null-co', - size=3D1048576) - assert ret['return'] =3D=3D {} + vm.cmd('blockdev-add', + node_name=3D'source', + driver=3D'null-co', + size=3D1048576) + + vm.cmd('blockdev-add', + node_name=3D'target', + driver=3D'null-co', + size=3D1048576) =20 if speed is not None: - ret =3D vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'source', - target=3D'target', - sync=3D'full', - speed=3Dspeed, - buf_size=3Dbuf_size) - assert ret['return'] =3D=3D {} + vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'source', + target=3D'target', + sync=3D'full', + speed=3Dspeed, + buf_size=3Dbuf_size) else: - ret =3D vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'source', - target=3D'target', - sync=3D'full') - assert ret['return'] =3D=3D {} + vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'source', + target=3D'target', + sync=3D'full') =20 =20 log('') @@ -150,38 +146,33 @@ with iotests.VM() as vm, \ =20 vm.launch() =20 - ret =3D vm.qmp('object-add', qom_type=3D'throttle-group', id=3D'tg', - limits=3D{'bps-read': 4096}) - assert ret['return'] =3D=3D {} - - ret =3D vm.qmp('blockdev-add', - node_name=3D'source', - driver=3Diotests.imgfmt, - file=3D{ - 'driver': 'file', - 'filename': src_img_path - }) - assert ret['return'] =3D=3D {} - - ret =3D vm.qmp('blockdev-add', - node_name=3D'throttled-source', - driver=3D'throttle', - throttle_group=3D'tg', - file=3D'source') - assert ret['return'] =3D=3D {} - - ret =3D vm.qmp('blockdev-add', - node_name=3D'target', - driver=3D'null-co', - size=3D(64 * 1048576)) - assert ret['return'] =3D=3D {} - - ret =3D vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'throttled-source', - target=3D'target', - sync=3D'full') - assert ret['return'] =3D=3D {} + vm.cmd('object-add', qom_type=3D'throttle-group', id=3D'tg', + limits=3D{'bps-read': 4096}) + + vm.cmd('blockdev-add', + node_name=3D'source', + driver=3Diotests.imgfmt, + file=3D{ + 'driver': 'file', + 'filename': src_img_path + }) + + vm.cmd('blockdev-add', + node_name=3D'throttled-source', + driver=3D'throttle', + throttle_group=3D'tg', + file=3D'source') + + vm.cmd('blockdev-add', + node_name=3D'target', + driver=3D'null-co', + size=3D(64 * 1048576)) + + vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'throttled-source', + target=3D'target', + sync=3D'full') =20 log(vm.qmp('quit')) =20 diff --git a/tests/qemu-iotests/245 b/tests/qemu-iotests/245 index edaf29094b..3993fee9a2 100755 --- a/tests/qemu-iotests/245 +++ b/tests/qemu-iotests/245 @@ -136,8 +136,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): def test_incorrect_parameters_single_file(self): # Open 'hd0' only (no backing files) opts =3D hd_opts(0) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) original_graph =3D self.vm.qmp('query-named-block-nodes') =20 # We can reopen the image passing the same options @@ -171,8 +170,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.check_node_graph(original_graph) =20 # Remove the node - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') =20 # This test opens an image with a backing file and tries to reopen # it with illegal / incorrect parameters. @@ -180,8 +178,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): # Open hd1 omitting the backing options (hd0 will be opened # with the default options) opts =3D hd_opts(1) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) original_graph =3D self.vm.qmp('query-named-block-nodes') =20 # We can't reopen the image passing the same options, 'backing' is= mandatory @@ -213,8 +210,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.check_node_graph(original_graph) =20 # Remove the node - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd1= ') =20 # Reopen an image several times changing some of its options def test_reopen(self): @@ -230,8 +226,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): # Open the hd1 image passing all backing options opts =3D hd_opts(1) opts['backing'] =3D hd_opts(0) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) original_graph =3D self.vm.qmp('query-named-block-nodes') =20 # We can reopen the image passing the same options @@ -306,8 +301,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.assert_qmp_absent(self.get_node('hd1'), 'image/backing-image') =20 # Open the 'hd0' image - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **hd_o= pts(0)) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **hd_opts(0)) =20 # Reopen the hd1 image setting 'hd0' as its backing image self.reopen(opts, {'backing': 'hd0'}) @@ -326,10 +320,8 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.assert_qmp(result, 'error/desc', "Node 'hd0' is busy: node is= used as backing hd of 'hd1'") =20 # But we can remove both nodes if done in the proper order - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd1') - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd1= ') + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') =20 # Reopen a raw image and see the effect of changing the 'offset' option def test_reopen_raw(self): @@ -345,8 +337,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): qemu_io('-f', 'raw', '-c', 'write -P 0xa1 1M 1M', hd_path[0]) =20 # Open the raw file with QEMU - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Read 1MB from offset 0 self.run_qemu_io("hd0", "read -P 0xa0 0 1M") @@ -362,8 +353,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.run_qemu_io("hd0", "read -P 0xa0 0 1M") =20 # Remove the block device - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') =20 # Omitting an option should reset it to the default value, but if # an option cannot be changed it shouldn't be possible to reset it @@ -377,8 +367,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): 'node-name': 'hd0-file' } } =20 # Open the file with QEMU - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # file.x-check-cache-dropped can be changed... self.reopen(opts, { 'file.x-check-cache-dropped': False }) @@ -394,8 +383,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.reopen(opts, { 'file.locking': 'off' }) =20 # Remove the block device - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') =20 # This test modifies the node graph a few times by changing the # 'backing' option on reopen and verifies that the guest data that @@ -407,8 +395,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): for i in range(3): opts.append(hd_opts(i)) opts[i]['backing'] =3D None - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **= opts[i]) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts[i]) =20 # hd0 self.run_qemu_io("hd0", "read -P 0xa0 0 1M") @@ -499,8 +486,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): for i in range(3): opts.append(hd_opts(i)) opts[i]['backing'] =3D None - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **= opts[i]) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts[i]) =20 # hd1 <- hd0, hd1 <- hd2 self.reopen(opts[0], {'backing': 'hd1'}) @@ -532,8 +518,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): 'node-name': 'bv', 'test': 'hd0', 'raw': 'hd1'} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **bvop= ts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **bvopts) =20 # blkverify doesn't currently allow reopening. TODO: implement this self.reopen(bvopts, {}, "Block format 'blkverify' used by node 'bv= '" + @@ -544,8 +529,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): "Making 'bv' a backing child of 'hd0' would create a c= ycle") =20 # Delete the blkverify node - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'bv') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'bv') =20 # Replace the protocol layer ('file' parameter) of a disk image def test_replace_file(self): @@ -556,16 +540,13 @@ class TestBlockdevReopen(iotests.QMPTestCase): hd0_opts =3D {'driver': 'file', 'node-name': 'hd0-file', 'filename= ': hd_path[0] } hd1_opts =3D {'driver': 'file', 'node-name': 'hd1-file', 'filename= ': hd_path[1] } =20 - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **hd0_= opts) - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **hd1_= opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **hd0_opts) + self.vm.cmd('blockdev-add', conv_keys =3D False, **hd1_opts) =20 # Add a raw format layer that uses hd0-file as its protocol layer opts =3D {'driver': 'raw', 'node-name': 'hd', 'file': 'hd0-file'} =20 - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Fill the image with data self.run_qemu_io("hd", "read -P 0 0 10k") @@ -588,21 +569,18 @@ class TestBlockdevReopen(iotests.QMPTestCase): def test_insert_throttle_filter(self): # Add an image to the VM hd0_opts =3D hd_opts(0) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **hd0_= opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **hd0_opts) =20 # Create a throttle-group object opts =3D { 'qom-type': 'throttle-group', 'id': 'group0', 'limits': { 'iops-total': 1000 } } - result =3D self.vm.qmp('object-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', conv_keys =3D False, **opts) =20 # Add a throttle filter with the group that we just created. # The filter is not used by anyone yet opts =3D { 'driver': 'throttle', 'node-name': 'throttle0', 'throttle-group': 'group0', 'file': 'hd0-file' } - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Insert the throttle filter between hd0 and hd0-file self.reopen(hd0_opts, {'file': 'throttle0'}) @@ -614,15 +592,13 @@ class TestBlockdevReopen(iotests.QMPTestCase): def test_insert_compress_filter(self): # Add an image to the VM: hd (raw) -> hd0 (qcow2) -> hd0-file (fil= e) opts =3D {'driver': 'raw', 'node-name': 'hd', 'file': hd_opts(0)} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Add a 'compress' filter filter_opts =3D {'driver': 'compress', 'node-name': 'compress0', 'file': 'hd0'} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **filt= er_opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **filter_opts) =20 # Unmap the beginning of the image (we cannot write compressed # data to an allocated cluster) @@ -658,12 +634,10 @@ class TestBlockdevReopen(iotests.QMPTestCase): def test_swap_files(self): # Add hd0 and hd2 (none of them with backing files) opts0 =3D hd_opts(0) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts= 0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts0) =20 opts2 =3D hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts= 2) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts2) =20 # Write different data to both block devices self.run_qemu_io("hd0", "write -P 0xa0 0 1k") @@ -711,15 +685,13 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts =3D hd_opts(i) # Open all three images without backing file opts['backing'] =3D None - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **= opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 opts =3D {'driver': 'quorum', 'node-name': 'quorum0', 'children': ['hd0', 'hd1', 'hd2'], 'vote-threshold': 2} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Quorum doesn't currently allow reopening. TODO: implement this self.reopen(opts, {}, "Block format 'quorum' used by node 'quorum0= '" + @@ -731,14 +703,12 @@ class TestBlockdevReopen(iotests.QMPTestCase): "Making 'quorum0' a backing child of 'hd0' would creat= e a cycle") =20 # Delete quorum0 - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'quorum0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'quo= rum0') =20 # Delete hd0, hd1 and hd2 for i in range(3): - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, - node_name =3D 'hd%d' % i) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, + node_name =3D 'hd%d' % i) =20 ###################### ###### blkdebug ###### @@ -747,8 +717,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): 'node-name': 'bd', 'config': '/dev/null', 'image': hd_opts(0)} - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # blkdebug allows reopening if we keep the same options self.reopen(opts) @@ -761,16 +730,14 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.reopen(opts, {}, "Option 'config' cannot be reset to its defa= ult value") =20 # Delete the blkdebug node - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'bd') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'bd') =20 ################## ###### null ###### ################## opts =3D {'driver': 'null-co', 'node-name': 'root', 'size': 1024} =20 - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # 1 << 30 is the default value, but we cannot change it explicitly self.reopen(opts, {'size': (1 << 30)}, "Cannot change the option '= size'") @@ -779,16 +746,14 @@ class TestBlockdevReopen(iotests.QMPTestCase): del opts['size'] self.reopen(opts, {}, "Option 'size' cannot be reset to its defaul= t value") =20 - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'root') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'roo= t') =20 ################## ###### file ###### ################## opts =3D hd_opts(0) opts['file']['locking'] =3D 'on' - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # 'locking' cannot be changed del opts['file']['locking'] @@ -802,27 +767,23 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.reopen(opts, {'locking': 'off'}, "Cannot change the option 'l= ocking'") self.reopen(opts, {}, "Option 'locking' cannot be reset to its def= ault value") =20 - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') =20 ###################### ###### throttle ###### ###################### opts =3D { 'qom-type': 'throttle-group', 'id': 'group0', 'limits': { 'iops-total': 1000 } } - result =3D self.vm.qmp('object-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', conv_keys =3D False, **opts) =20 opts =3D { 'qom-type': 'throttle-group', 'id': 'group1', 'limits': { 'iops-total': 2000 } } - result =3D self.vm.qmp('object-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', conv_keys =3D False, **opts) =20 # Add a throttle filter with group =3D group0 opts =3D { 'driver': 'throttle', 'node-name': 'throttle0', 'throttle-group': 'group0', 'file': hd_opts(0) } - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # We can reopen it if we keep the same options self.reopen(opts) @@ -850,16 +811,13 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.assert_qmp(result, 'error/desc', "object 'group0' is in use, = can not be deleted") =20 # But group1 is free this time, and it can be deleted - result =3D self.vm.qmp('object-del', id =3D 'group1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-del', id =3D 'group1') =20 # Let's delete the filter node - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'throttle0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'thr= ottle0') =20 # And we can finally get rid of group0 - result =3D self.vm.qmp('object-del', id =3D 'group0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-del', id =3D 'group0') =20 # If an image has a backing file then the 'backing' option must be # passed on reopen. We don't allow leaving the option out in this @@ -867,13 +825,11 @@ class TestBlockdevReopen(iotests.QMPTestCase): def test_missing_backing_options_1(self): # hd2 opts =3D hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # hd0 opts =3D hd_opts(0) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # hd0 has no backing file: we can omit the 'backing' option self.reopen(opts) @@ -896,11 +852,9 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.reopen(opts) =20 # Remove both hd0 and hd2 - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') =20 - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd2') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd2= ') =20 # If an image has default backing file (as part of its metadata) # then the 'backing' option must be passed on reopen. We don't @@ -910,8 +864,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): # hd0 <- hd1 # (hd0 is hd1's default backing file) opts =3D hd_opts(1) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # hd1 has a backing file: we can't omit the 'backing' option self.reopen(opts, {}, "backing is missing for 'hd1'") @@ -922,8 +875,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): # No backing file attached to hd1 now, but we still can't omit the= 'backing' option self.reopen(opts, {}, "backing is missing for 'hd1'") =20 - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd1= ') =20 # Test that making 'backing' a reference to an existing child # keeps its current options @@ -936,8 +888,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts['detect-zeroes'] =3D 'on' opts['backing']['detect-zeroes'] =3D 'on' opts['backing']['backing']['detect-zeroes'] =3D 'on' - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Reopen the chain passing the minimum amount of required options. # By making 'backing' a reference to hd1 (instead of a sub-dict) @@ -960,12 +911,10 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts =3D hd_opts(0) opts['backing'] =3D hd_opts(1) opts['backing']['backing'] =3D None - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Stream hd1 into hd0 and wait until it's done - result =3D self.vm.qmp('block-stream', conv_keys =3D True, job_id = =3D 'stream0', device =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', conv_keys =3D True, job_id =3D 'stream= 0', device =3D 'hd0') self.wait_until_completed(drive =3D 'stream0') =20 # Now we have only hd0 @@ -981,8 +930,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): # We can also reopen hd0 if we set 'backing' to null self.reopen(opts, {'backing': None}) =20 - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') =20 # Another block_stream test def test_block_stream_2(self): @@ -990,13 +938,11 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts =3D hd_opts(0) opts['backing'] =3D hd_opts(1) opts['backing']['backing'] =3D hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # Stream hd1 into hd0 and wait until it's done - result =3D self.vm.qmp('block-stream', conv_keys =3D True, job_id = =3D 'stream0', - device =3D 'hd0', base_node =3D 'hd2') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', conv_keys =3D True, job_id =3D 'stream= 0', + device =3D 'hd0', base_node =3D 'hd2') self.wait_until_completed(drive =3D 'stream0') =20 # The chain is hd2 <- hd0 now. hd1 is missing @@ -1018,8 +964,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.reopen(opts, {}, "backing is missing for 'hd0'") =20 # Now we can delete hd0 (and hd2) - result =3D self.vm.qmp('blockdev-del', conv_keys =3D True, node_na= me =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', conv_keys =3D True, node_name =3D 'hd0= ') self.assertEqual(self.get_node('hd2'), None) =20 # Reopen the chain during a block-stream job (from hd1 to hd0) @@ -1028,14 +973,12 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts =3D hd_opts(0) opts['backing'] =3D hd_opts(1) opts['backing']['backing'] =3D hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # hd2 <- hd0 - result =3D self.vm.qmp('block-stream', conv_keys =3D True, job_id = =3D 'stream0', - device =3D 'hd0', base_node =3D 'hd2', - auto_finalize =3D False) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', conv_keys =3D True, job_id =3D 'stream= 0', + device =3D 'hd0', base_node =3D 'hd2', + auto_finalize =3D False) =20 # We can remove hd2 while the stream job is ongoing opts['backing']['backing'] =3D None @@ -1053,14 +996,12 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts =3D hd_opts(0) opts['backing'] =3D hd_opts(1) opts['backing']['backing'] =3D hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 # hd1 <- hd0 - result =3D self.vm.qmp('block-stream', conv_keys =3D True, job_id = =3D 'stream0', - device =3D 'hd1', filter_node_name=3D'cor', - auto_finalize =3D False) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-stream', conv_keys =3D True, job_id =3D 'stream= 0', + device =3D 'hd1', filter_node_name=3D'cor', + auto_finalize =3D False) =20 # We can't reopen with the original options because there is a fil= ter # inserted by stream job above hd1. @@ -1089,12 +1030,10 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts =3D hd_opts(0) opts['backing'] =3D hd_opts(1) opts['backing']['backing'] =3D hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 - result =3D self.vm.qmp('block-commit', conv_keys =3D True, job_id = =3D 'commit0', - device =3D 'hd0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', conv_keys =3D True, job_id =3D 'commit= 0', + device =3D 'hd0') =20 # We can't remove hd2 while the commit job is ongoing opts['backing']['backing'] =3D None @@ -1109,8 +1048,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.assert_qmp(event, 'data/type', 'commit') self.assert_qmp_absent(event, 'data/error') =20 - result =3D self.vm.qmp('block-job-complete', device=3D'commit0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-complete', device=3D'commit0') =20 self.wait_until_completed(drive =3D 'commit0') =20 @@ -1120,13 +1058,11 @@ class TestBlockdevReopen(iotests.QMPTestCase): opts =3D hd_opts(0) opts['backing'] =3D hd_opts(1) opts['backing']['backing'] =3D hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 - result =3D self.vm.qmp('block-commit', conv_keys =3D True, job_id = =3D 'commit0', - device =3D 'hd0', top_node =3D 'hd1', - auto_finalize =3D False) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', conv_keys =3D True, job_id =3D 'commit= 0', + device =3D 'hd0', top_node =3D 'hd1', + auto_finalize =3D False) =20 # We can't remove hd2 while the commit job is ongoing opts['backing']['backing'] =3D None @@ -1146,36 +1082,28 @@ class TestBlockdevReopen(iotests.QMPTestCase): def run_test_iothreads(self, iothread_a, iothread_b, errmsg =3D None, opts_a =3D None, opts_b =3D None): opts =3D opts_a or hd_opts(0) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts) =20 opts2 =3D opts_b or hd_opts(2) - result =3D self.vm.qmp('blockdev-add', conv_keys =3D False, **opts= 2) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', conv_keys =3D False, **opts2) =20 - result =3D self.vm.qmp('object-add', qom_type=3D'iothread', id=3D'= iothread0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', qom_type=3D'iothread', id=3D'iothread0') =20 - result =3D self.vm.qmp('object-add', qom_type=3D'iothread', id=3D'= iothread1') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', qom_type=3D'iothread', id=3D'iothread1') =20 - result =3D self.vm.qmp('device_add', driver=3D'virtio-scsi', id=3D= 'scsi0', - iothread=3Diothread_a) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', driver=3D'virtio-scsi', id=3D'scsi0', + iothread=3Diothread_a) =20 - result =3D self.vm.qmp('device_add', driver=3D'virtio-scsi', id=3D= 'scsi1', - iothread=3Diothread_b) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', driver=3D'virtio-scsi', id=3D'scsi1', + iothread=3Diothread_b) =20 if iothread_a: - result =3D self.vm.qmp('device_add', driver=3D'scsi-hd', drive= =3D'hd0', - share_rw=3DTrue, bus=3D"scsi0.0") - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', driver=3D'scsi-hd', drive=3D'hd0', + share_rw=3DTrue, bus=3D"scsi0.0") =20 if iothread_b: - result =3D self.vm.qmp('device_add', driver=3D'scsi-hd', drive= =3D'hd2', - share_rw=3DTrue, bus=3D"scsi1.0") - self.assert_qmp(result, 'return', {}) + self.vm.cmd('device_add', driver=3D'scsi-hd', drive=3D'hd2', + share_rw=3DTrue, bus=3D"scsi1.0") =20 # Attaching the backing file may or may not work self.reopen(opts, {'backing': 'hd2'}, errmsg) @@ -1204,8 +1132,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): # Create a throttle-group object opts =3D { 'qom-type': 'throttle-group', 'id': 'group0', 'limits': { 'iops-total': 1000 } } - result =3D self.vm.qmp('object-add', conv_keys =3D False, **opts) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('object-add', conv_keys =3D False, **opts) =20 # Options with a throttle filter between format and protocol opts =3D [ diff --git a/tests/qemu-iotests/264 b/tests/qemu-iotests/264 index d44deb673a..c532ccd809 100755 --- a/tests/qemu-iotests/264 +++ b/tests/qemu-iotests/264 @@ -48,18 +48,16 @@ class TestNbdReconnect(iotests.QMPTestCase): """Stat job with nbd target and kill the server""" assert job in ('blockdev-backup', 'blockdev-mirror') with qemu_nbd_popen('-k', nbd_sock, '-f', iotests.imgfmt, disk_b): - result =3D self.vm.qmp('blockdev-add', - {'node-name': 'backup0', - 'driver': 'raw', - 'file': {'driver': 'nbd', - 'server': {'type': 'unix', - 'path': nbd_sock}, - 'reconnect-delay': 10}}) - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp(job, device=3D'drive0', - sync=3D'full', target=3D'backup0', - speed=3D(1 * 1024 * 1024)) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', + {'node-name': 'backup0', + 'driver': 'raw', + 'file': {'driver': 'nbd', + 'server': {'type': 'unix', + 'path': nbd_sock}, + 'reconnect-delay': 10}}) + self.vm.cmd(job, device=3D'drive0', + sync=3D'full', target=3D'backup0', + speed=3D(1 * 1024 * 1024)) =20 # Wait for some progress t =3D 0.0 @@ -77,8 +75,7 @@ class TestNbdReconnect(iotests.QMPTestCase): self.assertTrue(jobs) self.assertTrue(jobs[0]['offset'] < jobs[0]['len']) =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', s= peed=3D0) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', speed=3D0) =20 # Emulate server down time for 1 second time.sleep(1) @@ -91,12 +88,10 @@ class TestNbdReconnect(iotests.QMPTestCase): with qemu_nbd_popen('-k', nbd_sock, '-f', iotests.imgfmt, disk_b): e =3D self.vm.event_wait('BLOCK_JOB_COMPLETED') self.assertEqual(e['data']['offset'], size) - result =3D self.vm.qmp('blockdev-del', node_name=3D'backup0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'backup0') =20 def cancel_job(self): - result =3D self.vm.qmp('block-job-cancel', device=3D'drive0', forc= e=3DTrue) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-cancel', device=3D'drive0', force=3DTrue) =20 start_t =3D time.time() self.vm.event_wait('BLOCK_JOB_CANCELLED') diff --git a/tests/qemu-iotests/281 b/tests/qemu-iotests/281 index 5e1339bd75..f6746a12e8 100755 --- a/tests/qemu-iotests/281 +++ b/tests/qemu-iotests/281 @@ -56,15 +56,13 @@ class TestDirtyBitmapIOThread(iotests.QMPTestCase): os.remove(self.images[name]) =20 def test_add_dirty_bitmap(self): - result =3D self.vm.qmp( + self.vm.cmd( 'block-dirty-bitmap-add', node=3D'drive0', name=3D'bitmap1', persistent=3DTrue, ) =20 - self.assert_qmp(result, 'return', {}) - =20 # Test for RHBZ#1746217 & RHBZ#1773517 class TestNBDMirrorIOThread(iotests.QMPTestCase): @@ -105,23 +103,21 @@ class TestNBDMirrorIOThread(iotests.QMPTestCase): os.remove(self.images[name]) =20 def test_nbd_mirror(self): - result =3D self.vm_tgt.qmp( + self.vm_tgt.cmd( 'nbd-server-start', addr=3D{ 'type': 'unix', 'data': { 'path': self.nbd_sock } } ) - self.assert_qmp(result, 'return', {}) =20 - result =3D self.vm_tgt.qmp( + self.vm_tgt.cmd( 'nbd-server-add', device=3D'drive0', writable=3DTrue ) - self.assert_qmp(result, 'return', {}) =20 - result =3D self.vm_src.qmp( + self.vm_src.cmd( 'drive-mirror', device=3D'drive0', target=3D'nbd+unix:///drive0?socket=3D' + self.nbd_sock, @@ -130,7 +126,6 @@ class TestNBDMirrorIOThread(iotests.QMPTestCase): speed=3D64*1024*1024, job_id=3D'j1' ) - self.assert_qmp(result, 'return', {}) =20 self.vm_src.event_wait(name=3D"BLOCK_JOB_READY") =20 @@ -290,8 +285,7 @@ class TestYieldingAndTimers(iotests.QMPTestCase): # they will remain active, fire later, and then access freed data. # (Or, with "block/nbd: Assert there are no timers when closed" # applied, the assertions added in that patch will fail.) - result =3D self.vm.qmp('blockdev-del', node_name=3D'nbd') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', node_name=3D'nbd') =20 # Give the timers some time to fire (both have a timeout of 1 s). # (Sleeping in an iotest may ring some alarm bells, but note that = if @@ -303,9 +297,8 @@ class TestYieldingAndTimers(iotests.QMPTestCase): def test_yield_in_iothread(self): # Move the NBD node to the I/O thread; the NBD block driver should # attach the connection's QIOChannel to that thread's AioContext, = too - result =3D self.vm.qmp('x-blockdev-set-iothread', - node_name=3D'nbd', iothread=3D'iothr') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('x-blockdev-set-iothread', + node_name=3D'nbd', iothread=3D'iothr') =20 # Do some I/O that will be throttled by the QSD, so that the netwo= rk # connection hopefully will yield here. When it is resumed, it mu= st diff --git a/tests/qemu-iotests/295 b/tests/qemu-iotests/295 index 8ebe31054c..04818af264 100755 --- a/tests/qemu-iotests/295 +++ b/tests/qemu-iotests/295 @@ -57,8 +57,7 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): # create the secrets and load 'em into the VM self.secrets =3D [ Secret(i) for i in range(0, 6) ] for secret in self.secrets: - result =3D self.vm.qmp("object-add", **secret.to_qmp_object()) - self.assert_qmp(result, 'return', {}) + self.vm.cmd("object-add", **secret.to_qmp_object()) =20 if iotests.imgfmt =3D=3D "qcow2": self.pfx =3D "encrypt." @@ -102,7 +101,7 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): } } =20 - result =3D self.vm.qmp('blockdev-add', { + self.vm.cmd('blockdev-add', { 'driver': iotests.imgfmt, 'node-name': id, 'read-only': read_only, @@ -115,12 +114,10 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): } } ) - self.assert_qmp(result, 'return', {}) =20 # close the encrypted block device def closeImageQmp(self, id): - result =3D self.vm.qmp('blockdev-del', {'node-name': id}) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-del', {'node-name': id}) =20 ######################################################################= ##### # add a key to an encrypted block device @@ -159,8 +156,7 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): args['force'] =3D True =20 #TODO: check what jobs return - result =3D self.vm.qmp('x-blockdev-amend', **args) - assert result['return'] =3D=3D {} + self.vm.cmd('x-blockdev-amend', **args) self.vm.run_job('job_add_key') =20 # erase a key from an encrypted block device @@ -193,8 +189,7 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): if force =3D=3D True: args['force'] =3D True =20 - result =3D self.vm.qmp('x-blockdev-amend', **args) - assert result['return'] =3D=3D {} + self.vm.cmd('x-blockdev-amend', **args) self.vm.run_job('job_erase_key') =20 ######################################################################= ##### diff --git a/tests/qemu-iotests/296 b/tests/qemu-iotests/296 index 47d2526b72..2b63cefff0 100755 --- a/tests/qemu-iotests/296 +++ b/tests/qemu-iotests/296 @@ -61,10 +61,8 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): # create the secrets and load 'em into the VMs self.secrets =3D [ Secret(i) for i in range(0, 4) ] for secret in self.secrets: - result =3D self.vm1.qmp("object-add", secret.to_qmp_object()) - self.assert_qmp(result, 'return', {}) - result =3D self.vm2.qmp("object-add", secret.to_qmp_object()) - self.assert_qmp(result, 'return', {}) + self.vm1.cmd("object-add", secret.to_qmp_object()) + self.vm2.cmd("object-add", secret.to_qmp_object()) =20 # test case shutdown def tearDown(self): @@ -132,11 +130,9 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): } =20 if reOpen: - result =3D vm.qmp(command, options=3D[opts]) - self.assert_qmp(result, 'return', {}) + vm.cmd(command, options=3D[opts]) else: - result =3D vm.qmp(command, opts) - self.assert_qmp(result, 'return', {}) + vm.cmd(command, opts) =20 =20 ######################################################################= ##### @@ -154,8 +150,7 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): =20 # close the encrypted block device def closeImageQmp(self, vm, id): - result =3D vm.qmp('blockdev-del', {'node-name': id}) - self.assert_qmp(result, 'return', {}) + vm.cmd('blockdev-del', {'node-name': id}) =20 ######################################################################= ##### =20 diff --git a/tests/qemu-iotests/298 b/tests/qemu-iotests/298 index ad560e2941..4c5348a93b 100755 --- a/tests/qemu-iotests/298 +++ b/tests/qemu-iotests/298 @@ -80,25 +80,23 @@ class TestPreallocateFilter(TestPreallocateBase): def test_external_snapshot(self): self.test_prealloc() =20 - result =3D self.vm.qmp('blockdev-snapshot-sync', node_name=3D'disk= ', - snapshot_file=3Doverlay, - snapshot_node_name=3D'overlay') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-snapshot-sync', node_name=3D'disk', + snapshot_file=3Doverlay, + snapshot_node_name=3D'overlay') =20 # on reopen to r-o base preallocation should be dropped self.check_small() =20 self.vm.hmp_qemu_io('drive0', 'write 1M 1M') =20 - result =3D self.vm.qmp('block-commit', device=3D'overlay') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-commit', device=3D'overlay') self.complete_and_wait() =20 # commit of new megabyte should trigger preallocation self.check_big() =20 def test_reopen_opts(self): - result =3D self.vm.qmp('blockdev-reopen', options=3D[{ + self.vm.cmd('blockdev-reopen', options=3D[{ 'node-name': 'disk', 'driver': iotests.imgfmt, 'file': { @@ -113,7 +111,6 @@ class TestPreallocateFilter(TestPreallocateBase): } } }]) - self.assert_qmp(result, 'return', {}) =20 self.vm.hmp_qemu_io('drive0', 'write 0 1M') self.assertTrue(os.path.getsize(disk) =3D=3D 25 * MiB) diff --git a/tests/qemu-iotests/300 b/tests/qemu-iotests/300 index dbd28384ec..e46616d7b1 100755 --- a/tests/qemu-iotests/300 +++ b/tests/qemu-iotests/300 @@ -50,10 +50,9 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): self.vm_b.add_incoming(f'unix:{mig_sock}') self.vm_b.launch() =20 - result =3D self.vm_a.qmp('block-dirty-bitmap-add', - node=3Dself.src_node_name, - name=3Dself.src_bmap_name) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('block-dirty-bitmap-add', + node=3Dself.src_node_name, + name=3Dself.src_bmap_name) =20 # Dirty some random megabytes for _ in range(9): @@ -69,8 +68,7 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): for name in ('dirty-bitmaps', 'events')] =20 for vm in (self.vm_a, self.vm_b): - result =3D vm.qmp('migrate-set-capabilities', capabilities=3Dc= aps) - self.assert_qmp(result, 'return', {}) + vm.cmd('migrate-set-capabilities', capabilities=3Dcaps) =20 def tearDown(self) -> None: self.vm_a.shutdown() @@ -93,8 +91,7 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): =20 def migrate(self, bitmap_name_valid: bool =3D True, migration_success: bool =3D True) -> None: - result =3D self.vm_a.qmp('migrate', uri=3Df'unix:{mig_sock}') - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate', uri=3Df'unix:{mig_sock}') =20 with iotests.Timeout(5, 'Timeout waiting for migration to complete= '): self.assertEqual(self.vm_a.wait_migration('postmigrate'), @@ -442,10 +439,9 @@ class TestBlockBitmapMappingErrors(TestDirtyBitmapMigr= ation): def test_bitmap_name_too_long(self) -> None: name =3D 'a' * 256 =20 - result =3D self.vm_a.qmp('block-dirty-bitmap-add', - node=3Dself.src_node_name, - name=3Dname) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('block-dirty-bitmap-add', + node=3Dself.src_node_name, + name=3Dname) =20 self.migrate(False, False) =20 @@ -517,22 +513,19 @@ class TestCrossAliasMigration(TestDirtyBitmapMigratio= n): TestDirtyBitmapMigration.setUp(self) =20 # Now create another block device and let both have two bitmaps ea= ch - result =3D self.vm_a.qmp('blockdev-add', - node_name=3D'node-b', driver=3D'null-co') - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('blockdev-add', + node_name=3D'node-b', driver=3D'null-co') =20 - result =3D self.vm_b.qmp('blockdev-add', - node_name=3D'node-a', driver=3D'null-co') - self.assert_qmp(result, 'return', {}) + self.vm_b.cmd('blockdev-add', + node_name=3D'node-a', driver=3D'null-co') =20 bmaps_to_add =3D (('node-a', 'bmap-b'), ('node-b', 'bmap-a'), ('node-b', 'bmap-b')) =20 for (node, bmap) in bmaps_to_add: - result =3D self.vm_a.qmp('block-dirty-bitmap-add', - node=3Dnode, name=3Dbmap) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('block-dirty-bitmap-add', + node=3Dnode, name=3Dbmap) =20 @staticmethod def cross_mapping() -> BlockBitmapMapping: @@ -611,24 +604,21 @@ class TestAliasTransformMigration(TestDirtyBitmapMigr= ation): TestDirtyBitmapMigration.setUp(self) =20 # Now create another block device and let both have two bitmaps ea= ch - result =3D self.vm_a.qmp('blockdev-add', - node_name=3D'node-b', driver=3D'null-co', - read_zeroes=3DFalse) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('blockdev-add', + node_name=3D'node-b', driver=3D'null-co', + read_zeroes=3DFalse) =20 - result =3D self.vm_b.qmp('blockdev-add', - node_name=3D'node-a', driver=3D'null-co', - read_zeroes=3DFalse) - self.assert_qmp(result, 'return', {}) + self.vm_b.cmd('blockdev-add', + node_name=3D'node-a', driver=3D'null-co', + read_zeroes=3DFalse) =20 bmaps_to_add =3D (('node-a', 'bmap-b'), ('node-b', 'bmap-a'), ('node-b', 'bmap-b')) =20 for (node, bmap) in bmaps_to_add: - result =3D self.vm_a.qmp('block-dirty-bitmap-add', - node=3Dnode, name=3Dbmap) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('block-dirty-bitmap-add', + node=3Dnode, name=3Dbmap) =20 @staticmethod def transform_mapping() -> BlockBitmapMapping: diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py index 0add93bc47..7e33522873 100644 --- a/tests/qemu-iotests/iotests.py +++ b/tests/qemu-iotests/iotests.py @@ -1248,8 +1248,7 @@ def assert_json_filename_equal(self, json_filename, r= eference): def cancel_and_wait(self, drive=3D'drive0', force=3DFalse, resume=3DFalse, wait=3D60.0): '''Cancel a block job and wait for it to finish, returning the eve= nt''' - result =3D self.vm.qmp('block-job-cancel', device=3Ddrive, force= =3Dforce) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-cancel', device=3Ddrive, force=3Dforce) =20 if resume: self.vm.resume_drive(drive) @@ -1311,8 +1310,7 @@ def complete_and_wait(self, drive=3D'drive0', wait_re= ady=3DTrue, if wait_ready: self.wait_ready(drive=3Ddrive) =20 - result =3D self.vm.qmp('block-job-complete', device=3Ddrive) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-complete', device=3Ddrive) =20 event =3D self.wait_until_completed(drive=3Ddrive, error=3Dcomplet= ion_error) self.assertTrue(event['data']['type'] in ['mirror', 'commit']) @@ -1331,8 +1329,7 @@ def pause_wait(self, job_id=3D'job0'): assert found =20 def pause_job(self, job_id=3D'job0', wait=3DTrue): - result =3D self.vm.qmp('block-job-pause', device=3Djob_id) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-pause', device=3Djob_id) if wait: self.pause_wait(job_id) =20 diff --git a/tests/qemu-iotests/tests/export-incoming-iothread b/tests/qemu= -iotests/tests/export-incoming-iothread index 7679e49103..d36d6194e0 100755 --- a/tests/qemu-iotests/tests/export-incoming-iothread +++ b/tests/qemu-iotests/tests/export-incoming-iothread @@ -55,7 +55,7 @@ class TestExportIncomingIothread(iotests.QMPTestCase): os.remove(test_img) =20 def test_export_add(self): - result =3D self.vm.qmp('nbd-server-start', { + self.vm.cmd('nbd-server-start', { 'addr': { 'type': 'unix', 'data': { @@ -63,16 +63,14 @@ class TestExportIncomingIothread(iotests.QMPTestCase): } } }) - self.assert_qmp(result, 'return', {}) =20 # Regression test for issue 945: This should not fail an assertion - result =3D self.vm.qmp('block-export-add', { + self.vm.cmd('block-export-add', { 'type': 'nbd', 'id': 'exp0', 'node-name': node_name, 'iothread': iothread_id }) - self.assert_qmp(result, 'return', {}) =20 =20 if __name__ =3D=3D '__main__': diff --git a/tests/qemu-iotests/tests/graph-changes-while-io b/tests/qemu-i= otests/tests/graph-changes-while-io index 7664f33689..b35b8aac4b 100755 --- a/tests/qemu-iotests/tests/graph-changes-while-io +++ b/tests/qemu-iotests/tests/graph-changes-while-io @@ -66,7 +66,7 @@ class TestGraphChangesWhileIO(QMPTestCase): # While qemu-img bench is running, repeatedly add and remove an # overlay to/from node0 while bench_thr.is_alive(): - result =3D self.qsd.qmp('blockdev-add', { + self.qsd.cmd('blockdev-add', { 'driver': imgfmt, 'node-name': 'overlay', 'backing': 'node0', @@ -75,12 +75,10 @@ class TestGraphChangesWhileIO(QMPTestCase): 'filename': top } }) - self.assert_qmp(result, 'return', {}) =20 - result =3D self.qsd.qmp('blockdev-del', { + self.qsd.cmd('blockdev-del', { 'node-name': 'overlay' }) - self.assert_qmp(result, 'return', {}) =20 bench_thr.join() =20 diff --git a/tests/qemu-iotests/tests/image-fleecing b/tests/qemu-iotests/t= ests/image-fleecing index f6e449d071..5e3b2c7e46 100755 --- a/tests/qemu-iotests/tests/image-fleecing +++ b/tests/qemu-iotests/tests/image-fleecing @@ -213,8 +213,7 @@ def do_test(vm, use_cbw, use_snapshot_access_filter, ba= se_img_path, result =3D vm.qmp('query-block-jobs') assert len(result['return']) =3D=3D 1 =20 - result =3D vm.qmp('block-job-set-speed', device=3D'push-backup', s= peed=3D0) - assert result =3D=3D {'return': {}} + vm.cmd('block-job-set-speed', device=3D'push-backup', speed=3D0) =20 log(vm.event_wait(name=3D'BLOCK_JOB_COMPLETED', match=3D{'data': {'device': 'push-backup'}}), diff --git a/tests/qemu-iotests/tests/migrate-bitmaps-postcopy-test b/tests= /qemu-iotests/tests/migrate-bitmaps-postcopy-test index dda55fad28..c519e6db8c 100755 --- a/tests/qemu-iotests/tests/migrate-bitmaps-postcopy-test +++ b/tests/qemu-iotests/tests/migrate-bitmaps-postcopy-test @@ -118,11 +118,10 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTes= tCase): def start_postcopy(self): """ Run migration until RESUME event on target. Return this event.= """ for i in range(nb_bitmaps): - result =3D self.vm_a.qmp('block-dirty-bitmap-add', node=3D'dri= ve0', - name=3D'bitmap{}'.format(i), - granularity=3Dgranularity, - persistent=3DTrue) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('block-dirty-bitmap-add', node=3D'drive0', + name=3D'bitmap{}'.format(i), + granularity=3Dgranularity, + persistent=3DTrue) =20 result =3D self.vm_a.qmp('x-debug-block-dirty-bitmap-sha256', node=3D'drive0', name=3D'bitmap0') @@ -140,9 +139,8 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestC= ase): # We want to calculate resulting sha256. Do it in bitmap0, so, dis= able # other bitmaps for i in range(1, nb_bitmaps): - result =3D self.vm_a.qmp('block-dirty-bitmap-disable', node=3D= 'drive0', - name=3D'bitmap{}'.format(i)) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('block-dirty-bitmap-disable', node=3D'drive0', + name=3D'bitmap{}'.format(i)) =20 apply_discards(self.vm_a, discards2) =20 @@ -152,24 +150,19 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTes= tCase): =20 # Now, enable some bitmaps, to be updated during migration for i in range(2, nb_bitmaps, 2): - result =3D self.vm_a.qmp('block-dirty-bitmap-enable', node=3D'= drive0', - name=3D'bitmap{}'.format(i)) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('block-dirty-bitmap-enable', node=3D'drive0', + name=3D'bitmap{}'.format(i)) =20 caps =3D [{'capability': 'dirty-bitmaps', 'state': True}, {'capability': 'events', 'state': True}] =20 - result =3D self.vm_a.qmp('migrate-set-capabilities', capabilities= =3Dcaps) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate-set-capabilities', capabilities=3Dcaps) =20 - result =3D self.vm_b.qmp('migrate-set-capabilities', capabilities= =3Dcaps) - self.assert_qmp(result, 'return', {}) + self.vm_b.cmd('migrate-set-capabilities', capabilities=3Dcaps) =20 - result =3D self.vm_a.qmp('migrate', uri=3D'exec:cat>' + fifo) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate', uri=3D'exec:cat>' + fifo) =20 - result =3D self.vm_a.qmp('migrate-start-postcopy') - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate-start-postcopy') =20 event_resume =3D self.vm_b.event_wait('RESUME') self.vm_b_events.append(event_resume) diff --git a/tests/qemu-iotests/tests/migrate-bitmaps-test b/tests/qemu-iot= ests/tests/migrate-bitmaps-test index eebb256485..f98e721e97 100755 --- a/tests/qemu-iotests/tests/migrate-bitmaps-test +++ b/tests/qemu-iotests/tests/migrate-bitmaps-test @@ -67,8 +67,7 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): if persistent: params['persistent'] =3D True =20 - result =3D vm.qmp('block-dirty-bitmap-add', params) - self.assert_qmp(result, 'return', {}) + vm.cmd('block-dirty-bitmap-add', params) =20 def check_bitmap(self, vm, sha256): result =3D vm.qmp('x-debug-block-dirty-bitmap-sha256', @@ -91,17 +90,15 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): if migrate_bitmaps: mig_caps.append({'capability': 'dirty-bitmaps', 'state': True}) =20 - result =3D self.vm_a.qmp('migrate-set-capabilities', - capabilities=3Dmig_caps) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate-set-capabilities', + capabilities=3Dmig_caps) =20 self.add_bitmap(self.vm_a, granularity, persistent) for r in regions: self.vm_a.hmp_qemu_io('drive0', 'write %d %d' % r) sha256 =3D get_bitmap_hash(self.vm_a) =20 - result =3D self.vm_a.qmp('migrate', uri=3Dmig_cmd) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate', uri=3Dmig_cmd) while True: event =3D self.vm_a.event_wait('MIGRATION') if event['data']['status'] =3D=3D 'completed': @@ -115,8 +112,7 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): removed =3D (not migrate_bitmaps) and persistent self.check_bitmap(self.vm_a, False if removed else sha256) =20 - result =3D self.vm_a.qmp('cont') - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('cont') =20 # test that bitmap is still here after invalidation self.check_bitmap(self.vm_a, sha256) @@ -159,9 +155,8 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): if online: os.mkfifo(mig_file) self.vm_b.launch() - result =3D self.vm_b.qmp('migrate-set-capabilities', - capabilities=3Dmig_caps) - self.assert_qmp(result, 'return', {}) + self.vm_b.cmd('migrate-set-capabilities', + capabilities=3Dmig_caps) =20 self.add_bitmap(self.vm_a, granularity, persistent) for r in regions: @@ -172,12 +167,10 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): self.vm_a.shutdown() self.vm_a.launch() =20 - result =3D self.vm_a.qmp('migrate-set-capabilities', - capabilities=3Dmig_caps) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate-set-capabilities', + capabilities=3Dmig_caps) =20 - result =3D self.vm_a.qmp('migrate', uri=3Dmig_cmd) - self.assert_qmp(result, 'return', {}) + self.vm_a.cmd('migrate', uri=3Dmig_cmd) while True: event =3D self.vm_a.event_wait('MIGRATION') if event['data']['status'] =3D=3D 'completed': @@ -186,11 +179,9 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): if not online: self.vm_a.shutdown() self.vm_b.launch() - result =3D self.vm_b.qmp('migrate-set-capabilities', - capabilities=3Dmig_caps) - self.assert_qmp(result, 'return', {}) - result =3D self.vm_b.qmp('migrate-incoming', uri=3Dincoming_cm= d) - self.assert_qmp(result, 'return', {}) + self.vm_b.cmd('migrate-set-capabilities', + capabilities=3Dmig_caps) + self.vm_b.cmd('migrate-incoming', uri=3Dincoming_cmd) =20 while True: event =3D self.vm_b.event_wait('MIGRATION') @@ -256,8 +247,7 @@ class TestDirtyBitmapBackingMigration(iotests.QMPTestCa= se): self.vm =3D iotests.VM() self.vm.launch() =20 - result =3D self.vm.qmp('blockdev-add', blockdev) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-add', blockdev) =20 # Check that the bitmaps are there nodes =3D self.vm.qmp('query-named-block-nodes', flat=3DTrue)['ret= urn'] @@ -266,8 +256,7 @@ class TestDirtyBitmapBackingMigration(iotests.QMPTestCa= se): self.assert_qmp(node, 'dirty-bitmaps[0]/name', 'bmap0') =20 caps =3D [{'capability': 'events', 'state': True}] - result =3D self.vm.qmp('migrate-set-capabilities', capabilities=3D= caps) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('migrate-set-capabilities', capabilities=3Dcaps) =20 def tearDown(self): self.vm.shutdown() @@ -278,14 +267,12 @@ class TestDirtyBitmapBackingMigration(iotests.QMPTest= Case): """ Continue the source after migration. """ - result =3D self.vm.qmp('migrate', uri=3D'exec: cat > /dev/null') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('migrate', uri=3D'exec: cat > /dev/null') =20 with Timeout(10, 'Migration timeout'): self.vm.wait_migration('postmigrate') =20 - result =3D self.vm.qmp('cont') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('cont') =20 =20 def main() -> None: diff --git a/tests/qemu-iotests/tests/migrate-during-backup b/tests/qemu-io= tests/tests/migrate-during-backup index 34103229ee..afb2277896 100755 --- a/tests/qemu-iotests/tests/migrate-during-backup +++ b/tests/qemu-iotests/tests/migrate-during-backup @@ -43,7 +43,7 @@ class TestMigrateDuringBackup(iotests.QMPTestCase): =20 self.vm =3D iotests.VM().add_drive(disk_a) self.vm.launch() - result =3D self.vm.qmp('blockdev-add', { + self.vm.cmd('blockdev-add', { 'node-name': 'target', 'driver': iotests.imgfmt, 'file': { @@ -51,26 +51,21 @@ class TestMigrateDuringBackup(iotests.QMPTestCase): 'filename': disk_b } }) - self.assert_qmp(result, 'return', {}) =20 def test_migrate(self): - result =3D self.vm.qmp('blockdev-backup', device=3D'drive0', - target=3D'target', sync=3D'full', - speed=3D1, x_perf=3D{ - 'max-workers': 1, - 'max-chunk': 64 * 1024 - }) - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('job-pause', id=3D'drive0') - self.assert_qmp(result, 'return', {}) - - result =3D self.vm.qmp('migrate-set-capabilities', - capabilities=3D[{'capability': 'events', - 'state': True}]) - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('migrate', uri=3Dmig_cmd) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-backup', device=3D'drive0', + target=3D'target', sync=3D'full', + speed=3D1, x_perf=3D{ + 'max-workers': 1, + 'max-chunk': 64 * 1024 + }) + + self.vm.cmd('job-pause', id=3D'drive0') + + self.vm.cmd('migrate-set-capabilities', + capabilities=3D[{'capability': 'events', + 'state': True}]) + self.vm.cmd('migrate', uri=3Dmig_cmd) =20 e =3D self.vm.events_wait((('MIGRATION', {'data': {'status': 'completed'}}), @@ -80,11 +75,9 @@ class TestMigrateDuringBackup(iotests.QMPTestCase): # Don't assert that e is 'failed' now: this way we'll miss # possible crash when backup continues :) =20 - result =3D self.vm.qmp('block-job-set-speed', device=3D'drive0', - speed=3D0) - self.assert_qmp(result, 'return', {}) - result =3D self.vm.qmp('job-resume', id=3D'drive0') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-set-speed', device=3D'drive0', + speed=3D0) + self.vm.cmd('job-resume', id=3D'drive0') =20 # For future: if something changes so that both migration # and backup pass, let's not miss that moment, as it may diff --git a/tests/qemu-iotests/tests/migration-permissions b/tests/qemu-io= tests/tests/migration-permissions index 4e1da369c9..0deaad2d3a 100755 --- a/tests/qemu-iotests/tests/migration-permissions +++ b/tests/qemu-iotests/tests/migration-permissions @@ -47,11 +47,10 @@ class TestMigrationPermissions(iotests.QMPTestCase): =20 vms[i].launch() =20 - result =3D vms[i].qmp('migrate-set-capabilities', - capabilities=3D[ - {'capability': 'events', 'state': True} - ]) - self.assert_qmp(result, 'return', {}) + vms[i].cmd('migrate-set-capabilities', + capabilities=3D[ + {'capability': 'events', 'state': True} + ]) =20 self.vm_s =3D vms[0] self.vm_d =3D vms[1] diff --git a/tests/qemu-iotests/tests/mirror-ready-cancel-error b/tests/qem= u-iotests/tests/mirror-ready-cancel-error index a59e245659..ed2e46447e 100755 --- a/tests/qemu-iotests/tests/mirror-ready-cancel-error +++ b/tests/qemu-iotests/tests/mirror-ready-cancel-error @@ -48,51 +48,48 @@ class TestMirrorReadyCancelError(iotests.QMPTestCase): os.remove(target) =20 def add_blockdevs(self, once: bool) -> None: - res =3D self.vm.qmp('blockdev-add', - {'node-name': 'source', - 'driver': iotests.imgfmt, - 'file': { - 'driver': 'file', - 'filename': source - }}) - self.assert_qmp(res, 'return', {}) + self.vm.cmd('blockdev-add', + {'node-name': 'source', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': source + }}) =20 # blkdebug notes: # Enter state 2 on the first flush, which happens before the # job enters the READY state. The second flush will happen # when the job is about to complete, and we want that one to # fail. - res =3D self.vm.qmp('blockdev-add', - {'node-name': 'target', - 'driver': iotests.imgfmt, - 'file': { - 'driver': 'blkdebug', - 'image': { - 'driver': 'file', - 'filename': target - }, - 'set-state': [{ - 'event': 'flush_to_disk', - 'state': 1, - 'new_state': 2 - }], - 'inject-error': [{ - 'event': 'flush_to_disk', - 'once': once, - 'immediately': True, - 'state': 2 - }]}}) - self.assert_qmp(res, 'return', {}) + self.vm.cmd('blockdev-add', + {'node-name': 'target', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'blkdebug', + 'image': { + 'driver': 'file', + 'filename': target + }, + 'set-state': [{ + 'event': 'flush_to_disk', + 'state': 1, + 'new_state': 2 + }], + 'inject-error': [{ + 'event': 'flush_to_disk', + 'once': once, + 'immediately': True, + 'state': 2 + }]}}) =20 def start_mirror(self) -> None: - res =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'source', - target=3D'target', - filter_node_name=3D'mirror-top', - sync=3D'full', - on_target_error=3D'stop') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'source', + target=3D'target', + filter_node_name=3D'mirror-top', + sync=3D'full', + on_target_error=3D'stop') =20 def cancel_mirror_with_error(self) -> None: self.vm.event_wait('BLOCK_JOB_READY') @@ -107,8 +104,7 @@ class TestMirrorReadyCancelError(iotests.QMPTestCase): while self.vm.event_wait('JOB_STATUS_CHANGE', timeout=3D0.0) is no= t None: pass =20 - res =3D self.vm.qmp('block-job-cancel', device=3D'mirror') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-job-cancel', device=3D'mirror') =20 self.vm.event_wait('BLOCK_JOB_ERROR') =20 diff --git a/tests/qemu-iotests/tests/mirror-top-perms b/tests/qemu-iotests= /tests/mirror-top-perms index 8bca592708..fab9907e92 100755 --- a/tests/qemu-iotests/tests/mirror-top-perms +++ b/tests/qemu-iotests/tests/mirror-top-perms @@ -78,12 +78,11 @@ class TestMirrorTopPerms(iotests.QMPTestCase): difficult to let some other qemu process open the image.) """ =20 - result =3D self.vm.qmp('blockdev-mirror', - job_id=3D'mirror', - device=3D'drive0', - target=3D'null', - sync=3D'full') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('blockdev-mirror', + job_id=3D'mirror', + device=3D'drive0', + target=3D'null', + sync=3D'full') =20 self.vm.event_wait('BLOCK_JOB_READY') =20 @@ -105,9 +104,8 @@ class TestMirrorTopPerms(iotests.QMPTestCase): except machine.VMLaunchFailure as exc: assert 'Is another process using the image' in exc.output =20 - result =3D self.vm.qmp('block-job-cancel', - device=3D'mirror') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-job-cancel', + device=3D'mirror') =20 self.vm.event_wait('BLOCK_JOB_COMPLETED') =20 diff --git a/tests/qemu-iotests/tests/nbd-multiconn b/tests/qemu-iotests/te= sts/nbd-multiconn index b121f2e363..82b5fd79dd 100755 --- a/tests/qemu-iotests/tests/nbd-multiconn +++ b/tests/qemu-iotests/tests/nbd-multiconn @@ -46,12 +46,11 @@ class TestNbdMulticonn(iotests.QMPTestCase): =20 self.vm =3D iotests.VM() self.vm.launch() - result =3D self.vm.qmp('blockdev-add', { + self.vm.cmd('blockdev-add', { 'driver': 'qcow2', 'node-name': 'n', 'file': {'driver': 'file', 'filename': disk} }) - self.assert_qmp(result, 'return', {}) =20 def tearDown(self): self.vm.shutdown() @@ -72,12 +71,10 @@ class TestNbdMulticonn(iotests.QMPTestCase): if max_connections is not None: args['max-connections'] =3D max_connections =20 - result =3D self.vm.qmp('nbd-server-start', args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('nbd-server-start', args) yield =20 - result =3D self.vm.qmp('nbd-server-stop') - self.assert_qmp(result, 'return', {}) + self.vm.cmd('nbd-server-stop') =20 def add_export(self, name, writable=3DNone): args =3D { @@ -89,8 +86,7 @@ class TestNbdMulticonn(iotests.QMPTestCase): if writable is not None: args['writable'] =3D writable =20 - result =3D self.vm.qmp('block-export-add', args) - self.assert_qmp(result, 'return', {}) + self.vm.cmd('block-export-add', args) =20 def test_default_settings(self): with self.run_server(): diff --git a/tests/qemu-iotests/tests/reopen-file b/tests/qemu-iotests/test= s/reopen-file index 8590a94d53..5a50794ffc 100755 --- a/tests/qemu-iotests/tests/reopen-file +++ b/tests/qemu-iotests/tests/reopen-file @@ -64,12 +64,11 @@ class TestReopenFile(QMPTestCase): self.fail('qemu-io pattern verification failed') =20 def test_reopen_file(self) -> None: - result =3D self.vm.qmp('blockdev-reopen', options=3D[{ + self.vm.cmd('blockdev-reopen', options=3D[{ 'driver': imgfmt, 'node-name': 'format', 'file': 'raw' }]) - self.assert_qmp(result, 'return', {}) =20 # Do some I/O to the image to see whether it still works # (Pattern verification will be checked by tearDown()) diff --git a/tests/qemu-iotests/tests/stream-error-on-reset b/tests/qemu-io= tests/tests/stream-error-on-reset index 5a8c3a9e8d..b60aabb68e 100755 --- a/tests/qemu-iotests/tests/stream-error-on-reset +++ b/tests/qemu-iotests/tests/stream-error-on-reset @@ -115,8 +115,7 @@ class TestStreamErrorOnReset(QMPTestCase): # Launch a stream job, which will take at least a second to # complete, because the base image is throttled (so we can # get in between it having started and it having completed) - res =3D self.vm.qmp('block-stream', job_id=3D'stream', device=3D't= op') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('block-stream', job_id=3D'stream', device=3D'top') =20 while True: ev =3D self.vm.event_wait('JOB_STATUS_CHANGE') @@ -125,8 +124,7 @@ class TestStreamErrorOnReset(QMPTestCase): # forces the virtio-scsi device to be reset, thus draining # the stream job, and making it complete. Completing # inside of that drain should not result in a segfault. - res =3D self.vm.qmp('system_reset') - self.assert_qmp(res, 'return', {}) + self.vm.cmd('system_reset') elif ev['data']['status'] =3D=3D 'null': # The test is done once the job is gone break --=20 2.34.1