summaryrefslogtreecommitdiffstats
path: root/src/VBox/ValidationKit/tests/additions
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
commitf8fe689a81f906d1b91bb3220acde2a4ecb14c5b (patch)
tree26484e9d7e2c67806c2d1760196ff01aaa858e8c /src/VBox/ValidationKit/tests/additions
parentInitial commit. (diff)
downloadvirtualbox-upstream.tar.xz
virtualbox-upstream.zip
Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/VBox/ValidationKit/tests/additions')
-rw-r--r--src/VBox/ValidationKit/tests/additions/Makefile.kmk43
-rwxr-xr-xsrc/VBox/ValidationKit/tests/additions/tdAddBasic1.py340
-rwxr-xr-xsrc/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py3753
3 files changed, 4136 insertions, 0 deletions
diff --git a/src/VBox/ValidationKit/tests/additions/Makefile.kmk b/src/VBox/ValidationKit/tests/additions/Makefile.kmk
new file mode 100644
index 00000000..36c309c4
--- /dev/null
+++ b/src/VBox/ValidationKit/tests/additions/Makefile.kmk
@@ -0,0 +1,43 @@
+# $Id: Makefile.kmk $
+## @file
+# VirtualBox Validation Kit - Additions Tests.
+#
+
+#
+# Copyright (C) 2006-2019 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+# VirtualBox OSE distribution, in which case the provisions of the
+# CDDL are applicable instead of those of the GPL.
+#
+# You may elect to license modified versions of this file under the
+# terms and conditions of either the GPL or the CDDL or both.
+#
+
+SUB_DEPTH = ../../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+
+INSTALLS += ValidationKitTestsAdditions
+ValidationKitTestsAdditions_TEMPLATE = VBoxValidationKitR3
+ValidationKitTestsAdditions_INST = $(INST_VALIDATIONKIT)tests/additions/
+ValidationKitTestsAdditions_EXEC_SOURCES := \
+ $(PATH_SUB_CURRENT)/tdAddBasic1.py \
+ $(PATH_SUB_CURRENT)/tdAddGuestCtrl.py
+
+
+VBOX_VALIDATIONKIT_PYTHON_SOURCES += $(ValidationKitTestsAdditions_EXEC_SOURCES)
+
+$(evalcall def_vbox_validationkit_process_python_sources)
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/ValidationKit/tests/additions/tdAddBasic1.py b/src/VBox/ValidationKit/tests/additions/tdAddBasic1.py
new file mode 100755
index 00000000..b23ed97e
--- /dev/null
+++ b/src/VBox/ValidationKit/tests/additions/tdAddBasic1.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# $Id: tdAddBasic1.py $
+
+"""
+VirtualBox Validation Kit - Additions Basics #1.
+"""
+
+__copyright__ = \
+"""
+Copyright (C) 2010-2019 Oracle Corporation
+
+This file is part of VirtualBox Open Source Edition (OSE), as
+available from http://www.virtualbox.org. This file is free software;
+you can redistribute it and/or modify it under the terms of the GNU
+General Public License (GPL) as published by the Free Software
+Foundation, in version 2 as it comes in the "COPYING" file of the
+VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+
+The contents of this file may alternatively be used under the terms
+of the Common Development and Distribution License Version 1.0
+(CDDL) only, as it comes in the "COPYING.CDDL" file of the
+VirtualBox OSE distribution, in which case the provisions of the
+CDDL are applicable instead of those of the GPL.
+
+You may elect to license modified versions of this file under the
+terms and conditions of either the GPL or the CDDL or both.
+"""
+__version__ = "$Revision: 127855 $"
+
+
+# Standard Python imports.
+import os;
+import sys;
+
+# Only the main script needs to modify the path.
+try: __file__
+except: __file__ = sys.argv[0];
+g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))));
+sys.path.append(g_ksValidationKitDir);
+
+# Validation Kit imports.
+from testdriver import reporter;
+from testdriver import base;
+from testdriver import vbox;
+from testdriver import vboxcon;
+
+# Sub test driver imports.
+sys.path.append(os.path.dirname(os.path.abspath(__file__))); # For sub-test drivers.
+from tdAddGuestCtrl import SubTstDrvAddGuestCtrl;
+
+
+class tdAddBasic1(vbox.TestDriver): # pylint: disable=R0902
+ """
+ Additions Basics #1.
+ """
+ ## @todo
+ # - More of the settings stuff can be and need to be generalized!
+ #
+
+ def __init__(self):
+ vbox.TestDriver.__init__(self);
+ self.oTestVmSet = self.oTestVmManager.getSmokeVmSet('nat');
+ self.asTestsDef = ['guestprops', 'stdguestprops', 'guestcontrol'];
+ self.asTests = self.asTestsDef;
+ self.asRsrcs = None
+
+ self.addSubTestDriver(SubTstDrvAddGuestCtrl(self));
+
+ #
+ # Overridden methods.
+ #
+ def showUsage(self):
+ rc = vbox.TestDriver.showUsage(self);
+ reporter.log('');
+ reporter.log('tdAddBasic1 Options:');
+ reporter.log(' --tests <s1[:s2[:]]>');
+ reporter.log(' Default: %s (all)' % (':'.join(self.asTestsDef)));
+ reporter.log(' --quick');
+ reporter.log(' Same as --virt-modes hwvirt --cpu-counts 1.');
+ return rc;
+
+ def parseOption(self, asArgs, iArg): # pylint: disable=R0912,R0915
+ if asArgs[iArg] == '--tests':
+ iArg += 1;
+ if iArg >= len(asArgs): raise base.InvalidOption('The "--tests" takes a colon separated list of tests');
+ self.asTests = asArgs[iArg].split(':');
+ for s in self.asTests:
+ if s not in self.asTestsDef:
+ raise base.InvalidOption('The "--tests" value "%s" is not valid; valid values are: %s' \
+ % (s, ' '.join(self.asTestsDef)));
+
+ elif asArgs[iArg] == '--quick':
+ self.parseOption(['--virt-modes', 'hwvirt'], 0);
+ self.parseOption(['--cpu-counts', '1'], 0);
+
+ else:
+ return vbox.TestDriver.parseOption(self, asArgs, iArg);
+ return iArg + 1;
+
+ def getResourceSet(self):
+ if self.asRsrcs is None:
+ self.asRsrcs = []
+ for oSubTstDrv in self.aoSubTstDrvs:
+ self.asRsrcs.extend(oSubTstDrv.asRsrcs)
+ self.asRsrcs.extend(self.oTestVmSet.getResourceSet())
+ return self.asRsrcs
+
+ def actionConfig(self):
+ if not self.importVBoxApi(): # So we can use the constant below.
+ return False;
+
+ eNic0AttachType = vboxcon.NetworkAttachmentType_NAT;
+ sGaIso = self.getGuestAdditionsIso();
+ return self.oTestVmSet.actionConfig(self, eNic0AttachType = eNic0AttachType, sDvdImage = sGaIso);
+
+ def actionExecute(self):
+ return self.oTestVmSet.actionExecute(self, self.testOneCfg);
+
+
+ #
+ # Test execution helpers.
+ #
+
+ def testOneCfg(self, oVM, oTestVm):
+ """
+ Runs the specified VM thru the tests.
+
+ Returns a success indicator on the general test execution. This is not
+ the actual test result.
+ """
+ fRc = False;
+
+ self.logVmInfo(oVM);
+ oSession, oTxsSession = self.startVmAndConnectToTxsViaTcp(oTestVm.sVmName, fCdWait = True, \
+ sFileCdWait = 'AUTORUN.INF');
+ if oSession is not None:
+ self.addTask(oTxsSession);
+ # Do the testing.
+ reporter.testStart('Install');
+ fRc, oTxsSession = self.testInstallAdditions(oSession, oTxsSession, oTestVm);
+ reporter.testDone();
+ fSkip = not fRc;
+
+ reporter.testStart('Guest Properties');
+ if not fSkip:
+ fRc = self.testGuestProperties(oSession, oTxsSession, oTestVm) and fRc;
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Guest Control');
+ if not fSkip:
+ (fRc2, oTxsSession) = self.aoSubTstDrvs[0].testIt(oTestVm, oSession, oTxsSession);
+ fRc = fRc2 and fRc;
+ reporter.testDone(fSkip);
+
+ ## @todo Save and restore test.
+
+ ## @todo Reset tests.
+
+ ## @todo Final test: Uninstallation.
+
+ # Cleanup.
+ self.removeTask(oTxsSession);
+ self.terminateVmBySession(oSession)
+ return fRc;
+
+ def testInstallAdditions(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests installing the guest additions
+ """
+ if oTestVm.isWindows():
+ (fRc, oTxsSession) = self.testWindowsInstallAdditions(oSession, oTxsSession, oTestVm);
+ else:
+ reporter.error('Guest Additions installation not implemented for %s yet! (%s)' % \
+ (oTestVm.sKind, oTestVm.sVmName));
+ fRc = False;
+
+ #
+ # Verify installation of Guest Additions using commmon bits.
+ #
+ if fRc is True:
+ #
+ # Wait for the GAs to come up.
+ #
+
+ ## @todo need to signed up for a OnAdditionsStateChanged and wait runlevel to
+ # at least reach Userland.
+
+ #
+ # Check if the additions are operational.
+ #
+ try: oGuest = oSession.o.console.guest;
+ except:
+ reporter.errorXcpt('Getting IGuest failed.');
+ return (False, oTxsSession);
+
+ # Check the additionsVersion attribute. It must not be empty.
+ reporter.testStart('IGuest::additionsVersion');
+ fRc = self.testIGuest_additionsVersion(oGuest);
+ reporter.testDone();
+
+ reporter.testStart('IGuest::additionsRunLevel');
+ self.testIGuest_additionsRunLevel(oGuest, oTestVm);
+ reporter.testDone();
+
+ ## @todo test IAdditionsFacilities.
+
+ return (fRc, oTxsSession);
+
+ def testWindowsInstallAdditions(self, oSession, oTxsSession, oTestVm):
+ """
+ Installs the Windows guest additions using the test execution service.
+ Since this involves rebooting the guest, we will have to create a new TXS session.
+ """
+ asLogFile = [];
+
+ fHaveSetupApiDevLog = False;
+
+ # Delete relevant log files.
+ if oTestVm.sKind in ('WindowsNT4',):
+ sWinDir = 'C:/WinNT/';
+ else:
+ sWinDir = 'C:/Windows/';
+ asLogFile = [sWinDir+'setupapi.log', sWinDir+'setupact.log', sWinDir+'setuperr.log'];
+
+ # Apply The SetupAPI logging level so that we also get the (most verbose) setupapi.dev.log file.
+ ## @todo !!! HACK ALERT !!! Add the value directly into the testing source image. Later.
+ fHaveSetupApiDevLog = self.txsRunTest(oTxsSession, 'Enabling setupapi.dev.log', 30 * 1000, \
+ 'c:\\Windows\\System32\\reg.exe', ('c:\\Windows\\System32\\reg.exe', \
+ 'add', '"HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Setup"', '/v', 'LogLevel', '/t', 'REG_DWORD', \
+ '/d', '0xFF'));
+
+ # On some guests the files in question still can be locked by the OS, so ignore deletion
+ # errors from the guest side (e.g. sharing violations) and just continue.
+ for sFile in asLogFile:
+ self.txsRmFile(oSession, oTxsSession, sFile, 10 * 1000, fIgnoreErrors = True);
+
+ # Install the public signing key.
+ if oTestVm.sKind not in ('WindowsNT4', 'Windows2000', 'WindowsXP', 'Windows2003'):
+ ## TODO
+ pass;
+
+ #
+ # The actual install.
+ # Enable installing the optional auto-logon modules (VBoxGINA/VBoxCredProv) + (Direct)3D support.
+ # Also tell the installer to produce the appropriate log files.
+ #
+ fRc = self.txsRunTest(oTxsSession, 'VBoxWindowsAdditions.exe', 5 * 60 * 1000, \
+ '${CDROM}/VBoxWindowsAdditions.exe', ('${CDROM}/VBoxWindowsAdditions.exe', '/S', '/l', '/with_autologon'));
+ ## @todo For testing the installation (D)3D stuff ('/with_d3d') we need to boot up in safe mode.
+
+ #
+ # Reboot the VM and reconnect the TXS session.
+ #
+ if fRc is True:
+ (fRc, oTxsSession) = self.txsRebootAndReconnectViaTcp(oSession, oTxsSession, cMsTimeout = 3 * 60000);
+
+ if fRc is True:
+ # Add the Windows Guest Additions installer files to the files we want to download
+ # from the guest.
+ sGuestAddsDir = 'C:/Program Files/Oracle/VirtualBox Guest Additions/';
+ asLogFile.append(sGuestAddsDir + 'install.log');
+ # Note: There won't be a install_ui.log because of the silent installation.
+ asLogFile.append(sGuestAddsDir + 'install_drivers.log');
+ asLogFile.append('C:/Windows/setupapi.log');
+
+ # Note: setupapi.dev.log only is available since Windows 2000.
+ if fHaveSetupApiDevLog:
+ asLogFile.append('C:/Windows/setupapi.dev.log');
+
+ #
+ # Download log files.
+ # Ignore errors as all files above might not be present (or in different locations)
+ # on different Windows guests.
+ #
+ self.txsDownloadFiles(oSession, oTxsSession, asLogFile, fIgnoreErrors = True);
+
+ return (fRc, oTxsSession);
+
+ def testIGuest_additionsVersion(self, oGuest):
+ """
+ Returns False if no version string could be obtained, otherwise True
+ even though errors are logged.
+ """
+ try:
+ sVer = oGuest.additionsVersion;
+ except:
+ reporter.errorXcpt('Getting the additions version failed.');
+ return False;
+ reporter.log('IGuest::additionsVersion="%s"' % (sVer,));
+
+ if sVer.strip() == '':
+ reporter.error('IGuest::additionsVersion is empty.');
+ return False;
+
+ if sVer != sVer.strip():
+ reporter.error('IGuest::additionsVersion is contains spaces: "%s".' % (sVer,));
+
+ asBits = sVer.split('.');
+ if len(asBits) < 3:
+ reporter.error('IGuest::additionsVersion does not contain at least tree dot separated fields: "%s" (%d).'
+ % (sVer, len(asBits)));
+
+ ## @todo verify the format.
+ return True;
+
+ def testIGuest_additionsRunLevel(self, oGuest, oTestVm):
+ """
+ Do run level tests.
+ """
+ if oTestVm.isLoggedOntoDesktop():
+ eExpectedRunLevel = vboxcon.AdditionsRunLevelType_Desktop;
+ else:
+ eExpectedRunLevel = vboxcon.AdditionsRunLevelType_Userland;
+
+ ## @todo Insert wait for the desired run level.
+ try:
+ iLevel = oGuest.additionsRunLevel;
+ except:
+ reporter.errorXcpt('Getting the additions run level failed.');
+ return False;
+ reporter.log('IGuest::additionsRunLevel=%s' % (iLevel,));
+
+ if iLevel != eExpectedRunLevel:
+ pass; ## @todo We really need that wait!!
+ #reporter.error('Expected runlevel %d, found %d instead' % (eExpectedRunLevel, iLevel));
+ return True;
+
+
+ def testGuestProperties(self, oSession, oTxsSession, oTestVm):
+ """
+ Test guest properties.
+ """
+ _ = oSession; _ = oTxsSession; _ = oTestVm;
+ return True;
+
+if __name__ == '__main__':
+ sys.exit(tdAddBasic1().main(sys.argv));
+
diff --git a/src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py b/src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py
new file mode 100755
index 00000000..7f27e7da
--- /dev/null
+++ b/src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py
@@ -0,0 +1,3753 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# pylint: disable=C0302
+
+"""
+VirtualBox Validation Kit - Guest Control Tests.
+"""
+
+__copyright__ = \
+"""
+Copyright (C) 2010-2019 Oracle Corporation
+
+This file is part of VirtualBox Open Source Edition (OSE), as
+available from http://www.virtualbox.org. This file is free software;
+you can redistribute it and/or modify it under the terms of the GNU
+General Public License (GPL) as published by the Free Software
+Foundation, in version 2 as it comes in the "COPYING" file of the
+VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+
+The contents of this file may alternatively be used under the terms
+of the Common Development and Distribution License Version 1.0
+(CDDL) only, as it comes in the "COPYING.CDDL" file of the
+VirtualBox OSE distribution, in which case the provisions of the
+CDDL are applicable instead of those of the GPL.
+
+You may elect to license modified versions of this file under the
+terms and conditions of either the GPL or the CDDL or both.
+"""
+__version__ = "$Revision: 127855 $"
+
+# Disable bitching about too many arguments per function.
+# pylint: disable=R0913
+
+# Disable bitching about semicolons at the end of lines.
+# pylint: disable=W0301
+
+## @todo Convert map() usage to a cleaner alternative Python now offers.
+# pylint: disable=W0141
+
+## @todo Convert the context/test classes into named tuples. Not in the mood right now, so
+# disabling it.
+# pylint: disable=R0903
+
+# Standard Python imports.
+from array import array
+import errno
+import os
+import random
+import string # pylint: disable=W0402
+import struct
+import sys
+import time
+
+# Only the main script needs to modify the path.
+try: __file__
+except: __file__ = sys.argv[0];
+g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))));
+sys.path.append(g_ksValidationKitDir);
+
+# Validation Kit imports.
+from testdriver import reporter;
+from testdriver import base;
+from testdriver import vbox;
+from testdriver import vboxcon;
+from testdriver import vboxwrappers;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ long = int # pylint: disable=W0622,C0103
+
+
+class GuestStream(bytearray):
+ """
+ Class for handling a guest process input/output stream.
+ """
+ def appendStream(self, stream, convertTo='<b'):
+ """
+ Appends and converts a byte sequence to this object;
+ handy for displaying a guest stream.
+ """
+ self.extend(struct.pack(convertTo, stream));
+
+class tdCtxTest(object):
+ """
+ Provides the actual test environment. Should be kept
+ as generic as possible.
+ """
+ def __init__(self, oSession, oTxsSession, oTestVm): # pylint: disable=W0613
+ ## The desired Main API result.
+ self.fRc = False;
+ ## IGuest reference.
+ self.oGuest = oSession.o.console.guest;
+ # Rest not used (yet).
+
+class tdCtxCreds(object):
+ """
+ Provides credentials to pass to the guest.
+ """
+ def __init__(self, sUser = None, sPassword = None, sDomain = None, oTestVm = None):
+ # If no user is specified, select the default user and
+ # password for the given test VM.
+ if sUser is None:
+ assert sPassword is None;
+ assert sDomain is None;
+ assert oTestVm is not None;
+
+ ## @todo fix this so all VMs have several usable test users with the same passwords (or none).
+ sUser = 'test';
+ sPassword = 'password';
+ if oTestVm.isWindows():
+ #sPassword = ''; # stupid config mistake.
+ sPassword = 'password';
+ sUser = 'Administrator';
+ sDomain = '';
+
+ self.sUser = sUser;
+ self.sPassword = sPassword if sPassword is not None else '';
+ self.sDomain = sDomain if sDomain is not None else '';
+
+class tdTestGuestCtrlBase(object):
+ """
+ Base class for all guest control tests.
+ Note: This test ASSUMES that working Guest Additions
+ were installed and running on the guest to be tested.
+ """
+ def __init__(self):
+ self.oTest = None;
+ self.oCreds = None;
+ self.timeoutMS = 30 * 1000; # 30s timeout
+ ## IGuestSession reference or None.
+ self.oGuestSession = None;
+
+ def setEnvironment(self, oSession, oTxsSession, oTestVm):
+ """
+ Sets the test environment required for this test.
+ """
+ self.oTest = tdCtxTest(oSession, oTxsSession, oTestVm);
+ return self.oTest;
+
+ def createSession(self, sName):
+ """
+ Creates (opens) a guest session.
+ Returns (True, IGuestSession) on success or (False, None) on failure.
+ """
+ if self.oGuestSession is None:
+ if sName is None:
+ sName = "<untitled>";
+ try:
+ reporter.log('Creating session "%s" ...' % (sName,));
+ self.oGuestSession = self.oTest.oGuest.createSession(self.oCreds.sUser,
+ self.oCreds.sPassword,
+ self.oCreds.sDomain,
+ sName);
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Creating a guest session "%s" failed; sUser="%s", pw="%s", sDomain="%s":'
+ % (sName, self.oCreds.sUser, self.oCreds.sPassword, self.oCreds.sDomain));
+ return (False, None);
+
+ try:
+ reporter.log('Waiting for session "%s" to start within %dms...' % (sName, self.timeoutMS));
+ fWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ waitResult = self.oGuestSession.waitForArray(fWaitFor, self.timeoutMS);
+ #
+ # Be nice to Guest Additions < 4.3: They don't support session handling and
+ # therefore return WaitFlagNotSupported.
+ #
+ if waitResult != vboxcon.GuestSessionWaitResult_Start \
+ and waitResult != vboxcon.GuestSessionWaitResult_WaitFlagNotSupported:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.log('Session did not start successfully, returned wait result: %d' \
+ % (waitResult,));
+ return (False, None);
+ reporter.log('Session "%s" successfully started' % (sName,));
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Waiting for guest session "%s" (usr=%s;pw=%s;dom=%s) to start failed:'
+ % (sName, self.oCreds.sUser, self.oCreds.sPassword, self.oCreds.sDomain,));
+ return (False, None);
+ else:
+ reporter.log('Warning: Session already set; this is probably not what you want');
+ return (True, self.oGuestSession);
+
+ def setSession(self, oGuestSession):
+ """
+ Sets the current guest session and closes
+ an old one if necessary.
+ """
+ if self.oGuestSession is not None:
+ self.closeSession();
+ self.oGuestSession = oGuestSession;
+ return self.oGuestSession;
+
+ def closeSession(self):
+ """
+ Closes the guest session.
+ """
+ if self.oGuestSession is not None:
+ sName = self.oGuestSession.name;
+ try:
+ reporter.log('Closing session "%s" ...' % (sName,));
+ self.oGuestSession.close();
+ self.oGuestSession = None;
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Closing guest session "%s" failed:' % (sName,));
+ return False;
+ return True;
+
+class tdTestCopyFrom(tdTestGuestCtrlBase):
+ """
+ Test for copying files from the guest to the host.
+ """
+ def __init__(self, sSrc = "", sDst = "", sUser = "", sPassword = "", aFlags = None):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sSrc = sSrc;
+ self.sDst = sDst;
+ self.aFlags = aFlags;
+
+class tdTestCopyTo(tdTestGuestCtrlBase):
+ """
+ Test for copying files from the host to the guest.
+ """
+ def __init__(self, sSrc = "", sDst = "", sUser = "", sPassword = "", aFlags = None):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sSrc = sSrc;
+ self.sDst = sDst;
+ self.aFlags = aFlags;
+
+class tdTestDirCreate(tdTestGuestCtrlBase):
+ """
+ Test for directoryCreate call.
+ """
+ def __init__(self, sDirectory = "", sUser = "", sPassword = "", fMode = 0, aFlags = None):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sDirectory = sDirectory;
+ self.fMode = fMode;
+ self.aFlags = aFlags;
+
+class tdTestDirCreateTemp(tdTestGuestCtrlBase):
+ """
+ Test for the directoryCreateTemp call.
+ """
+ def __init__(self, sDirectory = "", sTemplate = "", sUser = "", sPassword = "", fMode = 0, fSecure = False):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sDirectory = sDirectory;
+ self.sTemplate = sTemplate;
+ self.fMode = fMode;
+ self.fSecure = fSecure;
+
+class tdTestDirOpen(tdTestGuestCtrlBase):
+ """
+ Test for the directoryOpen call.
+ """
+ def __init__(self, sDirectory = "", sUser = "", sPassword = "",
+ sFilter = "", aFlags = None):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sDirectory = sDirectory;
+ self.sFilter = sFilter;
+ self.aFlags = aFlags or [];
+
+class tdTestDirRead(tdTestDirOpen):
+ """
+ Test for the opening, reading and closing a certain directory.
+ """
+ def __init__(self, sDirectory = "", sUser = "", sPassword = "",
+ sFilter = "", aFlags = None):
+ tdTestDirOpen.__init__(self, sDirectory, sUser, sPassword, sFilter, aFlags);
+
+class tdTestExec(tdTestGuestCtrlBase):
+ """
+ Specifies exactly one guest control execution test.
+ Has a default timeout of 5 minutes (for safety).
+ """
+ def __init__(self, sCmd = "", aArgs = None, aEnv = None, \
+ aFlags = None, timeoutMS = 5 * 60 * 1000, \
+ sUser = "", sPassword = "", sDomain = "", \
+ fWaitForExit = True):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain);
+ self.sCmd = sCmd;
+ self.aArgs = aArgs if aArgs is not None else [sCmd,];
+ self.aEnv = aEnv;
+ self.aFlags = aFlags or [];
+ self.timeoutMS = timeoutMS;
+ self.fWaitForExit = fWaitForExit;
+ self.uExitStatus = 0;
+ self.iExitCode = 0;
+ self.cbStdOut = 0;
+ self.cbStdErr = 0;
+ self.sBuf = '';
+
+class tdTestFileExists(tdTestGuestCtrlBase):
+ """
+ Test for the file exists API call (fileExists).
+ """
+ def __init__(self, sFile = "", sUser = "", sPassword = ""):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sFile = sFile;
+
+class tdTestFileRemove(tdTestGuestCtrlBase):
+ """
+ Test querying guest file information.
+ """
+ def __init__(self, sFile = "", sUser = "", sPassword = ""):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sFile = sFile;
+
+class tdTestFileStat(tdTestGuestCtrlBase):
+ """
+ Test querying guest file information.
+ """
+ def __init__(self, sFile = "", sUser = "", sPassword = "", cbSize = 0, eFileType = 0):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sFile = sFile;
+ self.cbSize = cbSize;
+ self.eFileType = eFileType;
+
+class tdTestFileIO(tdTestGuestCtrlBase):
+ """
+ Test for the IGuestFile object.
+ """
+ def __init__(self, sFile = "", sUser = "", sPassword = ""):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sFile = sFile;
+
+class tdTestFileQuerySize(tdTestGuestCtrlBase):
+ """
+ Test for the file size query API call (fileQuerySize).
+ """
+ def __init__(self, sFile = "", sUser = "", sPassword = ""):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sFile = sFile;
+
+class tdTestFileReadWrite(tdTestGuestCtrlBase):
+ """
+ Tests reading from guest files.
+ """
+ def __init__(self, sFile = "", sUser = "", sPassword = "",
+ sOpenMode = "r", sDisposition = "",
+ sSharingMode = "",
+ lCreationMode = 0, cbOffset = 0, cbToReadWrite = 0,
+ aBuf = None):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain = "");
+ self.sFile = sFile;
+ self.sOpenMode = sOpenMode;
+ self.sDisposition = sDisposition;
+ self.sSharingMode = sSharingMode;
+ self.lCreationMode = lCreationMode;
+ self.cbOffset = cbOffset;
+ self.cbToReadWrite = cbToReadWrite;
+ self.aBuf = aBuf;
+
+ def getOpenAction(self):
+ """ Converts string disposition to open action enum. """
+ if self.sDisposition == 'oe': return vboxcon.FileOpenAction_OpenExisting;
+ if self.sDisposition == 'oc': return vboxcon.FileOpenAction_OpenOrCreate;
+ if self.sDisposition == 'ce': return vboxcon.FileOpenAction_CreateNew;
+ if self.sDisposition == 'ca': return vboxcon.FileOpenAction_CreateOrReplace;
+ if self.sDisposition == 'ot': return vboxcon.FileOpenAction_OpenExistingTruncated;
+ if self.sDisposition == 'oa': return vboxcon.FileOpenAction_AppendOrCreate;
+ raise base.GenError(self.sDisposition);
+
+ def getAccessMode(self):
+ """ Converts open mode to access mode enum. """
+ if self.sOpenMode == 'r': return vboxcon.FileOpenMode_ReadOnly;
+ if self.sOpenMode == 'w': return vboxcon.FileOpenMode_WriteOnly;
+ if self.sOpenMode == 'w+': return vboxcon.FileOpenMode_ReadWrite;
+ if self.sOpenMode == 'r+': return vboxcon.FileOpenMode_ReadWrite;
+ raise base.GenError(self.sOpenMode);
+
+ def getSharingMode(self):
+ """ Converts the sharing mode. """
+ return vboxcon.FileSharingMode_All;
+
+class tdTestSession(tdTestGuestCtrlBase):
+ """
+ Test the guest session handling.
+ """
+ def __init__(self, sUser = "", sPassword = "", sDomain = "", \
+ sSessionName = ""):
+ tdTestGuestCtrlBase.__init__(self);
+ self.sSessionName = sSessionName;
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain);
+
+ def getSessionCount(self, oVBoxMgr):
+ """
+ Helper for returning the number of currently
+ opened guest sessions of a VM.
+ """
+ if self.oTest.oGuest is None:
+ return 0;
+ aoSession = oVBoxMgr.getArray(self.oTest.oGuest, 'sessions')
+ return len(aoSession);
+
+class tdTestSessionEx(tdTestGuestCtrlBase):
+ """
+ Test the guest session.
+ """
+ def __init__(self, aoSteps = None, enmUser = None):
+ tdTestGuestCtrlBase.__init__(self);
+ assert enmUser is None; # For later.
+ self.enmUser = enmUser;
+ self.aoSteps = aoSteps if aoSteps is not None else [];
+
+ def execute(self, oTstDrv, oVmSession, oTxsSession, oTestVm, sMsgPrefix):
+ """
+ Executes the test.
+ """
+ #
+ # Create a session.
+ #
+ assert self.enmUser is None; # For later.
+ self.oCreds = tdCtxCreds(oTestVm = oTestVm);
+ self.setEnvironment(oVmSession, oTxsSession, oTestVm);
+ reporter.log2('%s: %s steps' % (sMsgPrefix, len(self.aoSteps),));
+ fRc, oCurSession = self.createSession(sMsgPrefix);
+ if fRc is True:
+ #
+ # Execute the tests.
+ #
+ try:
+ fRc = self.executeSteps(oTstDrv, oCurSession, sMsgPrefix);
+ except:
+ reporter.errorXcpt('%s: Unexpected exception executing test steps' % (sMsgPrefix,));
+ fRc = False;
+
+ fRc2 = self.closeSession();
+ if fRc2 is False:
+ reporter.error('%s: Session could not be closed' % (sMsgPrefix,));
+ fRc = False;
+ else:
+ reporter.error('%s: Session creation failed' % (sMsgPrefix,));
+ fRc = False;
+ return fRc;
+
+ def executeSteps(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Executes just the steps.
+ Returns True on success, False on test failure.
+ """
+ fRc = True;
+ for (i, oStep) in enumerate(self.aoSteps):
+ fRc2 = oStep.execute(oTstDrv, oGstCtrlSession, sMsgPrefix + ', step #%d' % i);
+ if fRc2 is True:
+ pass;
+ elif fRc2 is None:
+ reporter.log('skipping remaining %d steps' % (len(self.aoSteps) - i - 1,));
+ break;
+ else:
+ fRc = False;
+ return fRc;
+
+ @staticmethod
+ def executeListTestSessions(aoTests, oTstDrv, oVmSession, oTxsSession, oTestVm, sMsgPrefix):
+ """
+ Works thru a list of tdTestSessionEx object.
+ """
+ fRc = True;
+ for (i, oCurTest) in enumerate(aoTests):
+ try:
+ fRc2 = oCurTest.execute(oTstDrv, oVmSession, oTxsSession, oTestVm, '%s, test %#d' % (sMsgPrefix, i,));
+ if fRc2 is not True:
+ fRc = False;
+ except:
+ reporter.errorXcpt('Unexpected exception executing test #%d' % (i,));
+ fRc = False;
+
+ return (fRc, oTxsSession);
+
+
+class tdSessionStepBase(object):
+ """
+ Base class for the guest control session test steps.
+ """
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Executes the test step.
+
+ Returns True on success.
+ Returns False on failure (must be reported as error).
+ Returns None if to skip the remaining steps.
+ """
+ reporter.error('%s: Missing execute implementation: %s' % (sMsgPrefix, self,));
+ _ = oTstDrv;
+ _ = oGstCtrlSession;
+ return False;
+
+
+class tdStepRequireMinimumApiVer(tdSessionStepBase):
+ """
+ Special test step which will cause executeSteps to skip the remaining step
+ if the VBox API is too old:
+ """
+ def __init__(self, fpMinApiVer):
+ self.fpMinApiVer = fpMinApiVer;
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """ Returns None if API version is too old, otherwise True. """
+ if oTstDrv.fpApiVer >= self.fpMinApiVer:
+ return True;
+ _ = oGstCtrlSession;
+ _ = sMsgPrefix;
+ return None; # Special return value. Don't use elsewhere.
+
+
+#
+# Scheduling Environment Changes with the Guest Control Session.
+#
+
+class tdStepSessionSetEnv(tdSessionStepBase):
+ """
+ Guest session environment: schedule putenv
+ """
+ def __init__(self, sVar, sValue, hrcExpected = 0):
+ self.sVar = sVar;
+ self.sValue = sValue;
+ self.hrcExpected = hrcExpected;
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Executes the step.
+ Returns True on success, False on test failure.
+ """
+ reporter.log2('tdStepSessionSetEnv: sVar=%s sValue=%s hrcExpected=%#x' % (self.sVar, self.sValue, self.hrcExpected,));
+ try:
+ if oTstDrv.fpApiVer >= 5.0:
+ oGstCtrlSession.environmentScheduleSet(self.sVar, self.sValue);
+ else:
+ oGstCtrlSession.environmentSet(self.sVar, self.sValue);
+ except vbox.ComException as oXcpt:
+ # Is this an expected failure?
+ if vbox.ComError.equal(oXcpt, self.hrcExpected):
+ return True;
+ reporter.errorXcpt('%s: Expected hrc=%#x (%s) got %#x (%s) instead (setenv %s=%s)'
+ % (sMsgPrefix, self.hrcExpected, vbox.ComError.toString(self.hrcExpected),
+ vbox.ComError.getXcptResult(oXcpt),
+ vbox.ComError.toString(vbox.ComError.getXcptResult(oXcpt)),
+ self.sVar, self.sValue,));
+ return False;
+ except:
+ reporter.errorXcpt('%s: Unexpected exception in tdStepSessionSetEnv::execute (%s=%s)'
+ % (sMsgPrefix, self.sVar, self.sValue,));
+ return False;
+
+ # Should we succeed?
+ if self.hrcExpected != 0:
+ reporter.error('%s: Expected hrcExpected=%#x, got S_OK (putenv %s=%s)'
+ % (sMsgPrefix, self.hrcExpected, self.sVar, self.sValue,));
+ return False;
+ return True;
+
+class tdStepSessionUnsetEnv(tdSessionStepBase):
+ """
+ Guest session environment: schedule unset.
+ """
+ def __init__(self, sVar, hrcExpected = 0):
+ self.sVar = sVar;
+ self.hrcExpected = hrcExpected;
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Executes the step.
+ Returns True on success, False on test failure.
+ """
+ reporter.log2('tdStepSessionUnsetEnv: sVar=%s hrcExpected=%#x' % (self.sVar, self.hrcExpected,));
+ try:
+ if oTstDrv.fpApiVer >= 5.0:
+ oGstCtrlSession.environmentScheduleUnset(self.sVar);
+ else:
+ oGstCtrlSession.environmentUnset(self.sVar);
+ except vbox.ComException as oXcpt:
+ # Is this an expected failure?
+ if vbox.ComError.equal(oXcpt, self.hrcExpected):
+ return True;
+ reporter.errorXcpt('%s: Expected hrc=%#x (%s) got %#x (%s) instead (unsetenv %s)'
+ % (sMsgPrefix, self.hrcExpected, vbox.ComError.toString(self.hrcExpected),
+ vbox.ComError.getXcptResult(oXcpt),
+ vbox.ComError.toString(vbox.ComError.getXcptResult(oXcpt)),
+ self.sVar,));
+ return False;
+ except:
+ reporter.errorXcpt('%s: Unexpected exception in tdStepSessionUnsetEnv::execute (%s)'
+ % (sMsgPrefix, self.sVar,));
+ return False;
+
+ # Should we succeed?
+ if self.hrcExpected != 0:
+ reporter.error('%s: Expected hrcExpected=%#x, got S_OK (unsetenv %s)'
+ % (sMsgPrefix, self.hrcExpected, self.sVar,));
+ return False;
+ return True;
+
+class tdStepSessionBulkEnv(tdSessionStepBase):
+ """
+ Guest session environment: Bulk environment changes.
+ """
+ def __init__(self, asEnv = None, hrcExpected = 0):
+ self.asEnv = asEnv if asEnv is not None else [];
+ self.hrcExpected = hrcExpected;
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Executes the step.
+ Returns True on success, False on test failure.
+ """
+ reporter.log2('tdStepSessionBulkEnv: asEnv=%s hrcExpected=%#x' % (self.asEnv, self.hrcExpected,));
+ try:
+ if oTstDrv.fpApiVer >= 5.0:
+ oTstDrv.oVBoxMgr.setArray(oGstCtrlSession, 'environmentChanges', self.asEnv);
+ else:
+ oTstDrv.oVBoxMgr.setArray(oGstCtrlSession, 'environment', self.asEnv);
+ except vbox.ComException as oXcpt:
+ # Is this an expected failure?
+ if vbox.ComError.equal(oXcpt, self.hrcExpected):
+ return True;
+ reporter.errorXcpt('%s: Expected hrc=%#x (%s) got %#x (%s) instead (asEnv=%s)'
+ % (sMsgPrefix, self.hrcExpected, vbox.ComError.toString(self.hrcExpected),
+ vbox.ComError.getXcptResult(oXcpt),
+ vbox.ComError.toString(vbox.ComError.getXcptResult(oXcpt)),
+ self.asEnv,));
+ return False;
+ except:
+ reporter.errorXcpt('%s: Unexpected exception writing the environmentChanges property (asEnv=%s).'
+ % (sMsgPrefix, self.asEnv));
+ return False;
+ return True;
+
+class tdStepSessionClearEnv(tdStepSessionBulkEnv):
+ """
+ Guest session environment: clears the scheduled environment changes.
+ """
+ def __init__(self):
+ tdStepSessionBulkEnv.__init__(self);
+
+
+class tdStepSessionCheckEnv(tdSessionStepBase):
+ """
+ Check the currently scheduled environment changes of a guest control session.
+ """
+ def __init__(self, asEnv = None):
+ self.asEnv = asEnv if asEnv is not None else [];
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Executes the step.
+ Returns True on success, False on test failure.
+ """
+ reporter.log2('tdStepSessionCheckEnv: asEnv=%s' % (self.asEnv,));
+
+ #
+ # Get the environment change list.
+ #
+ try:
+ if oTstDrv.fpApiVer >= 5.0:
+ asCurEnv = oTstDrv.oVBoxMgr.getArray(oGstCtrlSession, 'environmentChanges');
+ else:
+ asCurEnv = oTstDrv.oVBoxMgr.getArray(oGstCtrlSession, 'environment');
+ except:
+ reporter.errorXcpt('%s: Unexpected exception reading the environmentChanges property.' % (sMsgPrefix,));
+ return False;
+
+ #
+ # Compare it with the expected one by trying to remove each expected value
+ # and the list anything unexpected.
+ #
+ fRc = True;
+ asCopy = list(asCurEnv); # just in case asCurEnv is immutable
+ for sExpected in self.asEnv:
+ try:
+ asCopy.remove(sExpected);
+ except:
+ reporter.error('%s: Expected "%s" to be in the resulting environment' % (sMsgPrefix, sExpected,));
+ fRc = False;
+ for sUnexpected in asCopy:
+ reporter.error('%s: Unexpected "%s" in the resulting environment' % (sMsgPrefix, sUnexpected,));
+ fRc = False;
+
+ if fRc is not True:
+ reporter.log2('%s: Current environment: %s' % (sMsgPrefix, asCurEnv));
+ return fRc;
+
+
+#
+# File system object statistics (i.e. stat()).
+#
+
+class tdStepStat(tdSessionStepBase):
+ """
+ Stats a file system object.
+ """
+ def __init__(self, sPath, hrcExpected = 0, fFound = True, fFollowLinks = True, enmType = None):
+ self.sPath = sPath;
+ self.hrcExpected = hrcExpected;
+ self.fFound = fFound;
+ self.fFollowLinks = fFollowLinks;
+ self.enmType = enmType if enmType is not None else vboxcon.FsObjType_File;
+ self.cbExactSize = None;
+ self.cbMinSize = None;
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Execute the test step.
+ """
+ reporter.log2('tdStepStat: sPath=%s enmType=%s hrcExpected=%s fFound=%s fFollowLinks=%s'
+ % (self.sPath, self.enmType, self.hrcExpected, self.fFound, self.fFollowLinks,));
+
+ # Don't execute non-file tests on older VBox version.
+ if oTstDrv.fpApiVer >= 5.0 or self.enmType == vboxcon.FsObjType_File or not self.fFound:
+ #
+ # Call the API.
+ #
+ try:
+ if oTstDrv.fpApiVer >= 5.0:
+ oFsInfo = oGstCtrlSession.fsObjQueryInfo(self.sPath, self.fFollowLinks);
+ else:
+ oFsInfo = oGstCtrlSession.fileQueryInfo(self.sPath);
+ except vbox.ComException as oXcpt:
+ ## @todo: The error reporting in the API just plain sucks! Most of the errors are
+ ## VBOX_E_IPRT_ERROR and there seems to be no way to distinguish between
+ ## non-existing files/path and a lot of other errors. Fix API and test!
+ if not self.fFound:
+ return True;
+ if vbox.ComError.equal(oXcpt, self.hrcExpected): # Is this an expected failure?
+ return True;
+ return reporter.errorXcpt('%s: Unexpected exception for exiting path "%s" (enmType=%s, hrcExpected=%s):'
+ % (sMsgPrefix, self.sPath, self.enmType, self.hrcExpected,));
+ except:
+ return reporter.errorXcpt('%s: Unexpected exception in tdStepStat::execute (%s)'
+ % (sMsgPrefix, self.sPath,));
+ if oFsInfo is None:
+ return reporter.error('%s: "%s" got None instead of IFsObjInfo instance!' % (sMsgPrefix, self.sPath,));
+
+ #
+ # Check type expectations.
+ #
+ try:
+ enmType = oFsInfo.type;
+ except:
+ return reporter.errorXcpt('%s: Unexpected exception in reading "IFsObjInfo::type"' % (sMsgPrefix,));
+ if enmType != self.enmType:
+ return reporter.error('%s: "%s" has type %s, expected %s'
+ % (sMsgPrefix, self.sPath, enmType, self.enmType));
+
+ #
+ # Check size expectations.
+ # Note! This is unicode string here on windows, for some reason.
+ # long long mapping perhaps?
+ #
+ try:
+ cbObject = long(oFsInfo.objectSize);
+ except:
+ return reporter.errorXcpt('%s: Unexpected exception in reading "IFsObjInfo::objectSize"'
+ % (sMsgPrefix,));
+ if self.cbExactSize is not None \
+ and cbObject != self.cbExactSize:
+ return reporter.error('%s: "%s" has size %s bytes, expected %s bytes'
+ % (sMsgPrefix, self.sPath, cbObject, self.cbExactSize));
+ if self.cbMinSize is not None \
+ and cbObject < self.cbMinSize:
+ return reporter.error('%s: "%s" has size %s bytes, expected as least %s bytes'
+ % (sMsgPrefix, self.sPath, cbObject, self.cbMinSize));
+ return True;
+
+class tdStepStatDir(tdStepStat):
+ """ Checks for an existing directory. """
+ def __init__(self, sDirPath):
+ tdStepStat.__init__(self, sPath = sDirPath, enmType = vboxcon.FsObjType_Directory);
+
+class tdStepStatFile(tdStepStat):
+ """ Checks for an existing file """
+ def __init__(self, sFilePath):
+ tdStepStat.__init__(self, sPath = sFilePath, enmType = vboxcon.FsObjType_File);
+
+class tdStepStatFileSize(tdStepStat):
+ """ Checks for an existing file of a given expected size.. """
+ def __init__(self, sFilePath, cbExactSize = 0):
+ tdStepStat.__init__(self, sPath = sFilePath, enmType = vboxcon.FsObjType_File);
+ self.cbExactSize = cbExactSize;
+
+class tdStepStatFileNotFound(tdStepStat):
+ """ Checks for an existing directory. """
+ def __init__(self, sPath):
+ tdStepStat.__init__(self, sPath = sPath, fFound = False);
+
+class tdStepStatPathNotFound(tdStepStat):
+ """ Checks for an existing directory. """
+ def __init__(self, sPath):
+ tdStepStat.__init__(self, sPath = sPath, fFound = False);
+
+
+#
+#
+#
+
+class tdTestSessionFileRefs(tdTestGuestCtrlBase):
+ """
+ Tests session file (IGuestFile) reference counting.
+ """
+ def __init__(self, cRefs = 0):
+ tdTestGuestCtrlBase.__init__(self);
+ self.cRefs = cRefs;
+
+class tdTestSessionDirRefs(tdTestGuestCtrlBase):
+ """
+ Tests session directory (IGuestDirectory) reference counting.
+ """
+ def __init__(self, cRefs = 0):
+ tdTestGuestCtrlBase.__init__(self);
+ self.cRefs = cRefs;
+
+class tdTestSessionProcRefs(tdTestGuestCtrlBase):
+ """
+ Tests session process (IGuestProcess) reference counting.
+ """
+ def __init__(self, cRefs = 0):
+ tdTestGuestCtrlBase.__init__(self);
+ self.cRefs = cRefs;
+
+class tdTestUpdateAdditions(tdTestGuestCtrlBase):
+ """
+ Test updating the Guest Additions inside the guest.
+ """
+ def __init__(self, sSrc = "", aArgs = None, aFlags = None,
+ sUser = "", sPassword = "", sDomain = ""):
+ tdTestGuestCtrlBase.__init__(self);
+ self.oCreds = tdCtxCreds(sUser, sPassword, sDomain);
+ self.sSrc = sSrc;
+ self.aArgs = aArgs;
+ self.aFlags = aFlags;
+
+class tdTestResult(object):
+ """
+ Base class for test results.
+ """
+ def __init__(self, fRc = False):
+ ## The overall test result.
+ self.fRc = fRc;
+
+class tdTestResultDirRead(tdTestResult):
+ """
+ Test result for reading guest directories.
+ """
+ def __init__(self, fRc = False,
+ numFiles = 0, numDirs = 0):
+ tdTestResult.__init__(self, fRc = fRc);
+ self.numFiles = numFiles;
+ self.numDirs = numDirs;
+
+class tdTestResultExec(tdTestResult):
+ """
+ Holds a guest process execution test result,
+ including the exit code, status + aFlags.
+ """
+ def __init__(self, fRc = False, \
+ uExitStatus = 500, iExitCode = 0, \
+ sBuf = None, cbBuf = 0, \
+ cbStdOut = 0, cbStdErr = 0):
+ tdTestResult.__init__(self);
+ ## The overall test result.
+ self.fRc = fRc;
+ ## Process exit stuff.
+ self.uExitStatus = uExitStatus;
+ self.iExitCode = iExitCode;
+ ## Desired buffer length returned back from stdout/stderr.
+ self.cbBuf = cbBuf;
+ ## Desired buffer result from stdout/stderr. Use with caution!
+ self.sBuf = sBuf;
+ self.cbStdOut = cbStdOut;
+ self.cbStdErr = cbStdErr;
+
+class tdTestResultFileStat(tdTestResult):
+ """
+ Test result for stat'ing guest files.
+ """
+ def __init__(self, fRc = False,
+ cbSize = 0, eFileType = 0):
+ tdTestResult.__init__(self, fRc = fRc);
+ self.cbSize = cbSize;
+ self.eFileType = eFileType;
+ ## @todo Add more information.
+
+class tdTestResultFileReadWrite(tdTestResult):
+ """
+ Test result for reading + writing guest directories.
+ """
+ def __init__(self, fRc = False,
+ cbProcessed = 0, cbOffset = 0, aBuf = None):
+ tdTestResult.__init__(self, fRc = fRc);
+ self.cbProcessed = cbProcessed;
+ self.cbOffset = cbOffset;
+ self.aBuf = aBuf;
+
+class tdTestResultSession(tdTestResult):
+ """
+ Test result for guest session counts.
+ """
+ def __init__(self, fRc = False, cNumSessions = 0):
+ tdTestResult.__init__(self, fRc = fRc);
+ self.cNumSessions = cNumSessions;
+
+class SubTstDrvAddGuestCtrl(base.SubTestDriverBase):
+ """
+ Sub-test driver for executing guest control (VBoxService, IGuest) tests.
+ """
+
+ def __init__(self, oTstDrv):
+ base.SubTestDriverBase.__init__(self, 'add-guest-ctrl', oTstDrv);
+
+ ## @todo base.TestBase.
+ self.asTestsDef = \
+ [
+ 'session_basic', 'session_env', 'session_file_ref', 'session_dir_ref', 'session_proc_ref',
+ 'exec_basic', 'exec_errorlevel', 'exec_timeout',
+ 'dir_create', 'dir_create_temp', 'dir_read',
+ 'file_remove', 'file_stat', 'file_read', 'file_write',
+ 'copy_to', 'copy_from',
+ 'update_additions'
+ ];
+ self.asTests = self.asTestsDef;
+ self.asRsrcs = ['5.3/guestctrl/50mb_rnd.dat', ];
+
+ def parseOption(self, asArgs, iArg): # pylint: disable=R0912,R0915
+ if asArgs[iArg] == '--add-guest-ctrl-tests':
+ iArg += 1;
+ if asArgs[iArg] == 'all': # Nice for debugging scripts.
+ self.asTests = self.asTestsDef;
+ return iArg + 1;
+
+ iNext = self.oTstDrv.requireMoreArgs(1, asArgs, iArg);
+ self.asTests = asArgs[iArg].split(':');
+ for s in self.asTests:
+ if s not in self.asTestsDef:
+ raise base.InvalidOption('The "--add-guest-ctrl-tests" value "%s" is not valid; valid values are: %s' \
+ % (s, ' '.join(self.asTestsDef)));
+ return iNext;
+ return iArg;
+
+ def showUsage(self):
+ base.SubTestDriverBase.showUsage(self);
+ reporter.log(' --add-guest-ctrl-tests <s1[:s2[:]]>');
+ reporter.log(' Default: %s (all)' % (':'.join(self.asTestsDef)));
+ return True;
+
+ def testIt(self, oTestVm, oSession, oTxsSession):
+ """
+ Executes the test.
+
+ Returns fRc, oTxsSession. The latter may have changed.
+ """
+ reporter.log("Active tests: %s" % (self.asTests,));
+
+ fRc = True;
+
+ # Do the testing.
+ reporter.testStart('Session Basics');
+ fSkip = 'session_basic' not in self.asTests;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlSession(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Session Environment');
+ fSkip = 'session_env' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlSessionEnvironment(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Session File References');
+ fSkip = 'session_file_ref' not in self.asTests;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlSessionFileRefs(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ ## @todo Implement this.
+ #reporter.testStart('Session Directory References');
+ #fSkip = 'session_dir_ref' not in self.asTests;
+ #if fSkip is False:
+ # fRc, oTxsSession = self.testGuestCtrlSessionDirRefs(oSession, oTxsSession, oTestVm);
+ #reporter.testDone(fSkip);
+
+ reporter.testStart('Session Process References');
+ fSkip = 'session_proc_ref' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlSessionProcRefs(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Execution');
+ fSkip = 'exec_basic' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlExec(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Execution Error Levels');
+ fSkip = 'exec_errorlevel' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlExecErrorLevel(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Execution Timeouts');
+ fSkip = 'exec_timeout' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlExecTimeout(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Creating directories');
+ fSkip = 'dir_create' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlDirCreate(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Creating temporary directories');
+ fSkip = 'dir_create_temp' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlDirCreateTemp(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Reading directories');
+ fSkip = 'dir_read' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlDirRead(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Copy to guest');
+ fSkip = 'copy_to' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlCopyTo(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Copy from guest');
+ fSkip = 'copy_from' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlCopyFrom(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Removing files');
+ fSkip = 'file_remove' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlFileRemove(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ reporter.testStart('Querying file information (stat)');
+ fSkip = 'file_stat' not in self.asTests or fRc is False;
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlFileStat(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ # FIXME: Failing tests.
+ # reporter.testStart('File read');
+ # fSkip = 'file_read' not in self.asTests or fRc is False;
+ # if fSkip is False:
+ # fRc, oTxsSession = self.testGuestCtrlFileRead(oSession, oTxsSession, oTestVm);
+ # reporter.testDone(fSkip);
+
+ # reporter.testStart('File write');
+ # fSkip = 'file_write' not in self.asTests or fRc is False;
+ # if fSkip is False:
+ # fRc, oTxsSession = self.testGuestCtrlFileWrite(oSession, oTxsSession, oTestVm);
+ # reporter.testDone(fSkip);
+
+ reporter.testStart('Updating Guest Additions');
+ fSkip = 'update_additions' not in self.asTests or fRc is False;
+ # Skip test for updating Guest Additions if we run on a too old (Windows) guest.
+ fSkip = oTestVm.sKind in ('WindowsNT4', 'Windows2000', 'WindowsXP', 'Windows2003');
+ if fSkip is False:
+ fRc, oTxsSession = self.testGuestCtrlUpdateAdditions(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ return (fRc, oTxsSession);
+
+ def gctrlCopyFileFrom(self, oGuestSession, sSrc, sDst, aFlags):
+ """
+ Helper function to copy a single file from the guest to the host.
+ """
+ fRc = True; # Be optimistic.
+ try:
+ reporter.log2('Copying guest file "%s" to host "%s"' % (sSrc, sDst));
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curProgress = oGuestSession.fileCopyFromGuest(sSrc, sDst, aFlags);
+ else:
+ curProgress = oGuestSession.copyFrom(sSrc, sDst, aFlags);
+ if curProgress is not None:
+ oProgress = vboxwrappers.ProgressWrapper(curProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, "gctrlFileCopyFrom");
+ try:
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = True);
+ fRc = False;
+ except:
+ reporter.logXcpt('Waiting exception for sSrc="%s", sDst="%s":' % (sSrc, sDst));
+ fRc = False;
+ else:
+ reporter.error('No progress object returned');
+ fRc = False;
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Copy from exception for sSrc="%s", sDst="%s":' % (sSrc, sDst));
+ fRc = False;
+
+ return fRc;
+
+ def gctrlCopyFileTo(self, oGuestSession, sSrc, sDst, aFlags):
+ """
+ Helper function to copy a single file from host to the guest.
+ """
+ fRc = True; # Be optimistic.
+ try:
+ reporter.log2('Copying host file "%s" to guest "%s" (flags %s)' % (sSrc, sDst, aFlags));
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curProgress = oGuestSession.fileCopyToGuest(sSrc, sDst, aFlags);
+ else:
+ curProgress = oGuestSession.copyTo(sSrc, sDst, aFlags);
+ if curProgress is not None:
+ oProgress = vboxwrappers.ProgressWrapper(curProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, "gctrlCopyFileTo");
+ try:
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = True);
+ fRc = False;
+ except:
+ reporter.logXcpt('Wait exception for sSrc="%s", sDst="%s":' % (sSrc, sDst));
+ fRc = False;
+ else:
+ reporter.error('No progress object returned');
+ fRc = False;
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Copy to exception for sSrc="%s", sDst="%s":' % (sSrc, sDst));
+ fRc = False;
+
+ return fRc;
+
+ def gctrlCreateDir(self, oTest, oRes, oGuestSession):
+ """
+ Helper function to create a guest directory specified in
+ the current test.
+ """
+ fRc = True; # Be optimistic.
+ reporter.log2('Creating directory "%s"' % (oTest.sDirectory,));
+
+ try:
+ oGuestSession.directoryCreate(oTest.sDirectory, \
+ oTest.fMode, oTest.aFlags);
+ if self.oTstDrv.fpApiVer >= 5.0:
+ fDirExists = oGuestSession.directoryExists(oTest.sDirectory, False);
+ else:
+ fDirExists = oGuestSession.directoryExists(oTest.sDirectory);
+ if fDirExists is False \
+ and oRes.fRc is True:
+ # Directory does not exist but we want it to.
+ fRc = False;
+ except:
+ reporter.logXcpt('Directory create exception for directory "%s":' % (oTest.sDirectory,));
+ if oRes.fRc is True:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ fRc = False;
+ # Directory creation failed, which was the expected result.
+
+ return fRc;
+
+ def gctrlReadDir(self, oTest, oRes, oGuestSession, subDir = ''): # pylint: disable=R0914
+ """
+ Helper function to read a guest directory specified in
+ the current test.
+ """
+ sDir = oTest.sDirectory;
+ sFilter = oTest.sFilter;
+ aFlags = oTest.aFlags;
+
+ fRc = True; # Be optimistic.
+ cDirs = 0; # Number of directories read.
+ cFiles = 0; # Number of files read.
+
+ try:
+ sCurDir = os.path.join(sDir, subDir);
+ #reporter.log2('Directory="%s", filter="%s", aFlags="%s"' % (sCurDir, sFilter, aFlags));
+ oCurDir = oGuestSession.directoryOpen(sCurDir, sFilter, aFlags);
+ while fRc:
+ try:
+ oFsObjInfo = oCurDir.read();
+ if oFsObjInfo.name == "." \
+ or oFsObjInfo.name == "..":
+ #reporter.log2('\tSkipping "%s"' % oFsObjInfo.name);
+ continue; # Skip "." and ".." entries.
+ if oFsObjInfo.type is vboxcon.FsObjType_Directory:
+ #reporter.log2('\tDirectory "%s"' % oFsObjInfo.name);
+ cDirs += 1;
+ sSubDir = oFsObjInfo.name;
+ if subDir != "":
+ sSubDir = os.path.join(subDir, oFsObjInfo.name);
+ fRc, cSubDirs, cSubFiles = self.gctrlReadDir(oTest, oRes, oGuestSession, sSubDir);
+ cDirs += cSubDirs;
+ cFiles += cSubFiles;
+ elif oFsObjInfo.type is vboxcon.FsObjType_File:
+ #reporter.log2('\tFile "%s"' % oFsObjInfo.name);
+ cFiles += 1;
+ elif oFsObjInfo.type is vboxcon.FsObjType_Symlink:
+ #reporter.log2('\tSymlink "%s" -- not tested yet' % oFsObjInfo.name);
+ pass;
+ else:
+ reporter.error('\tDirectory "%s" contains invalid directory entry "%s" (type %d)' % \
+ (sCurDir, oFsObjInfo.name, oFsObjInfo.type));
+ fRc = False;
+ except Exception as oXcpt:
+ # No necessarily an error -- could be VBOX_E_OBJECT_NOT_FOUND. See reference.
+ if vbox.ComError.equal(oXcpt, vbox.ComError.VBOX_E_OBJECT_NOT_FOUND):
+ #reporter.log2('\tNo more directory entries for "%s"' % (sCurDir,));
+ break
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('\tDirectory open exception for directory="%s":' % (sCurDir,));
+ fRc = False;
+ break;
+ oCurDir.close();
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('\tDirectory open exception for directory="%s":' % (sCurDir,));
+ fRc = False;
+
+ return (fRc, cDirs, cFiles);
+
+ def gctrlExecDoTest(self, i, oTest, oRes, oGuestSession):
+ """
+ Wrapper function around gctrlExecute to provide more sanity checking
+ when needed in actual execution tests.
+ """
+ reporter.log('Testing #%d, cmd="%s" ...' % (i, oTest.sCmd));
+ fRc = self.gctrlExecute(oTest, oGuestSession);
+ if fRc is oRes.fRc:
+ if fRc is True:
+ # Compare exit status / code on successful process execution.
+ if oTest.uExitStatus != oRes.uExitStatus \
+ or oTest.iExitCode != oRes.iExitCode:
+ reporter.error('Test #%d failed: Got exit status + code %d,%d, expected %d,%d'
+ % (i, oTest.uExitStatus, oTest.iExitCode, oRes.uExitStatus, oRes.iExitCode));
+ return False;
+ if fRc is True:
+ # Compare test / result buffers on successful process execution.
+ if oTest.sBuf is not None \
+ and oRes.sBuf is not None:
+ if bytes(oTest.sBuf) != bytes(oRes.sBuf):
+ reporter.error('Test #%d failed: Got buffer\n%s (%d bytes), expected\n%s (%d bytes)'
+ % (i, map(hex, map(ord, oTest.sBuf)), len(oTest.sBuf), \
+ map(hex, map(ord, oRes.sBuf)), len(oRes.sBuf)));
+ return False;
+ else:
+ reporter.log2('Test #%d passed: Buffers match (%d bytes)' % (i, len(oRes.sBuf)));
+ elif oRes.sBuf is not None \
+ and oRes.sBuf:
+ reporter.error('Test #%d failed: Got no buffer data, expected\n%s (%dbytes)' %
+ (i, map(hex, map(ord, oRes.sBuf)), len(oRes.sBuf)));
+ return False;
+ elif oRes.cbStdOut > 0 \
+ and oRes.cbStdOut != oTest.cbStdOut:
+ reporter.error('Test #%d failed: Got %d stdout data, expected %d'
+ % (i, oTest.cbStdOut, oRes.cbStdOut));
+ return False;
+ else:
+ reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc, oRes.fRc));
+ return False;
+ return True;
+
+ def gctrlExecute(self, oTest, oGuestSession):
+ """
+ Helper function to execute a program on a guest, specified in
+ the current test.
+ """
+ fRc = True; # Be optimistic.
+
+ ## @todo Compare execution timeouts!
+ #tsStart = base.timestampMilli();
+
+ reporter.log2('Using session user=%s, sDomain=%s, name=%s, timeout=%d' \
+ % (oGuestSession.user, oGuestSession.domain, \
+ oGuestSession.name, oGuestSession.timeout));
+ reporter.log2('Executing sCmd=%s, aFlags=%s, timeoutMS=%d, aArgs=%s, aEnv=%s' \
+ % (oTest.sCmd, oTest.aFlags, oTest.timeoutMS, \
+ oTest.aArgs, oTest.aEnv));
+ try:
+ curProc = oGuestSession.processCreate(oTest.sCmd,
+ oTest.aArgs if self.oTstDrv.fpApiVer >= 5.0 else oTest.aArgs[1:],
+ oTest.aEnv, oTest.aFlags, oTest.timeoutMS);
+ if curProc is not None:
+ reporter.log2('Process start requested, waiting for start (%dms) ...' % (oTest.timeoutMS,));
+ fWaitFor = [ vboxcon.ProcessWaitForFlag_Start ];
+ waitResult = curProc.waitForArray(fWaitFor, oTest.timeoutMS);
+ reporter.log2('Wait result returned: %d, current process status is: %d' % (waitResult, curProc.status));
+
+ if curProc.status == vboxcon.ProcessStatus_Started:
+ fWaitFor = [ vboxcon.ProcessWaitForFlag_Terminate ];
+ if vboxcon.ProcessCreateFlag_WaitForStdOut in oTest.aFlags:
+ fWaitFor.append(vboxcon.ProcessWaitForFlag_StdOut);
+ if vboxcon.ProcessCreateFlag_WaitForStdErr in oTest.aFlags:
+ fWaitFor.append(vboxcon.ProcessWaitForFlag_StdErr);
+ ## @todo Add vboxcon.ProcessWaitForFlag_StdIn.
+ reporter.log2('Process (PID %d) started, waiting for termination (%dms), waitFlags=%s ...' \
+ % (curProc.PID, oTest.timeoutMS, fWaitFor));
+ while True:
+ waitResult = curProc.waitForArray(fWaitFor, oTest.timeoutMS);
+ reporter.log2('Wait returned: %d' % (waitResult,));
+ try:
+ # Try stdout.
+ if waitResult == vboxcon.ProcessWaitResult_StdOut \
+ or waitResult == vboxcon.ProcessWaitResult_WaitFlagNotSupported:
+ reporter.log2('Reading stdout ...');
+ abBuf = curProc.Read(1, 64 * 1024, oTest.timeoutMS);
+ if abBuf:
+ reporter.log2('Process (PID %d) got %d bytes of stdout data' % (curProc.PID, len(abBuf)));
+ oTest.cbStdOut += len(abBuf);
+ oTest.sBuf = abBuf; # Appending does *not* work atm, so just assign it. No time now.
+ # Try stderr.
+ if waitResult == vboxcon.ProcessWaitResult_StdErr \
+ or waitResult == vboxcon.ProcessWaitResult_WaitFlagNotSupported:
+ reporter.log2('Reading stderr ...');
+ abBuf = curProc.Read(2, 64 * 1024, oTest.timeoutMS);
+ if abBuf:
+ reporter.log2('Process (PID %d) got %d bytes of stderr data' % (curProc.PID, len(abBuf)));
+ oTest.cbStdErr += len(abBuf);
+ oTest.sBuf = abBuf; # Appending does *not* work atm, so just assign it. No time now.
+ # Use stdin.
+ if waitResult == vboxcon.ProcessWaitResult_StdIn \
+ or waitResult == vboxcon.ProcessWaitResult_WaitFlagNotSupported:
+ pass; #reporter.log2('Process (PID %d) needs stdin data' % (curProc.pid,));
+ # Termination or error?
+ if waitResult == vboxcon.ProcessWaitResult_Terminate \
+ or waitResult == vboxcon.ProcessWaitResult_Error \
+ or waitResult == vboxcon.ProcessWaitResult_Timeout:
+ reporter.log2('Process (PID %d) reported terminate/error/timeout: %d, status: %d' \
+ % (curProc.PID, waitResult, curProc.status));
+ break;
+ except:
+ # Just skip reads which returned nothing.
+ pass;
+ reporter.log2('Final process status (PID %d) is: %d' % (curProc.PID, curProc.status));
+ reporter.log2('Process (PID %d) %d stdout, %d stderr' % (curProc.PID, oTest.cbStdOut, oTest.cbStdErr));
+ oTest.uExitStatus = curProc.status;
+ oTest.iExitCode = curProc.exitCode;
+ reporter.log2('Process (PID %d) has exit code: %d' % (curProc.PID, oTest.iExitCode));
+ except KeyboardInterrupt:
+ reporter.error('Process (PID %d) execution interrupted' % (curProc.PID,));
+ if curProc is not None:
+ curProc.close();
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Execution exception for command "%s":' % (oTest.sCmd,));
+ fRc = False;
+
+ return fRc;
+
+ def testGuestCtrlSessionEnvironment(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests the guest session environment changes.
+ """
+ aoTests = [
+ # Check basic operations.
+ tdTestSessionEx([ # Initial environment is empty.
+ tdStepSessionCheckEnv(),
+ # Check clearing empty env.
+ tdStepSessionClearEnv(),
+ tdStepSessionCheckEnv(),
+ # Check set.
+ tdStepSessionSetEnv('FOO', 'BAR'),
+ tdStepSessionCheckEnv(['FOO=BAR',]),
+ tdStepRequireMinimumApiVer(5.0), # 4.3 can't cope with the remainder.
+ tdStepSessionClearEnv(),
+ tdStepSessionCheckEnv(),
+ # Check unset.
+ tdStepSessionUnsetEnv('BAR'),
+ tdStepSessionCheckEnv(['BAR']),
+ tdStepSessionClearEnv(),
+ tdStepSessionCheckEnv(),
+ # Set + unset.
+ tdStepSessionSetEnv('FOO', 'BAR'),
+ tdStepSessionCheckEnv(['FOO=BAR',]),
+ tdStepSessionUnsetEnv('FOO'),
+ tdStepSessionCheckEnv(['FOO']),
+ # Bulk environment changes (via attrib) (shall replace existing 'FOO').
+ tdStepSessionBulkEnv( ['PATH=/bin:/usr/bin', 'TMPDIR=/var/tmp', 'USER=root']),
+ tdStepSessionCheckEnv(['PATH=/bin:/usr/bin', 'TMPDIR=/var/tmp', 'USER=root']),
+ ]),
+ tdTestSessionEx([ # Check that setting the same value several times works.
+ tdStepSessionSetEnv('FOO','BAR'),
+ tdStepSessionCheckEnv([ 'FOO=BAR',]),
+ tdStepSessionSetEnv('FOO','BAR2'),
+ tdStepSessionCheckEnv([ 'FOO=BAR2',]),
+ tdStepSessionSetEnv('FOO','BAR3'),
+ tdStepSessionCheckEnv([ 'FOO=BAR3',]),
+ tdStepRequireMinimumApiVer(5.0), # 4.3 can't cope with the remainder.
+ # Add a little unsetting to the mix.
+ tdStepSessionSetEnv('BAR', 'BEAR'),
+ tdStepSessionCheckEnv([ 'FOO=BAR3', 'BAR=BEAR',]),
+ tdStepSessionUnsetEnv('FOO'),
+ tdStepSessionCheckEnv([ 'FOO', 'BAR=BEAR',]),
+ tdStepSessionSetEnv('FOO','BAR4'),
+ tdStepSessionCheckEnv([ 'FOO=BAR4', 'BAR=BEAR',]),
+ # The environment is case sensitive.
+ tdStepSessionSetEnv('foo','BAR5'),
+ tdStepSessionCheckEnv([ 'FOO=BAR4', 'BAR=BEAR', 'foo=BAR5']),
+ tdStepSessionUnsetEnv('foo'),
+ tdStepSessionCheckEnv([ 'FOO=BAR4', 'BAR=BEAR', 'foo']),
+ ]),
+ tdTestSessionEx([ # Bulk settings merges stuff, last entry standing.
+ tdStepSessionBulkEnv(['FOO=bar', 'foo=bar', 'FOO=doofus', 'TMPDIR=/tmp', 'foo=bar2']),
+ tdStepSessionCheckEnv(['FOO=doofus', 'TMPDIR=/tmp', 'foo=bar2']),
+ tdStepRequireMinimumApiVer(5.0), # 4.3 is buggy!
+ tdStepSessionBulkEnv(['2=1+1', 'FOO=doofus2', ]),
+ tdStepSessionCheckEnv(['2=1+1', 'FOO=doofus2' ]),
+ ]),
+ # Invalid variable names.
+ tdTestSessionEx([
+ tdStepSessionSetEnv('', 'FOO', vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepRequireMinimumApiVer(5.0), # 4.3 is too relaxed checking input!
+ tdStepSessionSetEnv('=', '===', vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionSetEnv('FOO=', 'BAR', vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionSetEnv('=FOO', 'BAR', vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepRequireMinimumApiVer(5.0), # 4.3 is buggy and too relaxed!
+ tdStepSessionBulkEnv(['', 'foo=bar'], vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionBulkEnv(['=', 'foo=bar'], vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionBulkEnv(['=FOO', 'foo=bar'], vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ ]),
+ # A bit more weird keys/values.
+ tdTestSessionEx([ tdStepSessionSetEnv('$$$', ''),
+ tdStepSessionCheckEnv([ '$$$=',]), ]),
+ tdTestSessionEx([ tdStepSessionSetEnv('$$$', '%%%'),
+ tdStepSessionCheckEnv([ '$$$=%%%',]),
+ ]),
+ tdTestSessionEx([ tdStepRequireMinimumApiVer(5.0), # 4.3 is buggy!
+ tdStepSessionSetEnv(u'ß$%ß&', ''),
+ tdStepSessionCheckEnv([ u'ß$%ß&=',]),
+ ]),
+ # Misc stuff.
+ tdTestSessionEx([ tdStepSessionSetEnv('FOO', ''),
+ tdStepSessionCheckEnv(['FOO=',]),
+ ]),
+ tdTestSessionEx([ tdStepSessionSetEnv('FOO', 'BAR'),
+ tdStepSessionCheckEnv(['FOO=BAR',])
+ ],),
+ tdTestSessionEx([ tdStepSessionSetEnv('FOO', 'BAR'),
+ tdStepSessionSetEnv('BAR', 'BAZ'),
+ tdStepSessionCheckEnv([ 'FOO=BAR', 'BAR=BAZ',]),
+ ]),
+ ];
+ return tdTestSessionEx.executeListTestSessions(aoTests, self.oTstDrv, oSession, oTxsSession, oTestVm, 'SessionEnv');
+
+ def testGuestCtrlSession(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests the guest session handling.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ aaTests = [
+ # Invalid parameters.
+ [ tdTestSession(),
+ tdTestResultSession(fRc = False) ],
+ [ tdTestSession(sUser = ''),
+ tdTestResultSession(fRc = False) ],
+ [ tdTestSession(sPassword = 'bar'),
+ tdTestResultSession(fRc = False) ],
+ [ tdTestSession(sDomain = 'boo'),
+ tdTestResultSession(fRc = False) ],
+ [ tdTestSession(sPassword = 'bar', sDomain = 'boo'),
+ tdTestResultSession(fRc = False) ],
+ # User account without a passwort - forbidden.
+ [ tdTestSession(sUser = sUser),
+ tdTestResultSession(fRc = False) ],
+ # Wrong credentials.
+ # Note: On Guest Additions < 4.3 this always succeeds because these don't
+ # support creating dedicated sessions. Instead, guest process creation
+ # then will fail. See note below.
+ [ tdTestSession(sUser = 'foo', sPassword = 'bar', sDomain = 'boo'),
+ tdTestResultSession(fRc = False) ],
+ # Correct credentials.
+ [ tdTestSession(sUser = sUser, sPassword = sPassword),
+ tdTestResultSession(fRc = True, cNumSessions = 1) ]
+ ];
+
+ # Parameters.
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestSession, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ reporter.log('Testing #%d, user="%s", sPassword="%s", sDomain="%s" ...' \
+ % (i, curTest.oCreds.sUser, curTest.oCreds.sPassword, curTest.oCreds.sDomain));
+ curGuestSessionName = 'testGuestCtrlSession: Test #%d' % (i);
+ fRc2, curGuestSession = curTest.createSession(curGuestSessionName);
+ # See note about < 4.3 Guest Additions above.
+ if curGuestSession is not None \
+ and curGuestSession.protocolVersion >= 2 \
+ and fRc2 is not curRes.fRc:
+ reporter.error('Test #%d failed: Session creation failed: Got %s, expected %s' \
+ % (i, fRc2, curRes.fRc));
+ fRc = False;
+ if fRc2:
+ # On Guest Additions < 4.3 getSessionCount() always will return 1, so skip the
+ # check then.
+ if curGuestSession.protocolVersion >= 2:
+ curSessionCount = curTest.getSessionCount(self.oTstDrv.oVBoxMgr);
+ if curSessionCount is not curRes.cNumSessions:
+ reporter.error('Test #%d failed: Session count does not match: Got %d, expected %d' \
+ % (i, curSessionCount, curRes.cNumSessions));
+ fRc = False;
+ break;
+ if curGuestSession is not None \
+ and curGuestSession.name != curGuestSessionName:
+ reporter.error('Test #%d failed: Session name does not match: Got "%s", expected "%s"' \
+ % (i, curGuestSession.name, curGuestSessionName));
+ fRc = False;
+ break;
+ fRc2 = curTest.closeSession();
+ if fRc2 is False:
+ reporter.error('Test #%d failed: Session could not be closed' % (i,));
+ fRc = False;
+ break;
+
+ if fRc is False:
+ return (False, oTxsSession);
+
+ # Multiple sessions.
+ iMaxGuestSessions = 31; # Maximum number of concurrent guest session allowed.
+ # Actually, this is 32, but we don't test session 0.
+ multiSession = {};
+ reporter.log2('Opening multiple guest tsessions at once ...');
+ for i in range(iMaxGuestSessions + 1):
+ multiSession[i] = tdTestSession(sUser = sUser, sPassword = sPassword, sSessionName = 'MultiSession #%d' % (i,));
+ multiSession[i].setEnvironment(oSession, oTxsSession, oTestVm);
+ curSessionCount = multiSession[i].getSessionCount(self.oTstDrv.oVBoxMgr);
+ reporter.log2('MultiSession test #%d count is %d' % (i, curSessionCount));
+ if curSessionCount is not i:
+ reporter.error('MultiSession count #%d must be %d, got %d' % (i, i, curSessionCount));
+ fRc = False;
+ break;
+ fRc2, _ = multiSession[i].createSession('MultiSession #%d' % (i,));
+ if fRc2 is not True:
+ if i < iMaxGuestSessions:
+ reporter.error('MultiSession #%d test failed' % (i,));
+ fRc = False;
+ else:
+ reporter.log('MultiSession #%d exceeded concurrent guest session count, good' % (i,));
+ break;
+
+ curSessionCount = multiSession[i].getSessionCount(self.oTstDrv.oVBoxMgr);
+ if curSessionCount is not iMaxGuestSessions:
+ reporter.error('Final MultiSession count must be %d, got %d'
+ % (iMaxGuestSessions, curSessionCount));
+ return (False, oTxsSession);
+
+ reporter.log2('Closing MultiSessions ...');
+ iLastSession = iMaxGuestSessions - 1;
+ for i in range(iLastSession): # Close all but the last opened session.
+ fRc2 = multiSession[i].closeSession();
+ reporter.log2('MultiSession #%d count is %d' % (i, multiSession[i].getSessionCount(self.oTstDrv.oVBoxMgr),));
+ if fRc2 is False:
+ reporter.error('Closing MultiSession #%d failed' % (i,));
+ fRc = False;
+ break;
+ curSessionCount = multiSession[i].getSessionCount(self.oTstDrv.oVBoxMgr);
+ if curSessionCount is not 1:
+ reporter.error('Final MultiSession count #2 must be 1, got %d' % (curSessionCount,));
+ fRc = False;
+
+ try:
+ # r=bird: multiSession[0].oGuestSession is None! Why don't you just use 'assert' or 'if' to check
+ # the functioning of the __testcase__?
+
+ # Make sure that accessing the first opened guest session does not work anymore because we just removed (closed) it.
+ curSessionName = multiSession[0].oGuestSession.name;
+ reporter.error('Accessing first removed MultiSession should not be possible, got name="%s"' % (curSessionName,));
+ fRc = False;
+ except:
+ reporter.logXcpt('Could not access first removed MultiSession object, good:');
+
+ try:
+ # Try Accessing last opened session which did not get removed yet.
+ curSessionName = multiSession[iLastSession].oGuestSession.name;
+ reporter.log('Accessing last standing MultiSession worked, got name="%s"' % (curSessionName,));
+ multiSession[iLastSession].closeSession();
+ curSessionCount = multiSession[i].getSessionCount(self.oTstDrv.oVBoxMgr);
+ if curSessionCount is not 0:
+ reporter.error('Final MultiSession count #3 must be 0, got %d' % (curSessionCount,));
+ fRc = False;
+ except:
+ reporter.logXcpt('Could not access last standing MultiSession object:');
+ fRc = False;
+
+ ## @todo Test session timeouts.
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlSessionFileRefs(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests the guest session file reference handling.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ sPassword = "password";
+ sDomain = "";
+ sFile = "C:\\windows\\system32\\kernel32.dll";
+
+ # Number of stale guest files to create.
+ cStaleFiles = 10;
+
+ fRc = True;
+ try:
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(sUser, sPassword, sDomain, \
+ "testGuestCtrlSessionFileRefs");
+ fWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ waitResult = oGuestSession.waitForArray(fWaitFor, 30 * 1000);
+ #
+ # Be nice to Guest Additions < 4.3: They don't support session handling and
+ # therefore return WaitFlagNotSupported.
+ #
+ if waitResult != vboxcon.GuestSessionWaitResult_Start \
+ and waitResult != vboxcon.GuestSessionWaitResult_WaitFlagNotSupported:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.log('Session did not start successfully, returned wait result: %d' \
+ % (waitResult));
+ return (False, oTxsSession);
+ reporter.log('Session successfully started');
+
+ #
+ # Open guest files and "forget" them (stale entries).
+ # For them we don't have any references anymore intentionally.
+ #
+ reporter.log2('Opening stale files');
+ for i in range(0, cStaleFiles):
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ oGuestSession.fileOpen(sFile, vboxcon.FileAccessMode_ReadOnly, vboxcon.FileOpenAction_OpenExisting, 0);
+ else:
+ oGuestSession.fileOpen(sFile, "r", "oe", 0);
+ # Note: Use a timeout in the call above for not letting the stale processes
+ # hanging around forever. This can happen if the installed Guest Additions
+ # do not support terminating guest processes.
+ except:
+ reporter.errorXcpt('Opening stale file #%d failed:' % (i,));
+ fRc = False;
+ break;
+
+ if fRc:
+ cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ if cFiles != cStaleFiles:
+ reporter.error('Test failed: Got %d stale files, expected %d' % (cFiles, cStaleFiles));
+ fRc = False;
+
+ if fRc:
+ #
+ # Open non-stale files and close them again.
+ #
+ reporter.log2('Opening non-stale files');
+ aaFiles = [];
+ for i in range(0, cStaleFiles):
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ oCurFile = oGuestSession.fileOpen(sFile, vboxcon.FileAccessMode_ReadOnly,
+ vboxcon.FileOpenAction_OpenExisting, 0);
+ else:
+ oCurFile = oGuestSession.fileOpen(sFile, "r", "oe", 0);
+ aaFiles.append(oCurFile);
+ except:
+ reporter.errorXcpt('Opening non-stale file #%d failed:' % (i,));
+ fRc = False;
+ break;
+ if fRc:
+ cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ if cFiles != cStaleFiles * 2:
+ reporter.error('Test failed: Got %d total files, expected %d' % (cFiles, cStaleFiles * 2));
+ fRc = False;
+ if fRc:
+ reporter.log2('Closing all non-stale files again ...');
+ for i in range(0, cStaleFiles):
+ try:
+ aaFiles[i].close();
+ except:
+ reporter.errorXcpt('Waiting for non-stale file #%d failed:' % (i,));
+ fRc = False;
+ break;
+ cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ # Here we count the stale files (that is, files we don't have a reference
+ # anymore for) and the opened and then closed non-stale files (that we still keep
+ # a reference in aaFiles[] for).
+ if cFiles != cStaleFiles:
+ reporter.error('Test failed: Got %d total files, expected %d' \
+ % (cFiles, cStaleFiles));
+ fRc = False;
+ if fRc:
+ #
+ # Check if all (referenced) non-stale files now are in "closed" state.
+ #
+ reporter.log2('Checking statuses of all non-stale files ...');
+ for i in range(0, cStaleFiles):
+ try:
+ curFilesStatus = aaFiles[i].status;
+ if curFilesStatus != vboxcon.FileStatus_Closed:
+ reporter.error('Test failed: Non-stale file #%d has status %d, expected %d' \
+ % (i, curFilesStatus, vboxcon.FileStatus_Closed));
+ fRc = False;
+ except:
+ reporter.errorXcpt('Checking status of file #%d failed:' % (i,));
+ fRc = False;
+ break;
+ if fRc:
+ reporter.log2('All non-stale files closed');
+ cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ reporter.log2('Final guest session file count: %d' % (cFiles,));
+ # Now try to close the session and see what happens.
+ reporter.log2('Closing guest session ...');
+ oGuestSession.close();
+ except:
+ reporter.errorXcpt('Testing for stale processes failed:');
+ fRc = False;
+
+ return (fRc, oTxsSession);
+
+ #def testGuestCtrlSessionDirRefs(self, oSession, oTxsSession, oTestVm):
+ # """
+ # Tests the guest session directory reference handling.
+ # """
+
+ # fRc = True;
+ # return (fRc, oTxsSession);
+
+ def testGuestCtrlSessionProcRefs(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests the guest session process reference handling.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ sPassword = "password";
+ sDomain = "";
+ sCmd = "C:\\windows\\system32\\cmd.exe";
+ aArgs = [sCmd,];
+
+ # Number of stale guest processes to create.
+ cStaleProcs = 10;
+
+ fRc = True;
+ try:
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(sUser, sPassword, sDomain, \
+ "testGuestCtrlSessionProcRefs");
+ fWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ waitResult = oGuestSession.waitForArray(fWaitFor, 30 * 1000);
+ #
+ # Be nice to Guest Additions < 4.3: They don't support session handling and
+ # therefore return WaitFlagNotSupported.
+ #
+ if waitResult != vboxcon.GuestSessionWaitResult_Start \
+ and waitResult != vboxcon.GuestSessionWaitResult_WaitFlagNotSupported:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.log('Session did not start successfully, returned wait result: %d' \
+ % (waitResult));
+ return (False, oTxsSession);
+ reporter.log('Session successfully started');
+
+ #
+ # Fire off forever-running processes and "forget" them (stale entries).
+ # For them we don't have any references anymore intentionally.
+ #
+ reporter.log2('Starting stale processes');
+ for i in range(0, cStaleProcs):
+ try:
+ oGuestSession.processCreate(sCmd,
+ aArgs if self.oTstDrv.fpApiVer >= 5.0 else aArgs[1:], [],
+ [ vboxcon.ProcessCreateFlag_WaitForStdOut ], \
+ 30 * 1000);
+ # Note: Use a timeout in the call above for not letting the stale processes
+ # hanging around forever. This can happen if the installed Guest Additions
+ # do not support terminating guest processes.
+ except:
+ reporter.logXcpt('Creating stale process #%d failed:' % (i,));
+ fRc = False;
+ break;
+
+ if fRc:
+ cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ if cProcs != cStaleProcs:
+ reporter.error('Test failed: Got %d stale processes, expected %d' % (cProcs, cStaleProcs));
+ fRc = False;
+
+ if fRc:
+ #
+ # Fire off non-stale processes and wait for termination.
+ #
+ if oTestVm.isWindows():
+ aArgs = [ sCmd, '/C', 'dir', '/S', 'C:\\Windows\\system'];
+ reporter.log2('Starting non-stale processes');
+ aaProcs = [];
+ for i in range(0, cStaleProcs):
+ try:
+ oCurProc = oGuestSession.processCreate(sCmd, aArgs if self.oTstDrv.fpApiVer >= 5.0 else aArgs[1:],
+ [], [], 0); # Infinite timeout.
+ aaProcs.append(oCurProc);
+ except:
+ reporter.logXcpt('Creating non-stale process #%d failed:' % (i,));
+ fRc = False;
+ break;
+ if fRc:
+ reporter.log2('Waiting for non-stale processes to terminate');
+ for i in range(0, cStaleProcs):
+ try:
+ aaProcs[i].waitForArray([ vboxcon.ProcessWaitForFlag_Terminate ], 30 * 1000);
+ curProcStatus = aaProcs[i].status;
+ if aaProcs[i].status != vboxcon.ProcessStatus_TerminatedNormally:
+ reporter.error('Test failed: Waiting for non-stale processes #%d'
+ ' resulted in status %d, expected %d' \
+ % (i, curProcStatus, vboxcon.ProcessStatus_TerminatedNormally));
+ fRc = False;
+ except:
+ reporter.logXcpt('Waiting for non-stale process #%d failed:' % (i,));
+ fRc = False;
+ break;
+ cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ # Here we count the stale processes (that is, processes we don't have a reference
+ # anymore for) and the started + terminated non-stale processes (that we still keep
+ # a reference in aaProcs[] for).
+ if cProcs != (cStaleProcs * 2):
+ reporter.error('Test failed: Got %d total processes, expected %d' \
+ % (cProcs, cStaleProcs));
+ fRc = False;
+ if fRc:
+ #
+ # Check if all (referenced) non-stale processes now are in "terminated" state.
+ #
+ for i in range(0, cStaleProcs):
+ curProcStatus = aaProcs[i].status;
+ if aaProcs[i].status != vboxcon.ProcessStatus_TerminatedNormally:
+ reporter.error('Test failed: Non-stale processes #%d has status %d, expected %d' \
+ % (i, curProcStatus, vboxcon.ProcessStatus_TerminatedNormally));
+ fRc = False;
+ if fRc:
+ reporter.log2('All non-stale processes terminated');
+
+ # Fire off blocking processes which are terminated via terminate().
+ if oTestVm.isWindows():
+ aArgs = [ sCmd, '/C', 'dir', '/S', 'C:\\Windows'];
+ reporter.log2('Starting blocking processes');
+ aaProcs = [];
+ for i in range(0, cStaleProcs):
+ try:
+ oCurProc = oGuestSession.processCreate(sCmd, aArgs if self.oTstDrv.fpApiVer >= 5.0 else aArgs[1:],
+ [], [], 30 * 1000);
+ # Note: Use a timeout in the call above for not letting the stale processes
+ # hanging around forever. This can happen if the installed Guest Additions
+ # do not support terminating guest processes.
+ aaProcs.append(oCurProc);
+ except:
+ reporter.logXcpt('Creating blocking process failed:');
+ fRc = False;
+ break;
+ if fRc:
+ reporter.log2('Terminating blocking processes');
+ for i in range(0, cStaleProcs):
+ try:
+ aaProcs[i].terminate();
+ except: # Termination might not be supported, just skip and log it.
+ reporter.logXcpt('Termination of blocking process failed, skipped:');
+ cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ if cProcs != (cStaleProcs * 2): # Still should be 20 processes because we terminated the 10 newest ones.
+ reporter.error('Test failed: Got %d total processes, expected %d' % (cProcs, cStaleProcs * 2));
+ fRc = False;
+ cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ reporter.log2('Final guest session processes count: %d' % (cProcs,));
+ # Now try to close the session and see what happens.
+ reporter.log2('Closing guest session ...');
+ oGuestSession.close();
+ except:
+ reporter.logXcpt('Testing for stale processes failed:');
+ fRc = False;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlExec(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914,R0915
+ """
+ Tests the basic execution feature.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ if oTestVm.isWindows():
+ # Outputting stuff.
+ sImageOut = "C:\\windows\\system32\\cmd.exe";
+ else:
+ reporter.error('Implement me!'); ## @todo Implement non-Windows bits.
+ return (False, oTxsSession);
+
+ aaInvalid = [
+ # Invalid parameters.
+ [ tdTestExec(sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = False) ],
+ # Non-existent / invalid image.
+ [ tdTestExec(sCmd = "non-existent", sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = False) ],
+ [ tdTestExec(sCmd = "non-existent2", sUser = sUser, sPassword = sPassword, fWaitForExit = True),
+ tdTestResultExec(fRc = False) ],
+ # Use an invalid format string.
+ [ tdTestExec(sCmd = "%$%%%&", sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = False) ],
+ # More stuff.
+ [ tdTestExec(sCmd = u"ƒ‰‹ˆ÷‹¸", sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = False) ],
+ [ tdTestExec(sCmd = "???://!!!", sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = False) ],
+ [ tdTestExec(sCmd = "<>!\\", sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = False) ]
+ # Enable as soon as ERROR_BAD_DEVICE is implemented.
+ #[ tdTestExec(sCmd = "CON", sUser = sUser, sPassword = sPassword),
+ # tdTestResultExec(fRc = False) ]
+ ];
+
+ if oTestVm.isWindows():
+ sVBoxControl = "C:\\Program Files\\Oracle\\VirtualBox Guest Additions\\VBoxControl.exe";
+ aaExec = [
+ # Basic executon.
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'c:\\windows\\system32' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'c:\\windows\\system32\\kernel32.dll' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'c:\\windows\\system32\\nonexist.dll' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', '/wrongparam' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # Paths with spaces.
+ ## @todo Get path of installed Guest Additions. Later.
+ [ tdTestExec(sCmd = sVBoxControl, aArgs = [ sVBoxControl, 'version' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True) ],
+ # StdOut.
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'c:\\windows\\system32' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'stdout-non-existing' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # StdErr.
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'c:\\windows\\system32' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'stderr-non-existing' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # StdOut + StdErr.
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'c:\\windows\\system32' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir', '/S', 'stdouterr-non-existing' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ]
+ # FIXME: Failing tests.
+ # Environment variables.
+ # [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'set', 'TEST_NONEXIST' ],
+ # sUser = sUser, sPassword = sPassword),
+ # tdTestResultExec(fRc = True, iExitCode = 1) ]
+ # [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'set', 'windir' ],
+ # sUser = sUser, sPassword = sPassword,
+ # aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, sBuf = 'windir=C:\\WINDOWS\r\n') ],
+ # [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'set', 'TEST_FOO' ],
+ # sUser = sUser, sPassword = sPassword,
+ # aEnv = [ 'TEST_FOO=BAR' ],
+ # aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, sBuf = 'TEST_FOO=BAR\r\n') ],
+ # [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'set', 'TEST_FOO' ],
+ # sUser = sUser, sPassword = sPassword,
+ # aEnv = [ 'TEST_FOO=BAR', 'TEST_BAZ=BAR' ],
+ # aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, sBuf = 'TEST_FOO=BAR\r\n') ]
+
+ ## @todo Create some files (or get files) we know the output size of to validate output length!
+ ## @todo Add task which gets killed at some random time while letting the guest output something.
+ ];
+
+ # Manual test, not executed automatically.
+ aaManual = [
+ [ tdTestExec(sCmd = sImageOut, aArgs = [ sImageOut, '/C', 'dir /S C:\\Windows' ],
+ sUser = sUser, sPassword = sPassword,
+ aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ tdTestResultExec(fRc = True, cbStdOut = 497917) ] ];
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ # Build up the final test array for the first batch.
+ aaTests = [];
+ aaTests.extend(aaInvalid);
+ if aaExec is not None:
+ aaTests.extend(aaExec);
+ fRc = True;
+
+ #
+ # Single execution stuff. Nice for debugging.
+ #
+ fManual = False;
+ if fManual:
+ curTest = aaTests[1][0]; # tdTestExec, use an index, later.
+ curRes = aaTests[1][1]; # tdTestResultExec
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlExec: Single test 1');
+ if fRc is False:
+ reporter.error('Single test failed: Could not create session');
+ else:
+ fRc = self.gctrlExecDoTest(0, curTest, curRes, curGuestSession);
+ curTest.closeSession();
+
+ curTest = aaTests[2][0]; # tdTestExec, use an index, later.
+ curRes = aaTests[2][1]; # tdTestResultExec
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlExec: Single test 2');
+ if fRc is False:
+ reporter.error('Single test failed: Could not create session');
+ else:
+ fRc = self.gctrlExecDoTest(0, curTest, curRes, curGuestSession);
+ curTest.closeSession();
+
+ curTest = aaTests[3][0]; # tdTestExec, use an index, later.
+ curRes = aaTests[3][1]; # tdTestResultExec
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlExec: Single test 3');
+ if fRc is False:
+ reporter.error('Single test failed: Could not create session');
+ else:
+ fRc = self.gctrlExecDoTest(0, curTest, curRes, curGuestSession);
+ curTest.closeSession();
+ return (fRc, oTxsSession);
+ else:
+ aaManual = aaManual; # Workaround for pylint #W0612.
+
+ if fRc is False:
+ return (fRc, oTxsSession);
+
+ #
+ # First batch: One session per guest process.
+ #
+ reporter.log('One session per guest process ...');
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResultExec
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlExec: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ fRc = self.gctrlExecDoTest(i, curTest, curRes, curGuestSession);
+ if fRc is False:
+ break;
+ fRc = curTest.closeSession();
+ if fRc is False:
+ break;
+
+ # No sessions left?
+ if fRc is True:
+ aSessions = self.oTstDrv.oVBoxMgr.getArray(oSession.o.console.guest, 'sessions');
+ cSessions = len(aSessions);
+ if cSessions is not 0:
+ reporter.error('Found %d stale session(s), expected 0:' % (cSessions,));
+ for (i, aSession) in enumerate(aSessions):
+ reporter.log('\tStale session #%d ("%s")' % (aSession.id, aSession.name));
+ fRc = False;
+
+ if fRc is False:
+ return (fRc, oTxsSession);
+
+ reporter.log('Now using one guest session for all tests ...');
+
+ #
+ # Second batch: One session for *all* guest processes.
+ #
+ oGuest = oSession.o.console.guest;
+ try:
+ reporter.log('Creating session for all tests ...');
+ curGuestSession = oGuest.createSession(sUser, sPassword, '', 'testGuestCtrlExec: One session for all tests');
+ try:
+ fWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ waitResult = curGuestSession.waitForArray(fWaitFor, 30 * 1000);
+ if waitResult != vboxcon.GuestSessionWaitResult_Start \
+ and waitResult != vboxcon.GuestSessionWaitResult_WaitFlagNotSupported:
+ reporter.error('Session did not start successfully, returned wait result: %d' \
+ % (waitResult));
+ return (False, oTxsSession);
+ reporter.log('Session successfully started');
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Waiting for guest session to start failed:');
+ return (False, oTxsSession);
+ # Note: Not waiting for the guest session to start here
+ # is intentional. This must be handled by the process execution
+ # call then.
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResultExec
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc = self.gctrlExecDoTest(i, curTest, curRes, curGuestSession);
+ if fRc is False:
+ break;
+ try:
+ reporter.log2('Closing guest session ...');
+ curGuestSession.close();
+ curGuestSession = None;
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Closing guest session failed:');
+ fRc = False;
+ except:
+ reporter.logXcpt('Could not create one session:');
+
+ # No sessions left?
+ if fRc is True:
+ cSessions = len(self.oTstDrv.oVBoxMgr.getArray(oSession.o.console.guest, 'sessions'));
+ if cSessions is not 0:
+ reporter.error('Found %d stale session(s), expected 0' % (cSessions,));
+ fRc = False;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlExecErrorLevel(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests handling of error levels from started guest processes.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ if oTestVm.isWindows():
+ # Outputting stuff.
+ sImage = "C:\\windows\\system32\\cmd.exe";
+ else:
+ reporter.error('Implement me!'); ## @todo Implement non-Windows bits.
+ return (False, oTxsSession);
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Simple.
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'wrongcommand' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'exit', '22' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 22) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'set', 'ERRORLEVEL=234' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 0) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'echo', '%WINDIR%' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 0) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'set', 'ERRORLEVEL=0' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 0) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\windows\\system32' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 0) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\windows\\system32\\kernel32.dll' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 0) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-file' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-dir\\' ],
+ sUser = sUser, sPassword = sPassword),
+ tdTestResultExec(fRc = True, iExitCode = 1) ]
+ # FIXME: Failing tests.
+ # With stdout.
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\windows\\system32' ],
+ # sUser = sUser, sPassword = sPassword, aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut ]),
+ # tdTestResultExec(fRc = True, iExitCode = 0) ],
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-file' ],
+ # sUser = sUser, sPassword = sPassword, aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut ]),
+ # tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-dir\\' ],
+ # sUser = sUser, sPassword = sPassword, aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut ]),
+ # tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # With stderr.
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\windows\\system32' ],
+ # sUser = sUser, sPassword = sPassword, aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, iExitCode = 0) ],
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-file' ],
+ # sUser = sUser, sPassword = sPassword, aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-dir\\' ],
+ # sUser = sUser, sPassword = sPassword, aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # With stdout/stderr.
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\windows\\system32' ],
+ # sUser = sUser, sPassword = sPassword,
+ # aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, iExitCode = 0) ],
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-file' ],
+ # sUser = sUser, sPassword = sPassword,
+ # aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # [ tdTestExec(sCmd = sImage, aArgs = [ sImage, '/C', 'dir', 'c:\\nonexisting-dir\\' ],
+ # sUser = sUser, sPassword = sPassword,
+ # aFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, iExitCode = 1) ]
+ ## @todo Test stdin!
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlExecErrorLevel: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ fRc = self.gctrlExecDoTest(i, curTest, curRes, curGuestSession);
+ curTest.closeSession();
+ if fRc is False:
+ break;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlExecTimeout(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests handling of timeouts of started guest processes.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+ sDomain = "";
+
+ if oTestVm.isWindows():
+ # Outputting stuff.
+ sImage = "C:\\windows\\system32\\cmd.exe";
+ else:
+ reporter.error('Implement me!'); ## @todo Implement non-Windows bits.
+ return (False, oTxsSession);
+
+ fRc = True;
+ try:
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(sUser, sPassword, sDomain, "testGuestCtrlExecTimeout");
+ oGuestSession.waitForArray([ vboxcon.GuestSessionWaitForFlag_Start ], 30 * 1000);
+ # Create a process which never terminates and should timeout when
+ # waiting for termination.
+ try:
+ curProc = oGuestSession.processCreate(sImage, [sImage,] if self.oTstDrv.fpApiVer >= 5.0 else [], \
+ [], [], 30 * 1000);
+ reporter.log('Waiting for process 1 being started ...');
+ waitRes = curProc.waitForArray([ vboxcon.ProcessWaitForFlag_Start ], 30 * 1000);
+ if waitRes != vboxcon.ProcessWaitResult_Start:
+ reporter.error('Waiting for process 1 to start failed, got status %d');
+ fRc = False;
+ if fRc:
+ reporter.log('Waiting for process 1 to time out within 1ms ...');
+ waitRes = curProc.waitForArray([ vboxcon.ProcessWaitForFlag_Terminate ], 1);
+ if waitRes != vboxcon.ProcessWaitResult_Timeout:
+ reporter.error('Waiting for process 1 did not time out when it should (1)');
+ fRc = False;
+ else:
+ reporter.log('Waiting for process 1 timed out (1), good');
+ if fRc:
+ reporter.log('Waiting for process 1 to time out within 5000ms ...');
+ waitRes = curProc.waitForArray([ vboxcon.ProcessWaitForFlag_Terminate ], 5000);
+ if waitRes != vboxcon.ProcessWaitResult_Timeout:
+ reporter.error('Waiting for process 1 did not time out when it should, got wait result %d' % (waitRes,));
+ fRc = False;
+ else:
+ reporter.log('Waiting for process 1 timed out (5000), good');
+ ## @todo Add curProc.terminate() as soon as it's implemented.
+ except:
+ reporter.errorXcpt('Exception for process 1:');
+ fRc = False;
+ # Create a lengthly running guest process which will be killed by VBoxService on the
+ # guest because it ran out of execution time (5 seconds).
+ if fRc:
+ try:
+ curProc = oGuestSession.processCreate(sImage, [sImage,] if self.oTstDrv.fpApiVer >= 5.0 else [], \
+ [], [], 5 * 1000);
+ reporter.log('Waiting for process 2 being started ...');
+ waitRes = curProc.waitForArray([ vboxcon.ProcessWaitForFlag_Start ], 30 * 1000);
+ if waitRes != vboxcon.ProcessWaitResult_Start:
+ reporter.error('Waiting for process 1 to start failed, got status %d');
+ fRc = False;
+ if fRc:
+ reporter.log('Waiting for process 2 to get killed because it ran out of execution time ...');
+ waitRes = curProc.waitForArray([ vboxcon.ProcessWaitForFlag_Terminate ], 30 * 1000);
+ if waitRes != vboxcon.ProcessWaitResult_Timeout:
+ reporter.error('Waiting for process 2 did not time out when it should, got wait result %d' \
+ % (waitRes,));
+ fRc = False;
+ if fRc:
+ reporter.log('Waiting for process 2 indicated an error, good');
+ if curProc.status != vboxcon.ProcessStatus_TimedOutKilled:
+ reporter.error('Status of process 2 wrong; excepted %d, got %d' \
+ % (vboxcon.ProcessStatus_TimedOutKilled, curProc.status));
+ fRc = False;
+ else:
+ reporter.log('Status of process 2 correct (%d)' % (vboxcon.ProcessStatus_TimedOutKilled,));
+ ## @todo Add curProc.terminate() as soon as it's implemented.
+ except:
+ reporter.errorXcpt('Exception for process 2:');
+ fRc = False;
+ oGuestSession.close();
+ except:
+ reporter.errorXcpt('Could not handle session:');
+ fRc = False;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlDirCreate(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests creation of guest directories.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ if oTestVm.isWindows():
+ sScratch = "C:\\Temp\\vboxtest\\testGuestCtrlDirCreate\\";
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Invalid stuff.
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = '' ),
+ tdTestResult(fRc = False) ],
+ # More unusual stuff.
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = '..\\..\\' ),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = '../../' ),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = 'z:\\' ),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = '\\\\uncrulez\\foo' ),
+ tdTestResult(fRc = False) ],
+ # Creating directories.
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = sScratch ),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = os.path.join(sScratch, 'foo\\bar\\baz'),
+ aFlags = [ vboxcon.DirectoryCreateFlag_Parents ] ),
+ tdTestResult(fRc = True) ],
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword, sDirectory = os.path.join(sScratch, 'foo\\bar\\baz'),
+ aFlags = [ vboxcon.DirectoryCreateFlag_Parents ] ),
+ tdTestResult(fRc = True) ],
+ # Long (+ random) stuff.
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword,
+ sDirectory = os.path.join(sScratch,
+ "".join(random.choice(string.ascii_lowercase) for i in range(32))) ),
+ tdTestResult(fRc = True) ],
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword,
+ sDirectory = os.path.join(sScratch,
+ "".join(random.choice(string.ascii_lowercase) for i in range(128))) ),
+ tdTestResult(fRc = True) ],
+ # Following two should fail on Windows (paths too long). Both should timeout.
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword,
+ sDirectory = os.path.join(sScratch,
+ "".join(random.choice(string.ascii_lowercase) for i in range(255))) ),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreate(sUser = sUser, sPassword = sPassword,
+ sDirectory = os.path.join(sScratch,
+ "".join(random.choice(string.ascii_lowercase) for i in range(1024)))
+ ),
+ tdTestResult(fRc = False) ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sDirectory="%s" ...' % (i, curTest.sDirectory));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlDirCreate: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ fRc = self.gctrlCreateDir(curTest, curRes, curGuestSession);
+ curTest.closeSession();
+ if fRc is False:
+ reporter.error('Test #%d failed' % (i,));
+ fRc = False;
+ break;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlDirCreateTemp(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests creation of temporary directories.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ # if oTestVm.isWindows():
+ # sScratch = "C:\\Temp\\vboxtest\\testGuestCtrlDirCreateTemp\\";
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Invalid stuff.
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sDirectory = ''),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sDirectory = 'C:\\Windows',
+ fMode = 1234),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = '',
+ sDirectory = 'C:\\Windows', fMode = 1234),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'xXx',
+ sDirectory = 'C:\\Windows', fMode = 0o700),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'xxx',
+ sDirectory = 'C:\\Windows', fMode = 0o700),
+ tdTestResult(fRc = False) ],
+ # More unusual stuff.
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'foo',
+ sDirectory = 'z:\\'),
+ tdTestResult(fRc = False) ],
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'foo',
+ sDirectory = '\\\\uncrulez\\foo'),
+ tdTestResult(fRc = False) ],
+ # Non-existing stuff.
+ [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'bar',
+ sDirectory = 'c:\\Apps\\nonexisting\\foo'),
+ tdTestResult(fRc = False) ],
+ # FIXME: Failing test. Non Windows path
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'bar',
+ # sDirectory = '/tmp/non/existing'),
+ # tdTestResult(fRc = False) ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ # FIXME: Failing tests.
+ # aaTests.extend([
+ # Non-secure variants.
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'X',
+ # sDirectory = sScratch),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'X',
+ # sDirectory = sScratch),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fMode = 0o700),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fMode = 0o700),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fMode = 0o755),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fMode = 0o755),
+ # tdTestResult(fRc = True) ],
+ # Secure variants.
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch, fSecure = True),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch, fSecure = True),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch, fSecure = True),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch, fSecure = True),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fSecure = True, fMode = 0o700),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fSecure = True, fMode = 0o700),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fSecure = True, fMode = 0o755),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = 'XXX',
+ # sDirectory = sScratch,
+ # fSecure = True, fMode = 0o755),
+ # tdTestResult(fRc = True) ],
+ # Random stuff.
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword,
+ # sTemplate = "XXX-".join(random.choice(string.ascii_lowercase) for i in range(32)),
+ # sDirectory = sScratch,
+ # fSecure = True, fMode = 0o755),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = "".join('X' for i in range(32)),
+ # sDirectory = sScratch,
+ # fSecure = True, fMode = 0o755),
+ # tdTestResult(fRc = True) ],
+ # [ tdTestDirCreateTemp(sUser = sUser, sPassword = sPassword, sTemplate = "".join('X' for i in range(128)),
+ # sDirectory = sScratch,
+ # fSecure = True, fMode = 0o755),
+ # tdTestResult(fRc = True) ]
+ # ]);
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sTemplate="%s", fMode=%#o, path="%s", secure="%s" ...' %
+ (i, curTest.sTemplate, curTest.fMode, curTest.sDirectory, curTest.fSecure));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlDirCreateTemp: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ sDirTemp = "";
+ try:
+ sDirTemp = curGuestSession.directoryCreateTemp(curTest.sTemplate, curTest.fMode,
+ curTest.sDirectory, curTest.fSecure);
+ except:
+ if curRes.fRc is True:
+ reporter.errorXcpt('Creating temp directory "%s" failed:' % (curTest.sDirectory,));
+ fRc = False;
+ break;
+ else:
+ reporter.logXcpt('Creating temp directory "%s" failed expectedly, skipping:' % (curTest.sDirectory,));
+ curTest.closeSession();
+ if sDirTemp != "":
+ reporter.log2('Temporary directory is: %s' % (sDirTemp,));
+ if self.oTstDrv.fpApiVer >= 5.0:
+ fExists = curGuestSession.directoryExists(sDirTemp, False);
+ else:
+ fExists = curGuestSession.directoryExists(sDirTemp);
+ if fExists is False:
+ reporter.error('Test #%d failed: Temporary directory "%s" does not exists' % (i, sDirTemp));
+ fRc = False;
+ break;
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlDirRead(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests opening and reading (enumerating) guest directories.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Invalid stuff.
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = ''),
+ tdTestResultDirRead(fRc = False) ],
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = 'C:\\Windows', aFlags = [ 1234 ]),
+ tdTestResultDirRead(fRc = False) ],
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = 'C:\\Windows', sFilter = '*.foo'),
+ tdTestResultDirRead(fRc = False) ],
+ # More unusual stuff.
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = 'z:\\'),
+ tdTestResultDirRead(fRc = False) ],
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = '\\\\uncrulez\\foo'),
+ tdTestResultDirRead(fRc = False) ],
+ # Non-existing stuff.
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = 'c:\\Apps\\nonexisting'),
+ tdTestResultDirRead(fRc = False) ],
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = 'c:\\Apps\\testDirRead'),
+ tdTestResultDirRead(fRc = False) ]
+ ]);
+
+ if oTestVm.sVmName == 'tst-xppro':
+ aaTests.extend([
+ # Reading directories.
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = '../../Windows/Fonts'),
+ tdTestResultDirRead(fRc = True, numFiles = 191) ],
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = 'c:\\Windows\\Help'),
+ tdTestResultDirRead(fRc = True, numDirs = 13, numFiles = 569) ],
+ [ tdTestDirRead(sUser = sUser, sPassword = sPassword, sDirectory = 'c:\\Windows\\Web'),
+ tdTestResultDirRead(fRc = True, numDirs = 3, numFiles = 55) ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, dir="%s" ...' % (i, curTest.sDirectory));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlDirRead: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ (fRc2, cDirs, cFiles) = self.gctrlReadDir(curTest, curRes, curGuestSession);
+ curTest.closeSession();
+ reporter.log2('Test #%d: Returned %d directories, %d files total' % (i, cDirs, cFiles));
+ if fRc2 is curRes.fRc:
+ if fRc2 is True:
+ if curRes.numFiles != cFiles:
+ reporter.error('Test #%d failed: Got %d files, expected %d' % (i, cFiles, curRes.numFiles));
+ fRc = False;
+ break;
+ if curRes.numDirs != cDirs:
+ reporter.error('Test #%d failed: Got %d directories, expected %d' % (i, cDirs, curRes.numDirs));
+ fRc = False;
+ break;
+ else:
+ reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc2, curRes.fRc));
+ fRc = False;
+ break;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlFileRemove(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests removing guest files.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Invalid stuff.
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = ''),
+ tdTestResult(fRc = False) ],
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'C:\\Windows'),
+ tdTestResult(fRc = False) ],
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'C:\\Windows'),
+ tdTestResult(fRc = False) ],
+ # More unusual stuff.
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'z:\\'),
+ tdTestResult(fRc = False) ],
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = '\\\\uncrulez\\foo'),
+ tdTestResult(fRc = False) ],
+ # Non-existing stuff.
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\Apps\\nonexisting'),
+ tdTestResult(fRc = False) ],
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\Apps\\testFileRemove'),
+ tdTestResult(fRc = False) ],
+ # Try to delete system files.
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\pagefile.sys'),
+ tdTestResult(fRc = False) ],
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\Windows\\kernel32.sys'),
+ tdTestResult(fRc = False) ]
+ ]);
+
+ if oTestVm.sVmName == 'tst-xppro':
+ aaTests.extend([
+ # Try delete some unimportant media stuff.
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\Windows\\Media\\chimes.wav'),
+ tdTestResult(fRc = True) ],
+ # Second attempt should fail.
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\Windows\\Media\\chimes.wav'),
+ tdTestResult(fRc = False) ],
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\Windows\\Media\\chord.wav'),
+ tdTestResult(fRc = True) ],
+ [ tdTestFileRemove(sUser = sUser, sPassword = sPassword, sFile = 'c:\\Windows\\Media\\chord.wav'),
+ tdTestResult(fRc = False) ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, file="%s" ...' % (i, curTest.sFile));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlFileRemove: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curGuestSession.fsObjRemove(curTest.sFile);
+ else:
+ curGuestSession.fileRemove(curTest.sFile);
+ except:
+ if curRes.fRc is True:
+ reporter.errorXcpt('Removing file "%s" failed:' % (curTest.sFile,));
+ fRc = False;
+ break;
+ else:
+ reporter.logXcpt('Removing file "%s" failed expectedly, skipping:' % (curTest.sFile,));
+ curTest.closeSession();
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlFileStat(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests querying file information through stat.
+ """
+
+ # Basic stuff, existing stuff.
+ aoTests = [
+ tdTestSessionEx([ tdStepStatDir('.'),
+ tdStepStatDir('..'),
+ ]),
+ ];
+ if oTestVm.isWindows():
+ aoTests += [ tdTestSessionEx([ tdStepStatDir('C:\\Windows'),
+ tdStepStatDir('C:\\Windows\\System32'),
+ tdStepStatDir('C:\\Windows\\System32\\'),
+ tdStepStatDir('C:\\Windows\\System32\\.'),
+ tdStepStatDir('C:\\Windows\\System32\\.\\'),
+ tdStepStatDir('C:\\Windows\\System32\\..'),
+ tdStepStatDir('C:\\Windows\\System32\\..\\'),
+ tdStepStatDir('C:\\Windows\\System32\\..\\\\'),
+ tdStepStatDir('C:\\Windows\\System32\\\\..\\\\'),
+ tdStepStatDir('C:/Windows/System32'),
+ tdStepStatDir('C:/Windows/System32/'),
+ tdStepStatDir('c:/winDowS/sYsTeM32/'),
+ tdStepStatDir('C:/Windows/System32/.'),
+ tdStepStatDir('C:/Windows/System32/./'),
+ tdStepStatDir('C:/Windows/System32/..'),
+ tdStepStatDir('C:/Windows/System32/../'),
+ tdStepStatDir('C:/Windows/System32/..//'),
+ tdStepStatDir('C:/Windows/System32//..//'),
+ tdStepStatFile('C:\\Windows\\System32\\kernel32.dll'),
+ tdStepStatFile('C:/Windows/System32/kernel32.dll')
+ ]) ];
+ elif oTestVm.isOS2():
+ aoTests += [ tdTestSessionEx([ tdStepStatDir('C:\\OS2'),
+ tdStepStatDir('C:\\OS2\\DLL'),
+ tdStepStatDir('C:\\OS2\\DLL\\'),
+ tdStepStatDir('C:/OS2/DLL'),
+ tdStepStatDir('c:/OS2/DLL'),
+ tdStepStatDir('c:/OS2/DLL/'),
+ tdStepStatFile('C:\\CONFIG.SYS'),
+ tdStepStatFile('C:\\OS2\\DLL\\DOSCALL1.DLL'),
+ ]) ];
+ else: # generic unix.
+ aoTests += [ tdTestSessionEx([ tdStepStatDir('/'),
+ tdStepStatDir('///'),
+ tdStepStatDir('/usr/bin/.'),
+ tdStepStatDir('/usr/bin/./'),
+ tdStepStatDir('/usr/bin/..'),
+ tdStepStatDir('/usr/bin/../'),
+ tdStepStatFile('/bin/ls'),
+ tdStepStatFile('/bin/cp'),
+ tdStepStatFile('/bin/date'),
+ ]) ];
+ # None existing stuff.
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ aoTests += [ tdTestSessionEx([ tdStepStatFileNotFound('C:\\NoSuchFileOrDirectory', ),
+ tdStepStatPathNotFound('C:\\NoSuchDirectory\\'),
+ tdStepStatPathNotFound('C:/NoSuchDirectory/'),
+ tdStepStatPathNotFound('C:\\NoSuchDirectory\\.'),
+ tdStepStatPathNotFound('C:/NoSuchDirectory/.'),
+ tdStepStatPathNotFound('C:\\NoSuchDirectory\\NoSuchFileOrDirectory'),
+ tdStepStatPathNotFound('C:/NoSuchDirectory/NoSuchFileOrDirectory'),
+ tdStepStatPathNotFound('C:/NoSuchDirectory/NoSuchFileOrDirectory/'),
+ tdStepStatPathNotFound('N:\\'), # ASSUMES nothing mounted on N:!
+ tdStepStatPathNotFound('\\\\NoSuchUncServerName\\NoSuchShare'),
+ ]) ];
+ else: # generic unix.
+ aoTests += [ tdTestSessionEx([ tdStepStatFileNotFound('/NoSuchFileOrDirectory', ),
+ tdStepStatFileNotFound('/bin/NoSuchFileOrDirectory'),
+ tdStepStatPathNotFound('/NoSuchDirectory/'),
+ tdStepStatPathNotFound('/NoSuchDirectory/.'),
+ ]) ];
+ # Invalid parameter check.
+ aoTests += [ tdTestSessionEx([ tdStepStat('', vbox.ComError.E_INVALIDARG), ]), ];
+
+ # Some test VM specific tests.
+ if oTestVm.sVmName == 'tst-xppro':
+ aoTests += [ tdTestSessionEx([ tdStepStatFileSize('c:\\Windows\\system32\\kernel32.dll', 926720), ]) ];
+
+ #
+ # Execute the tests.
+ #
+ return tdTestSessionEx.executeListTestSessions(aoTests, self.oTstDrv, oSession, oTxsSession, oTestVm, 'FsStat');
+
+ def testGuestCtrlFileRead(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests reading from guest files.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ if oTxsSession.syncMkDir('${SCRATCH}/testGuestCtrlFileRead') is False:
+ reporter.error('Could not create scratch directory on guest');
+ return (False, oTxsSession);
+
+ aaTests = [];
+ aaTests.extend([
+ # Invalid stuff.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, cbToReadWrite = 0),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = ''),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'non-existing.file'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ # Wrong open mode.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'non-existing.file', \
+ sOpenMode = 'rt', sDisposition = 'oe'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = '\\\\uncrulez\\non-existing.file', \
+ sOpenMode = 'tr', sDisposition = 'oe'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = '../../non-existing.file', \
+ sOpenMode = 'wr', sDisposition = 'oe'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ # Wrong disposition.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'non-existing.file', \
+ sOpenMode = 'r', sDisposition = 'e'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = '\\\\uncrulez\\non-existing.file', \
+ sOpenMode = 'r', sDisposition = 'o'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = '../../non-existing.file', \
+ sOpenMode = 'r', sDisposition = 'c'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ # Opening non-existing file when it should exist.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'non-existing.file', \
+ sOpenMode = 'r', sDisposition = 'oe'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = '\\\\uncrulez\\non-existing.file', \
+ sOpenMode = 'r', sDisposition = 'oe'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = '../../non-existing.file', \
+ sOpenMode = 'r', sDisposition = 'oe'),
+ tdTestResultFileReadWrite(fRc = False) ]
+ ]);
+
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Create a file which must not exist (but it hopefully does).
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'C:\\Windows\\System32\\calc.exe', \
+ sOpenMode = 'w', sDisposition = 'ce'),
+ tdTestResultFileReadWrite(fRc = False) ],
+ # Open a file which must exist.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'C:\\Windows\\System32\\kernel32.dll', \
+ sOpenMode = 'r', sDisposition = 'oe'),
+ tdTestResultFileReadWrite(fRc = True) ],
+ # Try truncating a file which already is opened with a different sharing mode (and thus should fail).
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'C:\\Windows\\System32\\kernel32.dll', \
+ sOpenMode = 'w', sDisposition = 'ot'),
+ tdTestResultFileReadWrite(fRc = False) ]
+ ]);
+
+ if oTestVm.sKind == "WindowsXP":
+ aaTests.extend([
+ # Reading from beginning.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'C:\\Windows\\System32\\eula.txt', \
+ sOpenMode = 'r', sDisposition = 'oe', cbToReadWrite = 33),
+ tdTestResultFileReadWrite(fRc = True, aBuf = 'Microsoft Windows XP Professional', \
+ cbProcessed = 33, cbOffset = 33) ],
+ # Reading from offset.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = 'C:\\Windows\\System32\\eula.txt', \
+ sOpenMode = 'r', sDisposition = 'oe', cbOffset = 17782, cbToReadWrite = 26),
+ tdTestResultFileReadWrite(fRc = True, aBuf = 'LINKS TO THIRD PARTY SITES', \
+ cbProcessed = 26, cbOffset = 17782 + 26) ]
+ ]);
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestFileReadWrite, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sFile="%s", cbToReadWrite=%d, sOpenMode="%s", sDisposition="%s", cbOffset=%d ...' % \
+ (i, curTest.sFile, curTest.cbToReadWrite, curTest.sOpenMode, curTest.sDisposition, curTest.cbOffset));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlFileRead: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ try:
+ if curTest.cbOffset > 0: # The offset parameter is gone.
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curFile = curGuestSession.fileOpenEx(curTest.sFile, curTest.getAccessMode(), curTest.getOpenAction(),
+ curTest.getSharingMode(), curTest.lCreationMode, []);
+ curFile.seek(curTest.cbOffset, vboxcon.FileSeekOrigin_Begin);
+ else:
+ curFile = curGuestSession.fileOpenEx(curTest.sFile, curTest.sOpenMode, curTest.sDisposition, \
+ curTest.sSharingMode, curTest.lCreationMode, curTest.cbOffset);
+ curOffset = long(curFile.offset);
+ resOffset = long(curTest.cbOffset);
+ if curOffset != resOffset:
+ reporter.error('Test #%d failed: Initial offset on open does not match: Got %d, expected %d' \
+ % (i, curOffset, resOffset));
+ fRc = False;
+ else:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curFile = curGuestSession.fileOpen(curTest.sFile, curTest.getAccessMode(), curTest.getOpenAction(),
+ curTest.lCreationMode);
+ else:
+ curFile = curGuestSession.fileOpen(curTest.sFile, curTest.sOpenMode, curTest.sDisposition, \
+ curTest.lCreationMode);
+ if fRc \
+ and curTest.cbToReadWrite > 0:
+ ## @todo Split this up in 64K reads. Later.
+ ## @todo Test timeouts.
+ aBufRead = curFile.read(curTest.cbToReadWrite, 30 * 1000);
+ if curRes.cbProcessed > 0 \
+ and curRes.cbProcessed is not len(aBufRead):
+ reporter.error('Test #%d failed: Read buffer length does not match: Got %d, expected %d' \
+ % (i, len(aBufRead), curRes.cbProcessed));
+ fRc = False;
+ if fRc:
+ if curRes.aBuf is not None \
+ and bytes(curRes.aBuf) != bytes(aBufRead):
+ reporter.error('Test #%d failed: Got buffer\n%s (%d bytes), expected\n%s (%d bytes)' \
+ % (i, map(hex, map(ord, aBufRead)), len(aBufRead), \
+ map(hex, map(ord, curRes.aBuf)), len(curRes.aBuf)));
+ reporter.error('Test #%d failed: Got buffer\n%s, expected\n%s' \
+ % (i, aBufRead, curRes.aBuf));
+ fRc = False;
+ # Test final offset.
+ curOffset = long(curFile.offset);
+ resOffset = long(curRes.cbOffset);
+ if curOffset != resOffset:
+ reporter.error('Test #%d failed: Final offset does not match: Got %d, expected %d' \
+ % (i, curOffset, resOffset));
+ fRc = False;
+ curFile.close();
+ except:
+ reporter.logXcpt('Opening "%s" failed:' % (curTest.sFile,));
+ fRc = False;
+
+ curTest.closeSession();
+
+ if fRc != curRes.fRc:
+ reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc, curRes.fRc));
+ fRc = False;
+ break;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlFileWrite(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests writing to guest files.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ if oTestVm.isWindows():
+ sScratch = "C:\\Temp\\vboxtest\\testGuestCtrlFileWrite\\";
+
+ if oTxsSession.syncMkDir('${SCRATCH}/testGuestCtrlFileWrite') is False:
+ reporter.error('Could not create scratch directory on guest');
+ return (False, oTxsSession);
+
+ aaTests = [];
+
+ cScratchBuf = 512;
+ aScratchBuf = array('b', [random.randint(-128, 127) for i in range(cScratchBuf)]);
+ aaTests.extend([
+ # Write to a non-existing file.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = sScratch + 'testGuestCtrlFileWrite.txt', \
+ sOpenMode = 'w+', sDisposition = 'ce', cbToReadWrite = cScratchBuf,
+ aBuf = aScratchBuf),
+ tdTestResultFileReadWrite(fRc = True, aBuf = aScratchBuf, \
+ cbProcessed = cScratchBuf, cbOffset = cScratchBuf) ]
+ ]);
+
+ aScratchBuf2 = array('b', [random.randint(-128, 127) for i in range(cScratchBuf)]);
+ aaTests.extend([
+ # Append the same amount of data to the just created file.
+ [ tdTestFileReadWrite(sUser = sUser, sPassword = sPassword, sFile = sScratch + 'testGuestCtrlFileWrite.txt', \
+ sOpenMode = 'w+', sDisposition = 'oa', cbToReadWrite = cScratchBuf,
+ cbOffset = cScratchBuf, aBuf = aScratchBuf2),
+ tdTestResultFileReadWrite(fRc = True, aBuf = aScratchBuf2, \
+ cbProcessed = cScratchBuf, cbOffset = cScratchBuf * 2) ],
+ ]);
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestFileReadWrite, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sFile="%s", cbToReadWrite=%d, sOpenMode="%s", sDisposition="%s", cbOffset=%d ...' %
+ (i, curTest.sFile, curTest.cbToReadWrite, curTest.sOpenMode, curTest.sDisposition, curTest.cbOffset));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlFileWrite: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ try:
+ if curTest.cbOffset > 0: # The offset parameter is gone.
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curFile = curGuestSession.fileOpenEx(curTest.sFile, curTest.getAccessMode(), curTest.getOpenAction(),
+ curTest.getSharingMode(), []);
+ curFile.seek(curTest.cbOffset, vboxcon.FileSeekOrigin_Begin);
+ else:
+ curFile = curGuestSession.fileOpenEx(curTest.sFile, curTest.sOpenMode, curTest.sDisposition,
+ curTest.sSharingMode, curTest.lCreationMode, curTest.cbOffset);
+ curOffset = long(curFile.offset);
+ resOffset = long(curTest.cbOffset);
+ if curOffset != resOffset:
+ reporter.error('Test #%d failed: Initial offset on open does not match: Got %d, expected %d'
+ % (i, curOffset, resOffset));
+ fRc = False;
+ else:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curFile = curGuestSession.fileOpen(curTest.sFile, curTest.getAccessMode(), curTest.getOpenAction(),
+ curTest.lCreationMode);
+ else:
+ curFile = curGuestSession.fileOpen(curTest.sFile, curTest.sOpenMode, curTest.sDisposition,
+ curTest.lCreationMode);
+ if fRc and curTest.cbToReadWrite > 0:
+ ## @todo Split this up in 64K writes. Later.
+ ## @todo Test timeouts.
+ cBytesWritten = curFile.write(curTest.aBuf, 30 * 1000);
+ if curRes.cbProcessed > 0 \
+ and curRes.cbProcessed != cBytesWritten:
+ reporter.error('Test #%d failed: Written buffer length does not match: Got %d, expected %d'
+ % (i, cBytesWritten, curRes.cbProcessed));
+ fRc = False;
+ if fRc:
+ # Verify written content by seeking back to the initial offset and
+ # re-read & compare the written data.
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ curFile.seek(-(curTest.cbToReadWrite), vboxcon.FileSeekOrigin_Current);
+ else:
+ curFile.seek(-(curTest.cbToReadWrite), vboxcon.FileSeekType_Current);
+ except:
+ reporter.logXcpt('Seeking back to initial write position failed:');
+ fRc = False;
+ if fRc and long(curFile.offset) != curTest.cbOffset:
+ reporter.error('Test #%d failed: Initial write position does not match current position, '
+ 'got %d, expected %d' % (i, long(curFile.offset), curTest.cbOffset));
+ fRc = False;
+ if fRc:
+ aBufRead = curFile.read(curTest.cbToReadWrite, 30 * 1000);
+ if len(aBufRead) != curTest.cbToReadWrite:
+ reporter.error('Test #%d failed: Got buffer length %d, expected %d'
+ % (i, len(aBufRead), curTest.cbToReadWrite));
+ fRc = False;
+ if fRc \
+ and curRes.aBuf is not None \
+ and curRes.aBuf != aBufRead:
+ reporter.error('Test #%d failed: Got buffer\n%s, expected\n%s'
+ % (i, aBufRead, curRes.aBuf));
+ fRc = False;
+ # Test final offset.
+ curOffset = long(curFile.offset);
+ resOffset = long(curRes.cbOffset);
+ if curOffset != resOffset:
+ reporter.error('Test #%d failed: Final offset does not match: Got %d, expected %d'
+ % (i, curOffset, resOffset));
+ fRc = False;
+ curFile.close();
+ except:
+ reporter.logXcpt('Opening "%s" failed:' % (curTest.sFile,));
+ fRc = False;
+
+ curTest.closeSession();
+
+ if fRc != curRes.fRc:
+ reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc, curRes.fRc));
+ fRc = False;
+ break;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlCopyTo(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests copying files from host to the guest.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ sScratchGst = "C:\\Temp\\vboxtest\\testGuestCtrlCopyTo\\";
+ sScratchGstNotExist = "C:\\does-not-exist\\";
+ sScratchGstInvalid = "?*|invalid-name?*|";
+ else:
+ sUser = "vbox";
+ sScratchGst = "/tmp/testGuestCtrlCopyTo/";
+ sScratchGstNotExist = "/tmp/does-not-exist/";
+ sScratchGstInvalid = "/";
+ sPassword = "password";
+
+ if oTxsSession.syncMkDir('${SCRATCH}/testGuestCtrlCopyTo') is False:
+ reporter.error('Could not create scratch directory on guest');
+ return (False, oTxsSession);
+
+ ## @todo r=klaus It's not good to use files with unpredictable size
+ # for testing. Causes all sorts of weird failures as things grow,
+ # exceeding the free space of the test VMs. Especially as this used
+ # the very big (and quickly growing) validation kit ISO originally.
+ sTestFileBig = self.oTstDrv.getFullResourceName('5.3/guestctrl/50mb_rnd.dat');
+ if not os.path.isfile(sTestFileBig):
+ sTestFileBig = self.oTstDrv.getGuestAdditionsIso();
+ if sTestFileBig == '' or not os.path.isfile(sTestFileBig):
+ sTestFileBig = self.oTstDrv.sVBoxValidationKitIso;
+ if os.path.isfile(sTestFileBig):
+ reporter.log('Test file for big copy found at: %s' % (sTestFileBig,));
+ else:
+ reporter.log('Warning: Test file for big copy not found -- some tests might fail');
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Destination missing.
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = ''),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = '/placeholder',
+ aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Source missing.
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sDst = ''),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sDst = '/placeholder',
+ aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Testing DirectoryCopyFlag flags.
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = sScratchGstInvalid, aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Testing FileCopyFlag flags.
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = sScratchGstInvalid, aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Nothing to copy (source and/or destination is empty).
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = 'z:\\'),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = '\\\\uncrulez\\foo'),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = 'non-exist',
+ sDst = os.path.join(sScratchGst, 'non-exist.dll')),
+ tdTestResult(fRc = False) ]
+ ]);
+
+ #
+ # Single file handling.
+ #
+ if self.oTstDrv.fpApiVer > 5.2:
+ aaTests.extend([
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = sScratchGstInvalid),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = sScratchGstNotExist),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = sScratchGstNotExist),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = os.path.join(sScratchGstNotExist, 'renamedfile.dll')),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = os.path.join(sScratchGst, 'HostGABig.dat')),
+ tdTestResult(fRc = True) ],
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = os.path.join(sScratchGst, 'HostGABig.dat')),
+ tdTestResult(fRc = True) ],
+ # Note: Copying files into directories via Main is supported only in versions > 5.2.
+ # Destination is a directory.
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = sScratchGst),
+ tdTestResult(fRc = True) ],
+ # Copy over file again into same directory (overwrite).
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = sScratchGst),
+ tdTestResult(fRc = True) ]
+ ]);
+
+ aaTests.extend([
+ # Copy the same file over to the guest, but this time store the file into the former
+ # file's ADS (Alternate Data Stream). Only works on Windows, of course.
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = sTestFileBig,
+ sDst = os.path.join(sScratchGst, 'HostGABig.dat:ADS-Test')),
+ tdTestResult(fRc = True) ]
+ ]);
+
+ #
+ # Directory handling.
+ #
+ ## @todo r=michaln disabled completely, can fill up the guest disk or fail without giving a reason
+ if self.oTstDrv.fpApiVer > 6.0: # Copying directories via Main is supported only in versions > 5.2.
+ if self.oTstDrv.sHost == "win":
+ sSystemRoot = os.getenv('SystemRoot', 'C:\\Windows')
+ aaTests.extend([
+ # Copying directories with contain files we don't have read access to.
+ ## @todo r=klaus disabled, because this can fill up the guest disk, making other tests fail,
+ ## additionally it's not really clear if this fails reliably on all Windows versions, even
+ ## the old ones like XP with a "proper" administrator.
+ #[ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = os.path.join(sSystemRoot, 'security'),
+ # sDst = sScratchGst, aFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting ]),
+ # tdTestResult(fRc = False) ],
+ # Copying directories with regular files.
+ [ tdTestCopyTo(sUser = sUser, sPassword = sPassword, sSrc = os.path.join(sSystemRoot, 'Help'),
+ sDst = sScratchGst, aFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting ]),
+ tdTestResult(fRc = True) ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sSrc=%s, sDst=%s, aFlags=%s ...' % \
+ (i, curTest.sSrc, curTest.sDst, curTest.aFlags));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlCopyTo: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ fRc2 = False;
+ if os.path.isdir(curTest.sSrc):
+ try:
+ curProgress = curGuestSession.directoryCopyToGuest(curTest.sSrc, curTest.sDst, curTest.aFlags);
+ if curProgress is not None:
+ oProgress = vboxwrappers.ProgressWrapper(curProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, \
+ "gctrlDirCopyTo");
+ try:
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = True);
+ fRc = False;
+ except:
+ reporter.logXcpt('Waiting exception for sSrc="%s", sDst="%s":' % (curTest.sSrc, curTest.sDst));
+ fRc2 = False;
+ else:
+ reporter.error('No progress object returned');
+ fRc2 = False;
+ except:
+ fRc2 = False;
+ else:
+ fRc2 = self.gctrlCopyFileTo(curGuestSession, curTest.sSrc, curTest.sDst, curTest.aFlags);
+
+ curTest.closeSession();
+
+ if fRc2 is curRes.fRc:
+ ## @todo Verify the copied results (size, checksum?).
+ pass;
+ else:
+ reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc2, curRes.fRc));
+ fRc = False;
+ break;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlCopyFrom(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests copying files from guest to the host.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ sScratchHst = os.path.join(self.oTstDrv.sScratchPath, "testGctrlCopyFrom");
+
+ if self.oTstDrv.sHost == "win":
+ sScratchHstNotExist = sScratchHst + "\\does-not-exist\\";
+ sScratchHstNotExistChain = sScratchHst + "\\does\\not\\exist\\";
+ sScratchHstInvalid = "?*|invalid-name?*|";
+ else:
+ sScratchHstNotExist = sScratchHst + "/does-not-exist/";
+ sScratchHstNotExistChain = sScratchHst + "/does/not/exist/";
+ sScratchHstInvalid = "/";
+
+ try:
+ os.makedirs(sScratchHst);
+ except OSError as e:
+ if e.errno != errno.EEXIST:
+ reporter.error('Failed: Unable to create scratch directory \"%s\"' % (sScratchHst,));
+ return (False, oTxsSession);
+ reporter.log('Scratch path is: %s' % (sScratchHst,));
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Destination missing.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = ''),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'Something',
+ aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Source missing.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sDst = ''),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sDst = 'Something',
+ aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Testing DirectoryCopyFlag flags.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32',
+ sDst = sScratchHstInvalid, aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Testing FileCopyFlag flags.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = sScratchHstInvalid, aFlags = [ 80 ] ),
+ tdTestResult(fRc = False) ],
+ # Nothing to copy (sDst is empty / unreachable).
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'z:\\'),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = '\\\\uncrulez\\foo'),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'non-exist',
+ sDst = os.path.join(sScratchHst, 'non-exist.dll')),
+ tdTestResult(fRc = False) ]
+ ]);
+
+ #
+ # Single file handling.
+ #
+ if self.oTstDrv.fpApiVer > 5.2:
+ aaTests.extend([
+ # Copying single files.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = sScratchHstInvalid),
+ tdTestResult(fRc = False) ],
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = os.path.join(sScratchHstInvalid, 'renamedfile.dll')),
+ tdTestResult(fRc = False) ],
+ # Copy over file using a different destination name.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = os.path.join(sScratchHst, 'renamedfile.dll')),
+ tdTestResult(fRc = True) ],
+ # Copy over same file (and overwrite existing one).
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = os.path.join(sScratchHst, 'renamedfile.dll')),
+ tdTestResult(fRc = True) ],
+ # Note: Copying files into directories via Main is supported only in versions > 5.2.
+ # Destination is a directory with a trailing slash (should work).
+ # See "cp" syntax.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = sScratchHst + "/"),
+ tdTestResult(fRc = True) ],
+ # Destination is a directory (without a trailing slash, should also work).
+ # See "cp" syntax.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = sScratchHst),
+ tdTestResult(fRc = True) ],
+ # Destination is a non-existing directory.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\system32\\ole32.dll',
+ sDst = sScratchHstNotExist),
+ tdTestResult(fRc = False) ]
+ ]);
+
+ #
+ # Directory handling.
+ #
+ if self.oTstDrv.fpApiVer > 5.2: # Copying directories via Main is supported only in versions > 5.2.
+ aaTests.extend([
+ # Copying entire directories (destination is "<sScratchHst>\Web").
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\Web',
+ sDst = sScratchHst),
+ tdTestResult(fRc = True) ],
+ # Repeat -- this time it should fail, as the destination directory already exists (and
+ # DirectoryCopyFlag_CopyIntoExisting is not specified).
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\Web',
+ sDst = sScratchHst + "/"),
+ tdTestResult(fRc = False) ],
+ # Next try with the DirectoryCopyFlag_CopyIntoExisting flag being set.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\Web',
+ sDst = sScratchHst, aFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting ]),
+ tdTestResult(fRc = True) ],
+ # Ditto, with trailing slash.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\Web',
+ sDst = sScratchHst + "/", aFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting ]),
+ tdTestResult(fRc = True) ],
+ # Copying contents of directories into a non-existing directory chain on the host which fail.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\Web\\',
+ sDst = sScratchHstNotExistChain,
+ aFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting ]),
+ tdTestResult(fRc = False) ],
+ # Copying contents of directories into a non-existing directory on the host, which should succeed.
+ [ tdTestCopyFrom(sUser = sUser, sPassword = sPassword, sSrc = 'C:\\Windows\\Web\\',
+ sDst = sScratchHstNotExist,
+ aFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting ]),
+ tdTestResult(fRc = True) ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sSrc="%s", sDst="%s", aFlags="%s" ...' % \
+ (i, curTest.sSrc, curTest.sDst, curTest.aFlags));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, curGuestSession = curTest.createSession('testGuestCtrlCopyFrom: Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ fRc2 = True;
+
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ oFsInfo = curGuestSession.fsObjQueryInfo(curTest.sSrc, True); # fFollowSymlinks
+ else:
+ oFsInfo = curGuestSession.fileQueryInfo(curTest.sSrc);
+
+ if oFsInfo.type is vboxcon.FsObjType_Directory:
+ curProgress = curGuestSession.directoryCopyFromGuest(curTest.sSrc, curTest.sDst, curTest.aFlags);
+ if curProgress is not None:
+ oProgress = vboxwrappers.ProgressWrapper(curProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, \
+ "gctrlDirCopyFrom");
+ try:
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = True);
+ fRc2 = False;
+ except:
+ reporter.logXcpt('Waiting exception for sSrc="%s", sDst="%s":' % (curTest.sSrc, curTest.sDst));
+ fRc2 = False;
+ else:
+ reporter.error('No progress object returned');
+ fRc2 = False;
+ elif oFsInfo.type is vboxcon.FsObjType_File:
+ fRc2 = self.gctrlCopyFileFrom(curGuestSession, curTest.sSrc, curTest.sDst, curTest.aFlags);
+ else:
+ reporter.log2('Element "%s" not handled (yet), skipping' % oFsInfo.name);
+
+ except:
+ reporter.logXcpt('Query information exception for sSrc="%s", sDst="%s":' % (curTest.sSrc, curTest.sDst));
+ fRc2 = False;
+
+ curTest.closeSession();
+ if fRc2 is curRes.fRc:
+ ## @todo Verify the copied results (size, checksum?).
+ pass;
+ else:
+ reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc2, curRes.fRc));
+ fRc = False;
+ break;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlUpdateAdditions(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914
+ """
+ Tests updating the Guest Additions inside the guest.
+ """
+
+ if oTestVm.isWindows():
+ sUser = "Administrator";
+ else:
+ sUser = "vbox";
+ sPassword = "password";
+
+ # Some stupid trickery to guess the location of the iso.
+ sVBoxValidationKitISO = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../VBoxValidationKit.iso'));
+ if not os.path.isfile(sVBoxValidationKitISO):
+ sVBoxValidationKitISO = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../VBoxTestSuite.iso'));
+ if not os.path.isfile(sVBoxValidationKitISO):
+ sCur = os.getcwd();
+ for i in range(0, 10):
+ sVBoxValidationKitISO = os.path.join(sCur, 'validationkit/VBoxValidationKit.iso');
+ if os.path.isfile(sVBoxValidationKitISO):
+ break;
+ sVBoxValidationKitISO = os.path.join(sCur, 'testsuite/VBoxTestSuite.iso');
+ if os.path.isfile(sVBoxValidationKitISO):
+ break;
+ sCur = os.path.abspath(os.path.join(sCur, '..'));
+ if i is None: pass; # shut up pychecker/pylint.
+ if os.path.isfile(sVBoxValidationKitISO):
+ reporter.log('Validation Kit .ISO found at: %s' % (sVBoxValidationKitISO,));
+ else:
+ reporter.log('Warning: Validation Kit .ISO not found -- some tests might fail');
+
+ sScratch = os.path.join(self.oTstDrv.sScratchPath, "testGctrlUpdateAdditions");
+ try:
+ os.makedirs(sScratch);
+ except OSError as e:
+ if e.errno != errno.EEXIST:
+ reporter.error('Failed: Unable to create scratch directory \"%s\"' % (sScratch,));
+ return (False, oTxsSession);
+ reporter.log('Scratch path is: %s' % (sScratch,));
+
+ aaTests = [];
+ if oTestVm.isWindows():
+ aaTests.extend([
+ # Source is missing.
+ [ tdTestUpdateAdditions(sUser = sUser, sPassword = sPassword, sSrc = ''),
+ tdTestResult(fRc = False) ],
+ # Wrong aFlags.
+ [ tdTestUpdateAdditions(sUser = sUser, sPassword = sPassword, sSrc = self.oTstDrv.getGuestAdditionsIso(),
+ aFlags = [ 1234 ]),
+ tdTestResult(fRc = False) ],
+ # Non-existing .ISO.
+ [ tdTestUpdateAdditions(sUser = sUser, sPassword = sPassword, sSrc = "non-existing.iso"),
+ tdTestResult(fRc = False) ],
+ # Wrong .ISO.
+ [ tdTestUpdateAdditions(sUser = sUser, sPassword = sPassword, sSrc = sVBoxValidationKitISO),
+ tdTestResult(fRc = False) ],
+ # The real thing.
+ [ tdTestUpdateAdditions(sUser = sUser, sPassword = sPassword, sSrc = self.oTstDrv.getGuestAdditionsIso()),
+ tdTestResult(fRc = True) ],
+ # Test the (optional) installer arguments. This will extract the
+ # installer into our guest's scratch directory.
+ [ tdTestUpdateAdditions(sUser = sUser, sPassword = sPassword, sSrc = self.oTstDrv.getGuestAdditionsIso(),
+ aArgs = [ '/extract', '/D=' + sScratch ]),
+ tdTestResult(fRc = True) ]
+ # Some debg ISO. Only enable locally.
+ #[ tdTestUpdateAdditions(sUser = sUser, sPassword = sPassword,
+ # sSrc = "V:\\Downloads\\VBoxGuestAdditions-r80354.iso"),
+ # tdTestResult(fRc = True) ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, aTest) in enumerate(aaTests):
+ curTest = aTest[0]; # tdTestExec, use an index, later.
+ curRes = aTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sSrc="%s", aFlags="%s" ...' % \
+ (i, curTest.sSrc, curTest.aFlags));
+ curTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ fRc, _ = curTest.createSession('Test #%d' % (i,));
+ if fRc is False:
+ reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ try:
+ curProgress = curTest.oTest.oGuest.updateGuestAdditions(curTest.sSrc, curTest.aArgs, curTest.aFlags);
+ if curProgress is not None:
+ oProgress = vboxwrappers.ProgressWrapper(curProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, "gctrlUpGA");
+ try:
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = True);
+ fRc = False;
+ except:
+ reporter.logXcpt('Waiting exception for updating Guest Additions:');
+ fRc = False;
+ else:
+ reporter.error('No progress object returned');
+ fRc = False;
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.logXcpt('Updating Guest Additions exception for sSrc="%s", aFlags="%s":' \
+ % (curTest.sSrc, curTest.aFlags));
+ fRc = False;
+ curTest.closeSession();
+ if fRc is curRes.fRc:
+ if fRc:
+ ## @todo Verify if Guest Additions were really updated (build, revision, ...).
+ pass;
+ else:
+ reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc, curRes.fRc));
+ fRc = False;
+ break;
+
+ return (fRc, oTxsSession);
+
+
+
+class tdAddGuestCtrl(vbox.TestDriver): # pylint: disable=R0902,R0904
+ """
+ Guest control using VBoxService on the guest.
+ """
+
+ def __init__(self):
+ vbox.TestDriver.__init__(self);
+ self.oTestVmSet = self.oTestVmManager.getSmokeVmSet('nat');
+ self.asRsrcs = None;
+ self.fQuick = False; # Don't skip lengthly tests by default.
+ self.addSubTestDriver(SubTstDrvAddGuestCtrl(self));
+
+ #
+ # Overridden methods.
+ #
+ def showUsage(self):
+ """
+ Shows the testdriver usage.
+ """
+ rc = vbox.TestDriver.showUsage(self);
+ reporter.log('');
+ reporter.log('tdAddGuestCtrl Options:');
+ reporter.log(' --quick');
+ reporter.log(' Same as --virt-modes hwvirt --cpu-counts 1.');
+ return rc;
+
+ def parseOption(self, asArgs, iArg): # pylint: disable=R0912,R0915
+ """
+ Parses the testdriver arguments from the command line.
+ """
+ if asArgs[iArg] == '--quick':
+ self.parseOption(['--virt-modes', 'hwvirt'], 0);
+ self.parseOption(['--cpu-counts', '1'], 0);
+ self.fQuick = True;
+ else:
+ return vbox.TestDriver.parseOption(self, asArgs, iArg);
+ return iArg + 1;
+
+ def actionConfig(self):
+ if not self.importVBoxApi(): # So we can use the constant below.
+ return False;
+
+ eNic0AttachType = vboxcon.NetworkAttachmentType_NAT;
+ sGaIso = self.getGuestAdditionsIso();
+ return self.oTestVmSet.actionConfig(self, eNic0AttachType = eNic0AttachType, sDvdImage = sGaIso);
+
+ def actionExecute(self):
+ return self.oTestVmSet.actionExecute(self, self.testOneCfg);
+
+ #
+ # Test execution helpers.
+ #
+ def testOneCfg(self, oVM, oTestVm): # pylint: disable=R0915
+ """
+ Runs the specified VM thru the tests.
+
+ Returns a success indicator on the general test execution. This is not
+ the actual test result.
+ """
+
+ self.logVmInfo(oVM);
+
+ fRc = True;
+ oSession, oTxsSession = self.startVmAndConnectToTxsViaTcp(oTestVm.sVmName, fCdWait = False);
+ reporter.log("TxsSession: %s" % (oTxsSession,));
+ if oSession is not None:
+ self.addTask(oTxsSession);
+
+ fManual = False; # Manual override for local testing. (Committed version shall be False.)
+ if not fManual:
+ fRc, oTxsSession = self.aoSubTstDrvs[0].testIt(oTestVm, oSession, oTxsSession);
+ else:
+ fRc, oTxsSession = self.testGuestCtrlManual(oSession, oTxsSession, oTestVm);
+
+ # Cleanup.
+ self.removeTask(oTxsSession);
+ if not fManual:
+ self.terminateVmBySession(oSession);
+ else:
+ fRc = False;
+ return fRc;
+
+ def gctrlReportError(self, progress):
+ """
+ Helper function to report an error of a
+ given progress object.
+ """
+ if progress is None:
+ reporter.log('No progress object to print error for');
+ else:
+ errInfo = progress.errorInfo;
+ if errInfo:
+ reporter.log('%s' % (errInfo.text,));
+ return False;
+
+ def gctrlGetRemainingTime(self, msTimeout, msStart):
+ """
+ Helper function to return the remaining time (in ms)
+ based from a timeout value and the start time (both in ms).
+ """
+ if msTimeout is 0:
+ return 0xFFFFFFFE; # Wait forever.
+ msElapsed = base.timestampMilli() - msStart;
+ if msElapsed > msTimeout:
+ return 0; # No time left.
+ return msTimeout - msElapsed;
+
+ def testGuestCtrlManual(self, oSession, oTxsSession, oTestVm): # pylint: disable=R0914,R0915,W0613,W0612
+ """
+ For manually testing certain bits.
+ """
+
+ reporter.log('Manual testing ...');
+ fRc = True;
+
+ sUser = 'Administrator';
+ sPassword = 'password';
+
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(sUser,
+ sPassword,
+ "", "Manual Test");
+
+ aWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ _ = oGuestSession.waitForArray(aWaitFor, 30 * 1000);
+
+ sCmd = 'c:\\windows\\system32\\cmd.exe';
+ aArgs = [ sCmd, '/C', 'dir', '/S', 'c:\\windows' ];
+ aEnv = [];
+ aFlags = [];
+
+ for _ in range(100):
+ oProc = oGuestSession.processCreate(sCmd, aArgs if self.fpApiVer >= 5.0 else aArgs[1:],
+ aEnv, aFlags, 30 * 1000);
+
+ aWaitFor = [ vboxcon.ProcessWaitForFlag_Terminate ];
+ _ = oProc.waitForArray(aWaitFor, 30 * 1000);
+
+ oGuestSession.close();
+ oGuestSession = None;
+
+ time.sleep(5);
+
+ oSession.o.console.PowerDown();
+
+ return (fRc, oTxsSession);
+
+if __name__ == '__main__':
+ sys.exit(tdAddGuestCtrl().main(sys.argv));