|
|
@@ -127,7 +127,7 @@ class TC_00_AppVMMixin(qubes.tests.SystemTestsMixin):
|
|
|
time.sleep(0.5)
|
|
|
subprocess.check_call(
|
|
|
['xdotool', 'search', '--name', title,
|
|
|
- 'windowactivate', 'type', 'exit\n'])
|
|
|
+ 'windowactivate', '--sync', 'type', 'exit\n'])
|
|
|
|
|
|
wait_count = 0
|
|
|
while subprocess.call(['xdotool', 'search', '--name', title],
|
|
|
@@ -168,7 +168,7 @@ class TC_00_AppVMMixin(qubes.tests.SystemTestsMixin):
|
|
|
time.sleep(0.5)
|
|
|
subprocess.check_call(
|
|
|
['xdotool', 'search', '--name', title,
|
|
|
- 'windowactivate', 'type', 'exit\n'])
|
|
|
+ 'windowactivate', '--sync', 'type', 'exit\n'])
|
|
|
|
|
|
wait_count = 0
|
|
|
while subprocess.call(['xdotool', 'search', '--name', title],
|
|
|
@@ -785,6 +785,8 @@ class TC_00_AppVMMixin(qubes.tests.SystemTestsMixin):
|
|
|
|
|
|
def test_210_time_sync(self):
|
|
|
"""Test time synchronization mechanism"""
|
|
|
+ if self.template.startswith('whonix-'):
|
|
|
+ self.skipTest('qvm-sync-clock disabled for Whonix VMs')
|
|
|
self.testvm1.start()
|
|
|
self.testvm2.start()
|
|
|
(start_time, _) = subprocess.Popen(["date", "-u", "+%s"],
|
|
|
@@ -860,778 +862,150 @@ class TC_00_AppVMMixin(qubes.tests.SystemTestsMixin):
|
|
|
# some safety margin for FS metadata
|
|
|
self.assertGreater(int(new_size.strip()), 5.8*1024**2)
|
|
|
|
|
|
-class TC_05_StandaloneVM(qubes.tests.SystemTestsMixin, qubes.tests.QubesTestCase):
|
|
|
- def test_000_create_start(self):
|
|
|
- testvm1 = self.qc.add_new_vm("QubesAppVm",
|
|
|
- template=None,
|
|
|
- name=self.make_vm_name('vm1'))
|
|
|
- testvm1.create_on_disk(verbose=False,
|
|
|
- source_template=self.qc.get_default_template())
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
- testvm1.start()
|
|
|
- self.assertEquals(testvm1.get_power_state(), "Running")
|
|
|
-
|
|
|
- def test_100_resize_root_img(self):
|
|
|
- testvm1 = self.qc.add_new_vm("QubesAppVm",
|
|
|
- template=None,
|
|
|
- name=self.make_vm_name('vm1'))
|
|
|
- testvm1.create_on_disk(verbose=False,
|
|
|
- source_template=self.qc.get_default_template())
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
- with self.assertRaises(QubesException):
|
|
|
- testvm1.resize_root_img(20*1024**3)
|
|
|
- testvm1.resize_root_img(20*1024**3, allow_start=True)
|
|
|
- timeout = 60
|
|
|
- while testvm1.is_running():
|
|
|
- time.sleep(1)
|
|
|
- timeout -= 1
|
|
|
- if timeout == 0:
|
|
|
- self.fail("Timeout while waiting for VM shutdown")
|
|
|
- self.assertEquals(testvm1.get_root_img_sz(), 20*1024**3)
|
|
|
- testvm1.start()
|
|
|
- p = testvm1.run('df --output=size /|tail -n 1',
|
|
|
- passio_popen=True)
|
|
|
- # new_size in 1k-blocks
|
|
|
- (new_size, _) = p.communicate()
|
|
|
- # some safety margin for FS metadata
|
|
|
- self.assertGreater(int(new_size.strip()), 19*1024**2)
|
|
|
-
|
|
|
-
|
|
|
-class TC_10_HVM(qubes.tests.SystemTestsMixin, qubes.tests.QubesTestCase):
|
|
|
- # TODO: test with some OS inside
|
|
|
- # TODO: windows tools tests
|
|
|
-
|
|
|
- def test_000_create_start(self):
|
|
|
- testvm1 = self.qc.add_new_vm("QubesHVm",
|
|
|
- name=self.make_vm_name('vm1'))
|
|
|
- testvm1.create_on_disk(verbose=False)
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
- testvm1.start()
|
|
|
- self.assertEquals(testvm1.get_power_state(), "Running")
|
|
|
-
|
|
|
- def test_010_create_start_template(self):
|
|
|
- templatevm = self.qc.add_new_vm("QubesTemplateHVm",
|
|
|
- name=self.make_vm_name('template'))
|
|
|
- templatevm.create_on_disk(verbose=False)
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
-
|
|
|
- templatevm.start()
|
|
|
- self.assertEquals(templatevm.get_power_state(), "Running")
|
|
|
-
|
|
|
- def test_020_create_start_template_vm(self):
|
|
|
- templatevm = self.qc.add_new_vm("QubesTemplateHVm",
|
|
|
- name=self.make_vm_name('template'))
|
|
|
- templatevm.create_on_disk(verbose=False)
|
|
|
- testvm2 = self.qc.add_new_vm("QubesHVm",
|
|
|
- name=self.make_vm_name('vm2'),
|
|
|
- template=templatevm)
|
|
|
- testvm2.create_on_disk(verbose=False)
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
-
|
|
|
- testvm2.start()
|
|
|
- self.assertEquals(testvm2.get_power_state(), "Running")
|
|
|
-
|
|
|
- def test_030_prevent_simultaneus_start(self):
|
|
|
- templatevm = self.qc.add_new_vm("QubesTemplateHVm",
|
|
|
- name=self.make_vm_name('template'))
|
|
|
- templatevm.create_on_disk(verbose=False)
|
|
|
- testvm2 = self.qc.add_new_vm("QubesHVm",
|
|
|
- name=self.make_vm_name('vm2'),
|
|
|
- template=templatevm)
|
|
|
- testvm2.create_on_disk(verbose=False)
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
-
|
|
|
- templatevm.start()
|
|
|
- self.assertEquals(templatevm.get_power_state(), "Running")
|
|
|
- self.assertRaises(QubesException, testvm2.start)
|
|
|
- templatevm.force_shutdown()
|
|
|
- testvm2.start()
|
|
|
- self.assertEquals(testvm2.get_power_state(), "Running")
|
|
|
- self.assertRaises(QubesException, templatevm.start)
|
|
|
-
|
|
|
- def test_100_resize_root_img(self):
|
|
|
- testvm1 = self.qc.add_new_vm("QubesHVm",
|
|
|
- name=self.make_vm_name('vm1'))
|
|
|
- testvm1.create_on_disk(verbose=False)
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
- testvm1.resize_root_img(30*1024**3)
|
|
|
- self.assertEquals(testvm1.get_root_img_sz(), 30*1024**3)
|
|
|
- testvm1.start()
|
|
|
- self.assertEquals(testvm1.get_power_state(), "Running")
|
|
|
- # TODO: launch some OS there and check the size
|
|
|
-
|
|
|
-class TC_20_DispVMMixin(qubes.tests.SystemTestsMixin):
|
|
|
- def test_000_prepare_dvm(self):
|
|
|
- self.qc.unlock_db()
|
|
|
- retcode = subprocess.call(['/usr/bin/qvm-create-default-dvm',
|
|
|
- self.template],
|
|
|
- stderr=open(os.devnull, 'w'))
|
|
|
- self.assertEqual(retcode, 0)
|
|
|
- self.qc.lock_db_for_writing()
|
|
|
- self.qc.load()
|
|
|
- self.assertIsNotNone(self.qc.get_vm_by_name(
|
|
|
- self.template + "-dvm"))
|
|
|
- # TODO: check mtime of snapshot file
|
|
|
-
|
|
|
- def test_010_simple_dvm_run(self):
|
|
|
- self.qc.unlock_db()
|
|
|
- p = subprocess.Popen(['/usr/lib/qubes/qfile-daemon-dvm',
|
|
|
- 'qubes.VMShell', 'dom0', 'DEFAULT'],
|
|
|
- stdin=subprocess.PIPE,
|
|
|
- stdout=subprocess.PIPE,
|
|
|
- stderr=open(os.devnull, 'w'))
|
|
|
- (stdout, _) = p.communicate(input="echo test")
|
|
|
- self.assertEqual(stdout, "test\n")
|
|
|
- # TODO: check if DispVM is destroyed
|
|
|
-
|
|
|
- @unittest.skipUnless(spawn.find_executable('xdotool'),
|
|
|
- "xdotool not installed")
|
|
|
- def test_020_gui_app(self):
|
|
|
- self.qc.unlock_db()
|
|
|
- p = subprocess.Popen(['/usr/lib/qubes/qfile-daemon-dvm',
|
|
|
- 'qubes.VMShell', 'dom0', 'DEFAULT'],
|
|
|
- stdin=subprocess.PIPE,
|
|
|
- stdout=subprocess.PIPE,
|
|
|
- stderr=open(os.devnull, 'w'))
|
|
|
-
|
|
|
- # wait for DispVM startup:
|
|
|
- p.stdin.write("echo test\n")
|
|
|
- p.stdin.flush()
|
|
|
- l = p.stdout.readline()
|
|
|
- self.assertEqual(l, "test\n")
|
|
|
-
|
|
|
- # potential race condition, but our tests are supposed to be
|
|
|
- # running on dedicated machine, so should not be a problem
|
|
|
- self.qc.lock_db_for_reading()
|
|
|
- self.qc.load()
|
|
|
- self.qc.unlock_db()
|
|
|
-
|
|
|
- max_qid = 0
|
|
|
- for vm in self.qc.values():
|
|
|
- if not vm.is_disposablevm():
|
|
|
- continue
|
|
|
- if vm.qid > max_qid:
|
|
|
- max_qid = vm.qid
|
|
|
- dispvm = self.qc[max_qid]
|
|
|
- self.assertNotEqual(dispvm.qid, 0, "DispVM not found in qubes.xml")
|
|
|
- self.assertTrue(dispvm.is_running())
|
|
|
- try:
|
|
|
- window_title = 'user@%s' % (dispvm.template.name + "-dvm")
|
|
|
- p.stdin.write("xterm -e "
|
|
|
- "\"sh -s -c 'echo \\\"\033]0;{}\007\\\";read x;'\"\n".
|
|
|
- format(window_title))
|
|
|
- self.wait_for_window(window_title)
|
|
|
-
|
|
|
- time.sleep(0.5)
|
|
|
- self.enter_keys_in_window(window_title, ['Return'])
|
|
|
- # Wait for window to close
|
|
|
- self.wait_for_window(window_title, show=False)
|
|
|
- finally:
|
|
|
- p.stdin.close()
|
|
|
-
|
|
|
- wait_count = 0
|
|
|
- while dispvm.is_running():
|
|
|
- wait_count += 1
|
|
|
- if wait_count > 100:
|
|
|
- self.fail("Timeout while waiting for DispVM destruction")
|
|
|
- time.sleep(0.1)
|
|
|
- wait_count = 0
|
|
|
- while p.poll() is None:
|
|
|
- wait_count += 1
|
|
|
- if wait_count > 100:
|
|
|
- self.fail("Timeout while waiting for qfile-daemon-dvm "
|
|
|
- "termination")
|
|
|
- time.sleep(0.1)
|
|
|
- self.assertEqual(p.returncode, 0)
|
|
|
-
|
|
|
- self.qc.lock_db_for_reading()
|
|
|
- self.qc.load()
|
|
|
- self.qc.unlock_db()
|
|
|
- self.assertIsNone(self.qc.get_vm_by_name(dispvm.name),
|
|
|
- "DispVM not removed from qubes.xml")
|
|
|
-
|
|
|
- def _handle_editor(self, winid):
|
|
|
- (window_title, _) = subprocess.Popen(
|
|
|
- ['xdotool', 'getwindowname', winid], stdout=subprocess.PIPE).\
|
|
|
- communicate()
|
|
|
- window_title = window_title.strip().\
|
|
|
- replace('(', '\(').replace(')', '\)')
|
|
|
- time.sleep(1)
|
|
|
- if "gedit" in window_title:
|
|
|
- subprocess.check_call(['xdotool', 'search', '--name', window_title,
|
|
|
- 'windowactivate', 'type', 'test test 2\n'])
|
|
|
- time.sleep(0.5)
|
|
|
- subprocess.check_call(['xdotool', 'search', '--name', window_title,
|
|
|
- 'key', 'ctrl+s', 'ctrl+q'])
|
|
|
- elif "emacs" in window_title:
|
|
|
- subprocess.check_call(['xdotool', 'search', '--name', window_title,
|
|
|
- 'windowactivate', 'type', 'test test 2\n'])
|
|
|
- time.sleep(0.5)
|
|
|
- subprocess.check_call(['xdotool', 'search', '--name', window_title,
|
|
|
- 'key', 'ctrl+x', 'ctrl+s'])
|
|
|
- subprocess.check_call(['xdotool', 'search', '--name', window_title,
|
|
|
- 'key', 'ctrl+x', 'ctrl+c'])
|
|
|
- elif "vim" in window_title:
|
|
|
- subprocess.check_call(['xdotool', 'search', '--name', window_title,
|
|
|
- 'windowactivate', 'key', 'i',
|
|
|
- 'type', 'test test 2\n'])
|
|
|
- subprocess.check_call(
|
|
|
- ['xdotool', 'search', '--name', window_title,
|
|
|
- 'key', 'Escape', 'colon', 'w', 'q', 'Return'])
|
|
|
- else:
|
|
|
- self.fail("Unknown editor window: {}".format(window_title))
|
|
|
-
|
|
|
- @unittest.skipUnless(spawn.find_executable('xdotool'),
|
|
|
- "xdotool not installed")
|
|
|
- def test_030_edit_file(self):
|
|
|
- testvm1 = self.qc.add_new_vm("QubesAppVm",
|
|
|
- name=self.make_vm_name('vm1'),
|
|
|
- template=self.qc.get_vm_by_name(
|
|
|
- self.template))
|
|
|
- testvm1.create_on_disk(verbose=False)
|
|
|
- self.qc.save()
|
|
|
-
|
|
|
- testvm1.start()
|
|
|
- testvm1.run("echo test1 > /home/user/test.txt", wait=True)
|
|
|
-
|
|
|
- self.qc.unlock_db()
|
|
|
- p = testvm1.run("qvm-open-in-dvm /home/user/test.txt",
|
|
|
- passio_popen=True)
|
|
|
-
|
|
|
- wait_count = 0
|
|
|
- winid = None
|
|
|
- while True:
|
|
|
- search = subprocess.Popen(['xdotool', 'search',
|
|
|
- '--onlyvisible', '--class', 'disp*'],
|
|
|
- stdout=subprocess.PIPE,
|
|
|
- stderr=open(os.path.devnull, 'w'))
|
|
|
- retcode = search.wait()
|
|
|
- if retcode == 0:
|
|
|
- winid = search.stdout.read().strip()
|
|
|
- break
|
|
|
- wait_count += 1
|
|
|
- if wait_count > 100:
|
|
|
- self.fail("Timeout while waiting for editor window")
|
|
|
- time.sleep(0.3)
|
|
|
-
|
|
|
- self._handle_editor(winid)
|
|
|
- p.wait()
|
|
|
- p = testvm1.run("cat /home/user/test.txt",
|
|
|
- passio_popen=True)
|
|
|
- (test_txt_content, _) = p.communicate()
|
|
|
- self.assertEqual(test_txt_content, "test test 2\ntest1\n")
|
|
|
-
|
|
|
-
|
|
|
-class TC_30_Gui_daemon(qubes.tests.SystemTestsMixin, qubes.tests.QubesTestCase):
|
|
|
@unittest.skipUnless(spawn.find_executable('xdotool'),
|
|
|
"xdotool not installed")
|
|
|
- def test_000_clipboard(self):
|
|
|
- testvm1 = self.qc.add_new_vm("QubesAppVm",
|
|
|
- name=self.make_vm_name('vm1'),
|
|
|
- template=self.qc.get_default_template())
|
|
|
- testvm1.create_on_disk(verbose=False)
|
|
|
- testvm2 = self.qc.add_new_vm("QubesAppVm",
|
|
|
- name=self.make_vm_name('vm2'),
|
|
|
- template=self.qc.get_default_template())
|
|
|
- testvm2.create_on_disk(verbose=False)
|
|
|
- self.qc.save()
|
|
|
- self.qc.unlock_db()
|
|
|
-
|
|
|
- testvm1.start()
|
|
|
- testvm2.start()
|
|
|
-
|
|
|
- window_title = 'user@{}'.format(testvm1.name)
|
|
|
- testvm1.run('zenity --text-info --editable --title={}'.format(
|
|
|
- window_title))
|
|
|
-
|
|
|
- self.wait_for_window(window_title)
|
|
|
- time.sleep(0.5)
|
|
|
- test_string = "test{}".format(testvm1.xid)
|
|
|
-
|
|
|
- # Type and copy some text
|
|
|
- subprocess.check_call(['xdotool', 'search', '--name', window_title,
|
|
|
- 'windowactivate',
|
|
|
- 'type', '{}'.format(test_string)])
|
|
|
- # second xdotool call because type --terminator do not work (SEGV)
|
|
|
- # additionally do not use search here, so window stack will be empty
|
|
|
- # and xdotool will use XTEST instead of generating events manually -
|
|
|
- # this will be much better - at least because events will have
|
|
|
- # correct timestamp (so gui-daemon would not drop the copy request)
|
|
|
- subprocess.check_call(['xdotool',
|
|
|
- 'key', 'ctrl+a', 'ctrl+c', 'ctrl+shift+c',
|
|
|
- 'Escape'])
|
|
|
-
|
|
|
- clipboard_content = \
|
|
|
- open('/var/run/qubes/qubes-clipboard.bin', 'r').read().strip()
|
|
|
- self.assertEquals(clipboard_content, test_string,
|
|
|
- "Clipboard copy operation failed - content")
|
|
|
- clipboard_source = \
|
|
|
- open('/var/run/qubes/qubes-clipboard.bin.source',
|
|
|
- 'r').read().strip()
|
|
|
- self.assertEquals(clipboard_source, testvm1.name,
|
|
|
- "Clipboard copy operation failed - owner")
|
|
|
-
|
|
|
- # Then paste it to the other window
|
|
|
- window_title = 'user@{}'.format(testvm2.name)
|
|
|
- p = testvm2.run('zenity --entry --title={} > test.txt'.format(
|
|
|
- window_title), passio_popen=True)
|
|
|
- self.wait_for_window(window_title)
|
|
|
-
|
|
|
- subprocess.check_call(['xdotool', 'key', '--delay', '100',
|
|
|
- 'ctrl+shift+v', 'ctrl+v', 'Return'])
|
|
|
- p.wait()
|
|
|
-
|
|
|
- # And compare the result
|
|
|
- (test_output, _) = testvm2.run('cat test.txt',
|
|
|
- passio_popen=True).communicate()
|
|
|
- self.assertEquals(test_string, test_output.strip())
|
|
|
-
|
|
|
- clipboard_content = \
|
|
|
- open('/var/run/qubes/qubes-clipboard.bin', 'r').read().strip()
|
|
|
- self.assertEquals(clipboard_content, "",
|
|
|
- "Clipboard not wiped after paste - content")
|
|
|
- clipboard_source = \
|
|
|
- open('/var/run/qubes/qubes-clipboard.bin.source', 'r').read(
|
|
|
-
|
|
|
- ).strip()
|
|
|
- self.assertEquals(clipboard_source, "",
|
|
|
- "Clipboard not wiped after paste - owner")
|
|
|
-
|
|
|
-
|
|
|
-@unittest.skipUnless(os.path.exists('/var/lib/qubes/vm-kernels/pvgrub2'),
|
|
|
- 'grub-xen package not installed')
|
|
|
-class TC_40_PVGrub(qubes.tests.SystemTestsMixin):
|
|
|
- def setUp(self):
|
|
|
- super(TC_40_PVGrub, self).setUp()
|
|
|
- supported = False
|
|
|
- if self.template.startswith('fedora-'):
|
|
|
- supported = True
|
|
|
- elif self.template.startswith('debian-'):
|
|
|
- supported = True
|
|
|
- if not supported:
|
|
|
- self.skipTest("Template {} not supported by this test".format(
|
|
|
- self.template))
|
|
|
-
|
|
|
- def install_packages(self, vm):
|
|
|
- if self.template.startswith('fedora-'):
|
|
|
- cmd_install1 = 'yum clean expire-cache && ' \
|
|
|
- 'yum install -y qubes-kernel-vm-support grub2-tools'
|
|
|
- cmd_install2 = 'yum install -y kernel kernel-devel'
|
|
|
- cmd_update_grub = 'grub2-mkconfig -o /boot/grub2/grub.cfg'
|
|
|
- elif self.template.startswith('debian-'):
|
|
|
- cmd_install1 = 'apt-get update && apt-get install -y ' \
|
|
|
- 'qubes-kernel-vm-support grub2-common'
|
|
|
- cmd_install2 = 'apt-get install -y linux-image-amd64'
|
|
|
- cmd_update_grub = 'mkdir /boot/grub && update-grub2'
|
|
|
- else:
|
|
|
- assert False, "Unsupported template?!"
|
|
|
-
|
|
|
- for cmd in [cmd_install1, cmd_install2, cmd_update_grub]:
|
|
|
- p = vm.run(cmd, user="root", passio_popen=True, passio_stderr=True)
|
|
|
- (stdout, stderr) = p.communicate()
|
|
|
- self.assertEquals(p.returncode, 0,
|
|
|
- "Failed command: {}\nSTDOUT: {}\nSTDERR: {}"
|
|
|
- .format(cmd, stdout, stderr))
|
|
|
-
|
|
|
- def get_kernel_version(self, vm):
|
|
|
- if self.template.startswith('fedora-'):
|
|
|
- cmd_get_kernel_version = 'rpm -q kernel|sort -n|tail -1|' \
|
|
|
- 'cut -d - -f 2-'
|
|
|
- elif self.template.startswith('debian-'):
|
|
|
- cmd_get_kernel_version = \
|
|
|
- 'dpkg-query --showformat=\'${Package}\\n\' --show ' \
|
|
|
- '\'linux-image-*-amd64\'|sort -n|tail -1|cut -d - -f 3-'
|
|
|
- else:
|
|
|
- raise RuntimeError("Unsupported template?!")
|
|
|
-
|
|
|
- p = vm.run(cmd_get_kernel_version, user="root", passio_popen=True)
|
|
|
- (kver, _) = p.communicate()
|
|
|
- self.assertEquals(p.returncode, 0,
|
|
|
- "Failed command: {}".format(cmd_get_kernel_version))
|
|
|
- return kver.strip()
|
|
|
-
|
|
|
- def test_000_standalone_vm(self):
|
|
|
- testvm1 = self.qc.add_new_vm("QubesAppVm",
|
|
|
- template=None,
|
|
|
- name=self.make_vm_name('vm1'))
|
|
|
- testvm1.create_on_disk(verbose=False,
|
|
|
- source_template=self.qc.get_vm_by_name(
|
|
|
- self.template))
|
|
|
- self.save_and_reload_db()
|
|
|
- self.qc.unlock_db()
|
|
|
- testvm1 = self.qc[testvm1.qid]
|
|
|
- testvm1.start()
|
|
|
- self.install_packages(testvm1)
|
|
|
- kver = self.get_kernel_version(testvm1)
|
|
|
- self.shutdown_and_wait(testvm1)
|
|
|
-
|
|
|
- self.qc.lock_db_for_writing()
|
|
|
- self.qc.load()
|
|
|
- testvm1 = self.qc[testvm1.qid]
|
|
|
- testvm1.kernel = 'pvgrub2'
|
|
|
- self.save_and_reload_db()
|
|
|
- self.qc.unlock_db()
|
|
|
- testvm1 = self.qc[testvm1.qid]
|
|
|
- testvm1.start()
|
|
|
- p = testvm1.run('uname -r', passio_popen=True)
|
|
|
- (actual_kver, _) = p.communicate()
|
|
|
- self.assertEquals(actual_kver.strip(), kver)
|
|
|
-
|
|
|
- def test_010_template_based_vm(self):
|
|
|
- test_template = self.qc.add_new_vm("QubesTemplateVm",
|
|
|
- template=None,
|
|
|
- name=self.make_vm_name('template'))
|
|
|
- test_template.clone_attrs(self.qc.get_vm_by_name(self.template))
|
|
|
- test_template.clone_disk_files(
|
|
|
- src_vm=self.qc.get_vm_by_name(self.template),
|
|
|
- verbose=False)
|
|
|
-
|
|
|
- testvm1 = self.qc.add_new_vm("QubesAppVm",
|
|
|
- template=test_template,
|
|
|
- name=self.make_vm_name('vm1'))
|
|
|
- testvm1.create_on_disk(verbose=False,
|
|
|
- source_template=test_template)
|
|
|
- self.save_and_reload_db()
|
|
|
- self.qc.unlock_db()
|
|
|
- test_template = self.qc[test_template.qid]
|
|
|
- testvm1 = self.qc[testvm1.qid]
|
|
|
- test_template.start()
|
|
|
- self.install_packages(test_template)
|
|
|
- kver = self.get_kernel_version(test_template)
|
|
|
- self.shutdown_and_wait(test_template)
|
|
|
-
|
|
|
- self.qc.lock_db_for_writing()
|
|
|
- self.qc.load()
|
|
|
- test_template = self.qc[test_template.qid]
|
|
|
- test_template.kernel = 'pvgrub2'
|
|
|
- testvm1 = self.qc[testvm1.qid]
|
|
|
- testvm1.kernel = 'pvgrub2'
|
|
|
- self.save_and_reload_db()
|
|
|
- self.qc.unlock_db()
|
|
|
-
|
|
|
- # Check if TemplateBasedVM boots and has the right kernel
|
|
|
- testvm1 = self.qc[testvm1.qid]
|
|
|
- testvm1.start()
|
|
|
- p = testvm1.run('uname -r', passio_popen=True)
|
|
|
- (actual_kver, _) = p.communicate()
|
|
|
- self.assertEquals(actual_kver.strip(), kver)
|
|
|
-
|
|
|
- # And the same for the TemplateVM itself
|
|
|
- test_template = self.qc[test_template.qid]
|
|
|
- test_template.start()
|
|
|
- p = test_template.run('uname -r', passio_popen=True)
|
|
|
- (actual_kver, _) = p.communicate()
|
|
|
- self.assertEquals(actual_kver.strip(), kver)
|
|
|
-
|
|
|
-@unittest.skipUnless(
|
|
|
- spawn.find_executable('xprop') and
|
|
|
- spawn.find_executable('xdotool') and
|
|
|
- spawn.find_executable('wmctrl'),
|
|
|
- "xprop or xdotool or wmctrl not installed")
|
|
|
-class TC_50_MimeHandlers(qubes.tests.SystemTestsMixin):
|
|
|
- @classmethod
|
|
|
- def setUpClass(cls):
|
|
|
- if cls.template == 'whonix-gw' or 'minimal' in cls.template:
|
|
|
- raise unittest.SkipTest(
|
|
|
- 'Template {} not supported by this test'.format(cls.template))
|
|
|
-
|
|
|
- if cls.template == 'whonix-ws':
|
|
|
- # TODO remove when Whonix-based DispVMs will work (Whonix 13?)
|
|
|
- raise unittest.SkipTest(
|
|
|
- 'Template {} not supported by this test'.format(cls.template))
|
|
|
-
|
|
|
- qc = QubesVmCollection()
|
|
|
-
|
|
|
- cls._kill_test_vms(qc, prefix=qubes.tests.CLSVMPREFIX)
|
|
|
-
|
|
|
- qc.lock_db_for_writing()
|
|
|
- qc.load()
|
|
|
-
|
|
|
- cls._remove_test_vms(qc, qubes.qubes.vmm.libvirt_conn,
|
|
|
- prefix=qubes.tests.CLSVMPREFIX)
|
|
|
-
|
|
|
- cls.source_vmname = cls.make_vm_name('source', True)
|
|
|
- source_vm = qc.add_new_vm("QubesAppVm",
|
|
|
- template=qc.get_vm_by_name(cls.template),
|
|
|
- name=cls.source_vmname)
|
|
|
- source_vm.create_on_disk(verbose=False)
|
|
|
-
|
|
|
- cls.target_vmname = cls.make_vm_name('target', True)
|
|
|
- target_vm = qc.add_new_vm("QubesAppVm",
|
|
|
- template=qc.get_vm_by_name(cls.template),
|
|
|
- name=cls.target_vmname)
|
|
|
- target_vm.create_on_disk(verbose=False)
|
|
|
-
|
|
|
- qc.save()
|
|
|
- qc.unlock_db()
|
|
|
- source_vm.start()
|
|
|
- target_vm.start()
|
|
|
-
|
|
|
- # make sure that DispVMs will be started of the same template
|
|
|
- retcode = subprocess.call(['/usr/bin/qvm-create-default-dvm',
|
|
|
- cls.template],
|
|
|
- stderr=open(os.devnull, 'w'))
|
|
|
- assert retcode == 0, "Error preparing DispVM"
|
|
|
-
|
|
|
- def setUp(self):
|
|
|
- super(TC_50_MimeHandlers, self).setUp()
|
|
|
- self.source_vm = self.qc.get_vm_by_name(self.source_vmname)
|
|
|
- self.target_vm = self.qc.get_vm_by_name(self.target_vmname)
|
|
|
-
|
|
|
- def get_window_class(self, winid, dispvm=False):
|
|
|
- (vm_winid, _) = subprocess.Popen(
|
|
|
- ['xprop', '-id', winid, '_QUBES_VMWINDOWID'],
|
|
|
- stdout=subprocess.PIPE
|
|
|
- ).communicate()
|
|
|
- vm_winid = vm_winid.split("#")[1].strip('\n" ')
|
|
|
- if dispvm:
|
|
|
- (vmname, _) = subprocess.Popen(
|
|
|
- ['xprop', '-id', winid, '_QUBES_VMNAME'],
|
|
|
- stdout=subprocess.PIPE
|
|
|
- ).communicate()
|
|
|
- vmname = vmname.split("=")[1].strip('\n" ')
|
|
|
- window_class = None
|
|
|
- while window_class is None:
|
|
|
- # XXX to use self.qc.get_vm_by_name would require reloading
|
|
|
- # qubes.xml, so use qvm-run instead
|
|
|
- xprop = subprocess.Popen(
|
|
|
- ['qvm-run', '-p', vmname, 'xprop -id {} WM_CLASS'.format(
|
|
|
- vm_winid)], stdout=subprocess.PIPE)
|
|
|
- (window_class, _) = xprop.communicate()
|
|
|
- if xprop.returncode != 0:
|
|
|
- self.skipTest("xprop failed, not installed?")
|
|
|
- if 'not found' in window_class:
|
|
|
- # WM_CLASS not set yet, wait a little
|
|
|
- time.sleep(0.1)
|
|
|
- window_class = None
|
|
|
- else:
|
|
|
- window_class = None
|
|
|
- while window_class is None:
|
|
|
- xprop = self.target_vm.run(
|
|
|
- 'xprop -id {} WM_CLASS'.format(vm_winid),
|
|
|
- passio_popen=True)
|
|
|
- (window_class, _) = xprop.communicate()
|
|
|
- if xprop.returncode != 0:
|
|
|
- self.skipTest("xprop failed, not installed?")
|
|
|
- if 'not found' in window_class:
|
|
|
- # WM_CLASS not set yet, wait a little
|
|
|
- time.sleep(0.1)
|
|
|
- window_class = None
|
|
|
- # output: WM_CLASS(STRING) = "gnome-terminal-server", "Gnome-terminal"
|
|
|
- try:
|
|
|
- window_class = window_class.split("=")[1].split(",")[0].strip('\n" ')
|
|
|
- except IndexError:
|
|
|
- raise Exception(
|
|
|
- "Unexpected output from xprop: '{}'".format(window_class))
|
|
|
-
|
|
|
- return window_class
|
|
|
-
|
|
|
- def open_file_and_check_viewer(self, filename, expected_app_titles,
|
|
|
- expected_app_classes, dispvm=False):
|
|
|
- self.qc.unlock_db()
|
|
|
- if dispvm:
|
|
|
- p = self.source_vm.run("qvm-open-in-dvm {}".format(filename),
|
|
|
- passio_popen=True)
|
|
|
- vmpattern = "disp*"
|
|
|
- else:
|
|
|
- self.qrexec_policy('qubes.OpenInVM', self.source_vm.name,
|
|
|
- self.target_vmname)
|
|
|
- self.qrexec_policy('qubes.OpenURL', self.source_vm.name,
|
|
|
- self.target_vmname)
|
|
|
- p = self.source_vm.run("qvm-open-in-vm {} {}".format(
|
|
|
- self.target_vmname, filename), passio_popen=True)
|
|
|
- vmpattern = self.target_vmname
|
|
|
- wait_count = 0
|
|
|
- winid = None
|
|
|
- window_title = None
|
|
|
- while True:
|
|
|
- search = subprocess.Popen(['xdotool', 'search',
|
|
|
- '--onlyvisible', '--class', vmpattern],
|
|
|
- stdout=subprocess.PIPE,
|
|
|
- stderr=open(os.path.devnull, 'w'))
|
|
|
- retcode = search.wait()
|
|
|
- if retcode == 0:
|
|
|
- winid = search.stdout.read().strip()
|
|
|
- # get window title
|
|
|
- (window_title, _) = subprocess.Popen(
|
|
|
- ['xdotool', 'getwindowname', winid], stdout=subprocess.PIPE). \
|
|
|
- communicate()
|
|
|
- window_title = window_title.strip()
|
|
|
- # ignore LibreOffice splash screen and window with no title
|
|
|
- # set yet
|
|
|
- if window_title and not window_title.startswith("LibreOffice")\
|
|
|
- and not window_title == 'VMapp command':
|
|
|
- break
|
|
|
- wait_count += 1
|
|
|
- if wait_count > 100:
|
|
|
- self.fail("Timeout while waiting for editor window")
|
|
|
- time.sleep(0.3)
|
|
|
-
|
|
|
- # get window class
|
|
|
- window_class = self.get_window_class(winid, dispvm)
|
|
|
- # close the window - we've got the window class, it is no longer needed
|
|
|
- subprocess.check_call(['wmctrl', '-i', '-c', winid])
|
|
|
- p.wait()
|
|
|
- self.wait_for_window(window_title, show=False)
|
|
|
-
|
|
|
- def check_matches(obj, patterns):
|
|
|
- return any((pat.search(obj) if isinstance(pat, type(re.compile('')))
|
|
|
- else pat in obj) for pat in patterns)
|
|
|
-
|
|
|
- if not check_matches(window_title, expected_app_titles) and \
|
|
|
- not check_matches(window_class, expected_app_classes):
|
|
|
- self.fail("Opening file {} resulted in window '{} ({})', which is "
|
|
|
- "none of {!r} ({!r})".format(
|
|
|
- filename, window_title, window_class,
|
|
|
- expected_app_titles, expected_app_classes))
|
|
|
-
|
|
|
- def prepare_txt(self, filename):
|
|
|
- p = self.source_vm.run("cat > {}".format(filename), passio_popen=True)
|
|
|
- p.stdin.write("This is test\n")
|
|
|
- p.stdin.close()
|
|
|
- retcode = p.wait()
|
|
|
- assert retcode == 0, "Failed to write {} file".format(filename)
|
|
|
-
|
|
|
- def prepare_pdf(self, filename):
|
|
|
- self.prepare_txt("/tmp/source.txt")
|
|
|
- cmd = "convert /tmp/source.txt {}".format(filename)
|
|
|
- retcode = self.source_vm.run(cmd, wait=True)
|
|
|
- assert retcode == 0, "Failed to run '{}'".format(cmd)
|
|
|
-
|
|
|
- def prepare_doc(self, filename):
|
|
|
- self.prepare_txt("/tmp/source.txt")
|
|
|
- cmd = "unoconv -f doc -o {} /tmp/source.txt".format(filename)
|
|
|
- retcode = self.source_vm.run(cmd, wait=True)
|
|
|
- if retcode != 0:
|
|
|
- self.skipTest("Failed to run '{}', not installed?".format(cmd))
|
|
|
-
|
|
|
- def prepare_pptx(self, filename):
|
|
|
- self.prepare_txt("/tmp/source.txt")
|
|
|
- cmd = "unoconv -f pptx -o {} /tmp/source.txt".format(filename)
|
|
|
- retcode = self.source_vm.run(cmd, wait=True)
|
|
|
- if retcode != 0:
|
|
|
- self.skipTest("Failed to run '{}', not installed?".format(cmd))
|
|
|
-
|
|
|
- def prepare_png(self, filename):
|
|
|
- self.prepare_txt("/tmp/source.txt")
|
|
|
- cmd = "convert /tmp/source.txt {}".format(filename)
|
|
|
- retcode = self.source_vm.run(cmd, wait=True)
|
|
|
- if retcode != 0:
|
|
|
- self.skipTest("Failed to run '{}', not installed?".format(cmd))
|
|
|
-
|
|
|
- def prepare_jpg(self, filename):
|
|
|
- self.prepare_txt("/tmp/source.txt")
|
|
|
- cmd = "convert /tmp/source.txt {}".format(filename)
|
|
|
- retcode = self.source_vm.run(cmd, wait=True)
|
|
|
- if retcode != 0:
|
|
|
- self.skipTest("Failed to run '{}', not installed?".format(cmd))
|
|
|
-
|
|
|
- def test_000_txt(self):
|
|
|
- filename = "/home/user/test_file.txt"
|
|
|
- self.prepare_txt(filename)
|
|
|
- self.open_file_and_check_viewer(filename, ["vim"],
|
|
|
- ["gedit", "emacs"])
|
|
|
-
|
|
|
- def test_001_pdf(self):
|
|
|
- filename = "/home/user/test_file.pdf"
|
|
|
- self.prepare_pdf(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["evince"])
|
|
|
-
|
|
|
- def test_002_doc(self):
|
|
|
- filename = "/home/user/test_file.doc"
|
|
|
- self.prepare_doc(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["libreoffice", "abiword"])
|
|
|
-
|
|
|
- def test_003_pptx(self):
|
|
|
- filename = "/home/user/test_file.pptx"
|
|
|
- self.prepare_pptx(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["libreoffice"])
|
|
|
-
|
|
|
- def test_004_png(self):
|
|
|
- filename = "/home/user/test_file.png"
|
|
|
- self.prepare_png(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["shotwell", "eog", "display"])
|
|
|
-
|
|
|
- def test_005_jpg(self):
|
|
|
- filename = "/home/user/test_file.jpg"
|
|
|
- self.prepare_jpg(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["shotwell", "eog", "display"])
|
|
|
-
|
|
|
- def test_006_jpeg(self):
|
|
|
- filename = "/home/user/test_file.jpeg"
|
|
|
- self.prepare_jpg(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["shotwell", "eog", "display"])
|
|
|
-
|
|
|
- def test_010_url(self):
|
|
|
- self.open_file_and_check_viewer("https://www.qubes-os.org/", [],
|
|
|
- ["Firefox", "Iceweasel"])
|
|
|
-
|
|
|
- def test_100_txt_dispvm(self):
|
|
|
- filename = "/home/user/test_file.txt"
|
|
|
- self.prepare_txt(filename)
|
|
|
- self.open_file_and_check_viewer(filename, ["vim"],
|
|
|
- ["gedit", "emacs"],
|
|
|
- dispvm=True)
|
|
|
-
|
|
|
- def test_101_pdf_dispvm(self):
|
|
|
- filename = "/home/user/test_file.pdf"
|
|
|
- self.prepare_pdf(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["evince"],
|
|
|
- dispvm=True)
|
|
|
-
|
|
|
- def test_102_doc_dispvm(self):
|
|
|
- filename = "/home/user/test_file.doc"
|
|
|
- self.prepare_doc(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["libreoffice", "abiword"],
|
|
|
- dispvm=True)
|
|
|
-
|
|
|
- def test_103_pptx_dispvm(self):
|
|
|
- filename = "/home/user/test_file.pptx"
|
|
|
- self.prepare_pptx(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["libreoffice"],
|
|
|
- dispvm=True)
|
|
|
-
|
|
|
- def test_104_png_dispvm(self):
|
|
|
- filename = "/home/user/test_file.png"
|
|
|
- self.prepare_png(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["shotwell", "eog", "display"],
|
|
|
- dispvm=True)
|
|
|
-
|
|
|
- def test_105_jpg_dispvm(self):
|
|
|
- filename = "/home/user/test_file.jpg"
|
|
|
- self.prepare_jpg(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["shotwell", "eog", "display"],
|
|
|
- dispvm=True)
|
|
|
-
|
|
|
- def test_106_jpeg_dispvm(self):
|
|
|
- filename = "/home/user/test_file.jpeg"
|
|
|
- self.prepare_jpg(filename)
|
|
|
- self.open_file_and_check_viewer(filename, [],
|
|
|
- ["shotwell", "eog", "display"],
|
|
|
- dispvm=True)
|
|
|
-
|
|
|
- def test_110_url_dispvm(self):
|
|
|
- self.open_file_and_check_viewer("https://www.qubes-os.org/", [],
|
|
|
- ["Firefox", "Iceweasel"],
|
|
|
- dispvm=True)
|
|
|
+ def test_300_bug_1028_gui_memory_pinning(self):
|
|
|
+ """
|
|
|
+ If VM window composition buffers are relocated in memory, GUI will
|
|
|
+ still use old pointers and will display old pages
|
|
|
+ :return:
|
|
|
+ """
|
|
|
+ self.testvm1.memory = 800
|
|
|
+ self.testvm1.maxmem = 800
|
|
|
+ # exclude from memory balancing
|
|
|
+ self.testvm1.services['meminfo-writer'] = False
|
|
|
+ self.testvm1.start()
|
|
|
+ # and allow large map count
|
|
|
+ self.testvm1.run("echo 256000 > /proc/sys/vm/max_map_count",
|
|
|
+ user="root", wait=True)
|
|
|
+ allocator_c = (
|
|
|
+ "#include <sys/mman.h>\n"
|
|
|
+ "#include <stdlib.h>\n"
|
|
|
+ "#include <stdio.h>\n"
|
|
|
+ "\n"
|
|
|
+ "int main(int argc, char **argv) {\n"
|
|
|
+ " int total_pages;\n"
|
|
|
+ " char *addr, *iter;\n"
|
|
|
+ "\n"
|
|
|
+ " total_pages = atoi(argv[1]);\n"
|
|
|
+ " addr = mmap(NULL, total_pages * 0x1000, PROT_READ | "
|
|
|
+ "PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_POPULATE, -1, 0);\n"
|
|
|
+ " if (addr == MAP_FAILED) {\n"
|
|
|
+ " perror(\"mmap\");\n"
|
|
|
+ " exit(1);\n"
|
|
|
+ " }\n"
|
|
|
+ " printf(\"Stage1\\n\");\n"
|
|
|
+ " fflush(stdout);\n"
|
|
|
+ " getchar();\n"
|
|
|
+ " for (iter = addr; iter < addr + total_pages*0x1000; iter += "
|
|
|
+ "0x2000) {\n"
|
|
|
+ " if (mlock(iter, 0x1000) == -1) {\n"
|
|
|
+ " perror(\"mlock\");\n"
|
|
|
+ " fprintf(stderr, \"%d of %d\\n\", (iter-addr)/0x1000, "
|
|
|
+ "total_pages);\n"
|
|
|
+ " exit(1);\n"
|
|
|
+ " }\n"
|
|
|
+ " }\n"
|
|
|
+ " printf(\"Stage2\\n\");\n"
|
|
|
+ " fflush(stdout);\n"
|
|
|
+ " for (iter = addr+0x1000; iter < addr + total_pages*0x1000; "
|
|
|
+ "iter += 0x2000) {\n"
|
|
|
+ " if (munmap(iter, 0x1000) == -1) {\n"
|
|
|
+ " perror(\"munmap\");\n"
|
|
|
+ " exit(1);\n"
|
|
|
+ " }\n"
|
|
|
+ " }\n"
|
|
|
+ " printf(\"Stage3\\n\");\n"
|
|
|
+ " fflush(stdout);\n"
|
|
|
+ " fclose(stdout);\n"
|
|
|
+ " getchar();\n"
|
|
|
+ "\n"
|
|
|
+ " return 0;\n"
|
|
|
+ "}\n")
|
|
|
+
|
|
|
+ p = self.testvm1.run("cat > allocator.c", passio_popen=True)
|
|
|
+ p.communicate(allocator_c)
|
|
|
+ p = self.testvm1.run("gcc allocator.c -o allocator",
|
|
|
+ passio_popen=True, passio_stderr=True)
|
|
|
+ (stdout, stderr) = p.communicate()
|
|
|
+ if p.returncode != 0:
|
|
|
+ self.skipTest("allocator compile failed: {}".format(stderr))
|
|
|
+
|
|
|
+ # drop caches to have even more memory pressure
|
|
|
+ self.testvm1.run("echo 3 > /proc/sys/vm/drop_caches",
|
|
|
+ user="root", wait=True)
|
|
|
+
|
|
|
+ # now fragment all free memory
|
|
|
+ p = self.testvm1.run("grep ^MemFree: /proc/meminfo|awk '{print $2}'",
|
|
|
+ passio_popen=True)
|
|
|
+ memory_pages = int(p.communicate()[0].strip())
|
|
|
+ memory_pages /= 4 # 4k pages
|
|
|
+ alloc1 = self.testvm1.run(
|
|
|
+ "ulimit -l unlimited; exec /home/user/allocator {}".format(
|
|
|
+ memory_pages),
|
|
|
+ user="root", passio_popen=True, passio_stderr=True)
|
|
|
+ # wait for memory being allocated; can't use just .read(), because EOF
|
|
|
+ # passing is unreliable while the process is still running
|
|
|
+ alloc1.stdin.write("\n")
|
|
|
+ alloc1.stdin.flush()
|
|
|
+ alloc_out = alloc1.stdout.read(len("Stage1\nStage2\nStage3\n"))
|
|
|
+
|
|
|
+ if "Stage3" not in alloc_out:
|
|
|
+ # read stderr only in case of failed assert, but still have nice
|
|
|
+ # failure message (don't use self.fail() directly)
|
|
|
+ self.assertIn("Stage3", alloc_out, alloc1.stderr.read())
|
|
|
+
|
|
|
+ # now, launch some window - it should get fragmented composition buffer
|
|
|
+ # it is important to have some changing content there, to generate
|
|
|
+ # content update events (aka damage notify)
|
|
|
+ proc = self.testvm1.run("gnome-terminal --full-screen -e top",
|
|
|
+ passio_popen=True)
|
|
|
+
|
|
|
+ # help xdotool a little...
|
|
|
+ time.sleep(2)
|
|
|
+ # get window ID
|
|
|
+ search = subprocess.Popen(['xdotool', 'search', '--sync',
|
|
|
+ '--onlyvisible', '--class', self.testvm1.name + ':.*erminal'],
|
|
|
+ stdout=subprocess.PIPE)
|
|
|
+ winid = search.communicate()[0].strip()
|
|
|
+ xprop = subprocess.Popen(['xprop', '-notype', '-id', winid,
|
|
|
+ '_QUBES_VMWINDOWID'], stdout=subprocess.PIPE)
|
|
|
+ vm_winid = xprop.stdout.read().strip().split(' ')[4]
|
|
|
+
|
|
|
+ # now free the fragmented memory and trigger compaction
|
|
|
+ alloc1.stdin.write("\n")
|
|
|
+ alloc1.wait()
|
|
|
+ self.testvm1.run("echo 1 > /proc/sys/vm/compact_memory", user="root")
|
|
|
+
|
|
|
+ # now window may be already "broken"; to be sure, allocate (=zero)
|
|
|
+ # some memory
|
|
|
+ alloc2 = self.testvm1.run(
|
|
|
+ "ulimit -l unlimited; /home/user/allocator {}".format(memory_pages),
|
|
|
+ user="root", passio_popen=True, passio_stderr=True)
|
|
|
+ alloc2.stdout.read(len("Stage1\n"))
|
|
|
+
|
|
|
+ # wait for damage notify - top updates every 3 sec by default
|
|
|
+ time.sleep(6)
|
|
|
+
|
|
|
+ # now take screenshot of the window, from dom0 and VM
|
|
|
+ # choose pnm format, as it doesn't have any useless metadata - easy
|
|
|
+ # to compare
|
|
|
+ p = self.testvm1.run("import -window {} pnm:-".format(vm_winid),
|
|
|
+ passio_popen=True, passio_stderr=True)
|
|
|
+ (vm_image, stderr) = p.communicate()
|
|
|
+ if p.returncode != 0:
|
|
|
+ raise Exception("Failed to get VM window image: {}".format(
|
|
|
+ stderr))
|
|
|
+
|
|
|
+ p = subprocess.Popen(["import", "-window", winid, "pnm:-"],
|
|
|
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
|
+ (dom0_image, stderr) = p.communicate()
|
|
|
+ if p.returncode != 0:
|
|
|
+ raise Exception("Failed to get dom0 window image: {}".format(
|
|
|
+ stderr))
|
|
|
+
|
|
|
+ if vm_image != dom0_image:
|
|
|
+ self.fail("Dom0 window doesn't match VM window content")
|
|
|
|
|
|
|
|
|
def load_tests(loader, tests, pattern):
|
|
|
@@ -1651,21 +1025,4 @@ def load_tests(loader, tests, pattern):
|
|
|
(TC_00_AppVMMixin, qubes.tests.QubesTestCase),
|
|
|
{'template': template})))
|
|
|
|
|
|
- tests.addTests(loader.loadTestsFromTestCase(
|
|
|
- type(
|
|
|
- 'TC_20_DispVM_' + template,
|
|
|
- (TC_20_DispVMMixin, qubes.tests.QubesTestCase),
|
|
|
- {'template': template})))
|
|
|
- tests.addTests(loader.loadTestsFromTestCase(
|
|
|
- type(
|
|
|
- 'TC_40_PVGrub_' + template,
|
|
|
- (TC_40_PVGrub, qubes.tests.QubesTestCase),
|
|
|
- {'template': template})))
|
|
|
-
|
|
|
- tests.addTests(loader.loadTestsFromTestCase(
|
|
|
- type(
|
|
|
- 'TC_50_MimeHandlers_' + template,
|
|
|
- (TC_50_MimeHandlers, qubes.tests.QubesTestCase),
|
|
|
- {'template': template})))
|
|
|
-
|
|
|
return tests
|
Marek Marczykowski-Górecki