Lines Matching full:self
49 def setUp(self): argument
52 self.vm = iotests.VM()
53 self.vm.add_drive('blkdebug::' + test_img, 'node-name=source')
54 self.vm.add_drive(blockdev_target_img, 'node-name=target',
57 self.vm.add_drive(None, 'media=cdrom', 'ide')
58 self.vm.launch()
60 def tearDown(self): argument
61 self.vm.shutdown()
68 def do_test_cancel(self, cmd, target): argument
69 self.assert_no_active_block_jobs()
71 self.vm.pause_drive('drive0')
72 self.vm.cmd(cmd, device='drive0', target=target, sync='full')
74 event = self.cancel_and_wait(resume=True)
75 self.assert_qmp(event, 'data/type', 'backup')
77 def test_cancel_drive_backup(self): argument
78 self.do_test_cancel('drive-backup', target_img)
80 def test_cancel_blockdev_backup(self): argument
81 self.do_test_cancel('blockdev-backup', 'drive1')
83 def do_test_pause(self, cmd, target, image): argument
84 self.assert_no_active_block_jobs()
86 self.vm.pause_drive('drive0')
87 self.vm.cmd(cmd, device='drive0',
90 self.pause_job('drive0', wait=False)
91 self.vm.resume_drive('drive0')
92 self.pause_wait('drive0')
94 result = self.vm.qmp('query-block-jobs')
95 offset = self.dictpath(result, 'return[0]/offset')
98 result = self.vm.qmp('query-block-jobs')
99 self.assert_qmp(result, 'return[0]/offset', offset)
101 self.vm.cmd('block-job-resume', device='drive0')
103 self.wait_until_completed()
105 self.vm.shutdown()
106 self.assertTrue(iotests.compare_images(test_img, image),
109 def test_pause_drive_backup(self): argument
110 self.do_test_pause('drive-backup', target_img, target_img)
112 def test_pause_blockdev_backup(self): argument
113 self.do_test_pause('blockdev-backup', 'drive1', blockdev_target_img)
115 def do_test_resize_blockdev_backup(self, device, node): argument
117 result = self.vm.qmp('block_resize', device=device, size=65536)
118 self.assert_qmp(result, 'error/class', 'GenericError')
120 result = self.vm.qmp('block_resize', node_name=node, size=65536)
121 self.assert_qmp(result, 'error/class', 'GenericError')
123 self.vm.cmd('blockdev-backup', job_id='job0', device='drive0',
127 self.vm.run_job('job0', auto_finalize=False, pre_finalize=pre_finalize)
129 def test_source_resize_blockdev_backup(self): argument
130 self.do_test_resize_blockdev_backup('drive0', 'source')
132 def test_target_resize_blockdev_backup(self): argument
133 self.do_test_resize_blockdev_backup('drive1', 'target')
135 def do_test_target_size(self, size): argument
136 self.vm.cmd('block_resize', device='drive1', size=size)
138 result = self.vm.qmp('blockdev-backup', job_id='job0', device='drive0',
140 self.assert_qmp(result, 'error/class', 'GenericError')
142 def test_small_target(self): argument
143 self.do_test_target_size(image_len // 2)
145 def test_large_target(self): argument
146 self.do_test_target_size(image_len * 2)
148 def test_medium_not_found(self): argument
152 result = self.vm.qmp('drive-backup', device='drive2', # CD-ROM
154 self.assert_qmp(result, 'error/class', 'GenericError')
156 def test_medium_not_found_blockdev_backup(self): argument
160 result = self.vm.qmp('blockdev-backup', device='drive2', # CD-ROM
162 self.assert_qmp(result, 'error/class', 'GenericError')
164 def test_image_not_found(self): argument
165 result = self.vm.qmp('drive-backup', device='drive0',
167 self.assert_qmp(result, 'error/class', 'GenericError')
169 def test_invalid_format(self): argument
170 result = self.vm.qmp('drive-backup', device='drive0',
173 self.assert_qmp(result, 'error/class', 'GenericError')
175 def do_test_device_not_found(self, cmd, **args): argument
176 result = self.vm.qmp(cmd, **args)
177 self.assert_qmp(result, 'error/class', 'GenericError')
179 def test_device_not_found(self): argument
180 self.do_test_device_not_found('drive-backup', device='nonexistent',
183 self.do_test_device_not_found('blockdev-backup', device='nonexistent',
186 self.do_test_device_not_found('blockdev-backup', device='drive0',
189 self.do_test_device_not_found('blockdev-backup', device='nonexistent',
192 def test_target_is_source(self): argument
193 result = self.vm.qmp('blockdev-backup', device='drive0',
195 self.assert_qmp(result, 'error/class', 'GenericError')
198 def setUp(self): argument
201 self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
202 self.vm.add_drive(blockdev_target_img, interface="none")
203 self.vm.launch()
205 def tearDown(self): argument
206 self.vm.shutdown()
213 def do_test_set_speed(self, cmd, target): argument
214 self.assert_no_active_block_jobs()
216 self.vm.pause_drive('drive0')
217 self.vm.cmd(cmd, device='drive0', target=target, sync='full')
220 result = self.vm.qmp('query-block-jobs')
221 self.assert_qmp(result, 'return[0]/device', 'drive0')
222 self.assert_qmp(result, 'return[0]/speed', 0)
224 self.vm.cmd('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
227 result = self.vm.qmp('query-block-jobs')
228 self.assert_qmp(result, 'return[0]/device', 'drive0')
229 self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
231 event = self.cancel_and_wait(resume=True)
232 self.assert_qmp(event, 'data/type', 'backup')
235 self.vm.pause_drive('drive0')
236 self.vm.cmd(cmd, device='drive0',
239 result = self.vm.qmp('query-block-jobs')
240 self.assert_qmp(result, 'return[0]/device', 'drive0')
241 self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
243 event = self.cancel_and_wait(resume=True)
244 self.assert_qmp(event, 'data/type', 'backup')
246 def test_set_speed_drive_backup(self): argument
247 self.do_test_set_speed('drive-backup', target_img)
249 def test_set_speed_blockdev_backup(self): argument
250 self.do_test_set_speed('blockdev-backup', 'drive1')
252 def do_test_set_speed_invalid(self, cmd, target): argument
253 self.assert_no_active_block_jobs()
255 result = self.vm.qmp(cmd, device='drive0',
257 self.assert_qmp(result, 'error/class', 'GenericError')
259 self.assert_no_active_block_jobs()
261 self.vm.pause_drive('drive0')
262 self.vm.cmd(cmd, device='drive0',
265 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
266 self.assert_qmp(result, 'error/class', 'GenericError')
268 event = self.cancel_and_wait(resume=True)
269 self.assert_qmp(event, 'data/type', 'backup')
271 def test_set_speed_invalid_drive_backup(self): argument
272 self.do_test_set_speed_invalid('drive-backup', target_img)
274 def test_set_speed_invalid_blockdev_backup(self): argument
275 self.do_test_set_speed_invalid('blockdev-backup', 'drive1')
280 def setUp(self): argument
283 self.vm = iotests.VM().add_drive(test_img)
284 self.vm.add_drive(blockdev_target_img, interface="none")
286 self.vm.add_drive(None, 'media=cdrom', 'ide')
287 self.vm.launch()
289 def tearDown(self): argument
290 self.vm.shutdown()
297 def do_test_cancel(self, cmd, target): argument
298 self.assert_no_active_block_jobs()
300 self.vm.cmd('transaction', actions=[{
309 event = self.cancel_and_wait()
310 self.assert_qmp(event, 'data/type', 'backup')
312 def test_cancel_drive_backup(self): argument
313 self.do_test_cancel('drive-backup', target_img)
315 def test_cancel_blockdev_backup(self): argument
316 self.do_test_cancel('blockdev-backup', 'drive1')
318 def do_test_pause(self, cmd, target, image): argument
319 self.assert_no_active_block_jobs()
321 self.vm.cmd('transaction', actions=[{
330 self.pause_job('drive0', wait=False)
332 self.vm.cmd('block-job-set-speed', device='drive0', speed=0)
334 self.pause_wait('drive0')
336 result = self.vm.qmp('query-block-jobs')
337 offset = self.dictpath(result, 'return[0]/offset')
340 result = self.vm.qmp('query-block-jobs')
341 self.assert_qmp(result, 'return[0]/offset', offset)
343 self.vm.cmd('block-job-resume', device='drive0')
345 self.wait_until_completed()
347 self.vm.shutdown()
348 self.assertTrue(iotests.compare_images(test_img, image),
351 def test_pause_drive_backup(self): argument
352 self.do_test_pause('drive-backup', target_img, target_img)
354 def test_pause_blockdev_backup(self): argument
355 self.do_test_pause('blockdev-backup', 'drive1', blockdev_target_img)
357 def do_test_medium_not_found(self, cmd, target): argument
361 result = self.vm.qmp('transaction', actions=[{
368 self.assert_qmp(result, 'error/class', 'GenericError')
370 def test_medium_not_found_drive_backup(self): argument
371 self.do_test_medium_not_found('drive-backup', target_img)
373 def test_medium_not_found_blockdev_backup(self): argument
374 self.do_test_medium_not_found('blockdev-backup', 'drive1')
376 def test_image_not_found(self): argument
377 result = self.vm.qmp('transaction', actions=[{
385 self.assert_qmp(result, 'error/class', 'GenericError')
387 def test_device_not_found(self): argument
388 result = self.vm.qmp('transaction', actions=[{
396 self.assert_qmp(result, 'error/class', 'GenericError')
398 result = self.vm.qmp('transaction', actions=[{
405 self.assert_qmp(result, 'error/class', 'GenericError')
407 result = self.vm.qmp('transaction', actions=[{
414 self.assert_qmp(result, 'error/class', 'GenericError')
416 result = self.vm.qmp('transaction', actions=[{
423 self.assert_qmp(result, 'error/class', 'GenericError')
425 def test_target_is_source(self): argument
426 result = self.vm.qmp('transaction', actions=[{
433 self.assert_qmp(result, 'error/class', 'GenericError')
435 def test_abort(self): argument
436 result = self.vm.qmp('transaction', actions=[{
447 self.assert_qmp(result, 'error/class', 'GenericError')
448 self.assert_no_active_block_jobs()
450 result = self.vm.qmp('transaction', actions=[{
460 self.assert_qmp(result, 'error/class', 'GenericError')
461 self.assert_no_active_block_jobs()
463 result = self.vm.qmp('transaction', actions=[{
473 self.assert_qmp(result, 'error/class', 'GenericError')
474 self.assert_no_active_block_jobs()
481 def tearDown(self): argument
482 self.vm.shutdown()
489 def do_prepare_drives(self, attach_target): argument
490 self.vm = iotests.VM().add_drive('blkdebug::' + test_img,
491 opts=self.target_fmt['drive-opts'])
493 qemu_img('create', '-f', self.target_fmt['type'], blockdev_target_img,
494 str(self.image_len), *self.target_fmt['args'])
496 self.vm.add_drive(blockdev_target_img,
497 img_format=self.target_fmt['type'],
499 opts=self.target_fmt['drive-opts'])
501 self.vm.launch()
503 def do_test_compress_complete(self, cmd, attach_target, **args): argument
504 self.do_prepare_drives(attach_target)
506 self.assert_no_active_block_jobs()
508 self.vm.cmd(cmd, device='drive0', sync='full', compress=True, **args)
510 self.wait_until_completed()
512 self.vm.shutdown()
513 self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
515 self.target_fmt['type']),
518 def test_complete_compress_drive_backup(self): argument
519 self.do_test_compress_complete('drive-backup', False,
523 def test_complete_compress_blockdev_backup(self): argument
524 self.do_test_compress_complete('blockdev-backup',
527 def do_test_compress_cancel(self, cmd, attach_target, **args): argument
528 self.do_prepare_drives(attach_target)
530 self.assert_no_active_block_jobs()
532 self.vm.pause_drive('drive0')
533 self.vm.cmd(cmd, device='drive0', sync='full', compress=True, **args)
535 event = self.cancel_and_wait(resume=True)
536 self.assert_qmp(event, 'data/type', 'backup')
538 self.vm.shutdown()
540 def test_compress_cancel_drive_backup(self): argument
541 self.do_test_compress_cancel('drive-backup', False,
545 def test_compress_cancel_blockdev_backup(self): argument
546 self.do_test_compress_cancel('blockdev-backup', True,
549 def do_test_compress_pause(self, cmd, attach_target, **args): argument
550 self.do_prepare_drives(attach_target)
552 self.assert_no_active_block_jobs()
554 self.vm.pause_drive('drive0')
555 self.vm.cmd(cmd, device='drive0', sync='full', compress=True, **args)
557 self.pause_job('drive0', wait=False)
558 self.vm.resume_drive('drive0')
559 self.pause_wait('drive0')
561 result = self.vm.qmp('query-block-jobs')
562 offset = self.dictpath(result, 'return[0]/offset')
565 result = self.vm.qmp('query-block-jobs')
566 self.assert_qmp(result, 'return[0]/offset', offset)
568 self.vm.cmd('block-job-resume', device='drive0')
570 self.wait_until_completed()
572 self.vm.shutdown()
573 self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
575 self.target_fmt['type']),
578 def test_compress_pause_drive_backup(self): argument
579 self.do_test_compress_pause('drive-backup', False,
583 def test_compress_pause_blockdev_backup(self): argument
584 self.do_test_compress_pause('blockdev-backup', True,
593 def setUp(self): argument