← Back to branch summary

~ubuntu-branches/ubuntu/vivid/qemu-linaro/vivid

« back to all changes in this revision

Viewing changes to tests/qemu-iotests/030

  • Committer: Ricardo Salveti de Araujo
  • Date: 2012-09-20 18:39:31 UTC
  • mfrom: (12922.1.2 qemu-linaro)
  • Revision ID: ricardo.salveti@linaro.org-20120920183931-sp3cg6kpdl8dmwo9
* New upstream release.
  - support emulated systems with more than 2G of memory. (LP: #1030588)
* Drop powerpc-missing-include.patch - merged upstream.
* Update debian/control:
  - drop perl build dependency.
  - add libfdt-dev build dependency.
* Update debian/qemu-keymaps.install file.
* Update debian/rules:
  - update QEMU_CPU for ARM architecture: armv4l -> armv7l.
  - update conf_audio_drv: default to PulseAudio since PA is the default on
    Ubuntu.
  - enable KVM on ARM architecture.
  - enable flat device tree support (--enable-fdt). (LP: #1030594)

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/qemu-iotests/030
21
21
import os
22
22
import iotests
23
23
from iotests import qemu_img, qemu_io
 
24
import struct
24
25
 
25
26
backing_img = os.path.join(iotests.test_dir, 'backing.img')
 
27
mid_img = os.path.join(iotests.test_dir, 'mid.img')
26
28
test_img = os.path.join(iotests.test_dir, 'test.img')
27
29
 
28
30
class ImageStreamingTestCase(iotests.QMPTestCase):
32
34
        result = self.vm.qmp('query-block-jobs')
33
35
        self.assert_qmp(result, 'return', [])
34
36
 
 
37
    def cancel_and_wait(self, drive='drive0'):
 
38
        '''Cancel a block job and wait for it to finish'''
 
39
        result = self.vm.qmp('block-job-cancel', device=drive)
 
40
        self.assert_qmp(result, 'return', {})
 
41
 
 
42
        cancelled = False
 
43
        while not cancelled:
 
44
            for event in self.vm.get_qmp_events(wait=True):
 
45
                if event['event'] == 'BLOCK_JOB_CANCELLED':
 
46
                    self.assert_qmp(event, 'data/type', 'stream')
 
47
                    self.assert_qmp(event, 'data/device', drive)
 
48
                    cancelled = True
 
49
 
 
50
        self.assert_no_active_streams()
 
51
 
 
52
    def create_image(self, name, size):
 
53
        file = open(name, 'w')
 
54
        i = 0
 
55
        while i < size:
 
56
            sector = struct.pack('>l504xl', i / 512, i / 512)
 
57
            file.write(sector)
 
58
            i = i + 512
 
59
        file.close()
 
60
 
 
61
 
35
62
class TestSingleDrive(ImageStreamingTestCase):
36
63
    image_len = 1 * 1024 * 1024 # MB
37
64
 
38
65
    def setUp(self):
39
 
        qemu_img('create', backing_img, str(TestSingleDrive.image_len))
40
 
        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
 
66
        self.create_image(backing_img, TestSingleDrive.image_len)
 
67
        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, mid_img)
 
68
        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % mid_img, test_img)
41
69
        self.vm = iotests.VM().add_drive(test_img)
42
70
        self.vm.launch()
43
71
 
44
72
    def tearDown(self):
45
73
        self.vm.shutdown()
46
74
        os.remove(test_img)
 
75
        os.remove(mid_img)
47
76
        os.remove(backing_img)
48
77
 
49
78
    def test_stream(self):
50
79
        self.assert_no_active_streams()
51
80
 
52
 
        result = self.vm.qmp('block_stream', device='drive0')
53
 
        self.assert_qmp(result, 'return', {})
54
 
 
55
 
        completed = False
56
 
        while not completed:
57
 
            for event in self.vm.get_qmp_events(wait=True):
58
 
                if event['event'] == 'BLOCK_JOB_COMPLETED':
59
 
                    self.assert_qmp(event, 'data/type', 'stream')
60
 
                    self.assert_qmp(event, 'data/device', 'drive0')
61
 
                    self.assert_qmp(event, 'data/offset', self.image_len)
62
 
                    self.assert_qmp(event, 'data/len', self.image_len)
63
 
                    completed = True
64
 
 
65
 
        self.assert_no_active_streams()
66
 
 
67
 
        self.assertFalse('sectors not allocated' in qemu_io('-c', 'map', test_img),
68
 
                         'image file not fully populated after streaming')
 
81
        result = self.vm.qmp('block-stream', device='drive0')
 
82
        self.assert_qmp(result, 'return', {})
 
83
 
 
84
        completed = False
 
85
        while not completed:
 
86
            for event in self.vm.get_qmp_events(wait=True):
 
87
                if event['event'] == 'BLOCK_JOB_COMPLETED':
 
88
                    self.assert_qmp(event, 'data/type', 'stream')
 
89
                    self.assert_qmp(event, 'data/device', 'drive0')
 
90
                    self.assert_qmp(event, 'data/offset', self.image_len)
 
91
                    self.assert_qmp(event, 'data/len', self.image_len)
 
92
                    completed = True
 
93
 
 
94
        self.assert_no_active_streams()
 
95
        self.vm.shutdown()
 
96
 
 
97
        self.assertEqual(qemu_io('-c', 'map', backing_img),
 
98
                         qemu_io('-c', 'map', test_img),
 
99
                         'image file map does not match backing file after streaming')
 
100
 
 
101
    def test_stream_partial(self):
 
102
        self.assert_no_active_streams()
 
103
 
 
104
        result = self.vm.qmp('block-stream', device='drive0', base=mid_img)
 
105
        self.assert_qmp(result, 'return', {})
 
