diff options
Diffstat (limited to 'src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py')
| -rwxr-xr-x | src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py | 3753 |
1 files changed, 3753 insertions, 0 deletions
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)); |