106
 
 
107
        completed = False
 
108
        while not completed:
 
109
            for event in self.vm.get_qmp_events(wait=True):
 
110
                if event['event'] == 'BLOCK_JOB_COMPLETED':
 
111
                    self.assert_qmp(event, 'data/type', 'stream')
 
112
                    self.assert_qmp(event, 'data/device', 'drive0')
 
113
                    self.assert_qmp(event, 'data/offset', self.image_len)
 
114
                    self.assert_qmp(event, 'data/len', self.image_len)
 
115
                    completed = True
 
116
 
 
117
        self.assert_no_active_streams()
 
118
        self.vm.shutdown()
 
119
 
 
120
        self.assertEqual(qemu_io('-c', 'map', mid_img),
 
121
                         qemu_io('-c', 'map', test_img),
 
122
                         'image file map does not match backing file after streaming')
69
123
 
70
124
    def test_device_not_found(self):
71
 
        result = self.vm.qmp('block_stream', device='nonexistent')
 
125
        result = self.vm.qmp('block-stream', device='nonexistent')
72
126
        self.assert_qmp(result, 'error/class', 'DeviceNotFound')
73
127
 
74
128
class TestStreamStop(ImageStreamingTestCase):
90
144
 
91
145
        self.assert_no_active_streams()
92
146
 
93
 
        result = self.vm.qmp('block_stream', device='drive0')
 
147
        result = self.vm.qmp('block-stream', device='drive0')
94
148
        self.assert_qmp(result, 'return', {})
95
149
 
96
 
        time.sleep(1)
 
150
        time.sleep(0.1)
97
151
        events = self.vm.get_qmp_events(wait=False)
98
152
        self.assertEqual(events, [], 'unexpected QMP event: %s' % events)
99
153
 
100
 
        self.vm.qmp('block_job_cancel', device='drive0')
101
 
        self.assert_qmp(result, 'return', {})
102
 
 
103
 
        cancelled = False
104
 
        while not cancelled:
105
 
            for event in self.vm.get_qmp_events(wait=True):
106
 
                if event['event'] == 'BLOCK_JOB_CANCELLED':
107
 
                    self.assert_qmp(event, 'data/type', 'stream')
108
 
                    self.assert_qmp(event, 'data/device', 'drive0')
109
 
                    cancelled = True
110
 
 
111
 
        self.assert_no_active_streams()
112
 
 
113
 
# This is a short performance test which is not run by default.
114
 
# Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_set_speed"
 
154
        self.cancel_and_wait()
 
155
 
115
156
class TestSetSpeed(ImageStreamingTestCase):
116
157
    image_len = 80 * 1024 * 1024 # MB
117
158
 
126
167
        os.remove(test_img)
127
168
        os.remove(backing_img)
128
169
 
129
 
    def perf_test_set_speed(self):
 
170
    # This is a short performance test which is not run by default.
 
171
    # Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_throughput"
 
172
    def perf_test_throughput(self):
130
173
        self.assert_no_active_streams()
131
174
 
132
 
        result = self.vm.qmp('block_stream', device='drive0')
 
175
        result = self.vm.qmp('block-stream', device='drive0')
133
176
        self.assert_qmp(result, 'return', {})
134
177
 
135
 
        result = self.vm.qmp('block_job_set_speed', device='drive0', value=8 * 1024 * 1024)
 
178
        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
136
179
        self.assert_qmp(result, 'return', {})
137
180
 
138
181
        completed = False
147
190
 
148
191
        self.assert_no_active_streams()
149
192
 
 
193
    def test_set_speed(self):
 
194
        self.assert_no_active_streams()
 
195
 
 
196
        result = self.vm.qmp('block-stream', device='drive0')
 
197
        self.assert_qmp(result, 'return', {})
 
198
 
 
199
        # Default speed is 0
 
200
        result = self.vm.qmp('query-block-jobs')
 
201
        self.assert_qmp(result, 'return[0]/device', 'drive0')
 
202
        self.assert_qmp(result, 'return[0]/speed', 0)
 
203
 
 
204
        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
 
205
        self.assert_qmp(result, 'return', {})
 
206
 
 
207
        # Ensure the speed we set was accepted
 
208
        result = self.vm.qmp('query-block-jobs')
 
209
        self.assert_qmp(result, 'return[0]/device', 'drive0')
 
210
        self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
 
211
 
 
212
        self.cancel_and_wait()
 
213
 
 
214
        # Check setting speed in block-stream works
 
215
        result = self.vm.qmp('block-stream', device='drive0', speed=4 * 1024 * 1024)
 
216
        self.assert_qmp(result, 'return', {})
 
217
 
 
218
        result = self.vm.qmp('query-block-jobs')
 
219
        self.assert_qmp(result, 'return[0]/device', 'drive0')
 
220
        self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
 
221
 
 
222
        self.cancel_and_wait()
 
223
 
 
224
    def test_set_speed_invalid(self):
 
225
        self.assert_no_active_streams()
 
226
 
 
227
        result = self.vm.qmp('block-stream', device='drive0', speed=-1)
 
228
        self.assert_qmp(result, 'error/class', 'InvalidParameter')
 
229
        self.assert_qmp(result, 'error/data/name', 'speed')
 
230
 
 
231
        self.assert_no_active_streams()
 
232
 
 
233
        result = self.vm.qmp('block-stream', device='drive0')
 
234
        self.assert_qmp(result, 'return', {})
 
235
 
 
236
        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
 
237
        self.assert_qmp(result, 'error/class', 'InvalidParameter')
 
238
        self.assert_qmp(result, 'error/data/name', 'speed')
 
239
 
 
240
        self.cancel_and_wait()
 
241
 
150
242
if __name__ == '__main__':
151
243
    iotests.main(supported_fmts=['qcow2', 'qed'])