summaryrefslogtreecommitdiffstats
path: root/src/VBox/ValidationKit/tests/additions
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/VBox/ValidationKit/tests/additions/Makefile.kmk54
-rwxr-xr-xsrc/VBox/ValidationKit/tests/additions/tdAddBasic1.py649
-rwxr-xr-xsrc/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py5503
-rwxr-xr-xsrc/VBox/ValidationKit/tests/additions/tdAddSharedFolders1.py361
4 files changed, 6567 insertions, 0 deletions
diff --git a/src/VBox/ValidationKit/tests/additions/Makefile.kmk b/src/VBox/ValidationKit/tests/additions/Makefile.kmk
new file mode 100644
index 00000000..5af122d2
--- /dev/null
+++ b/src/VBox/ValidationKit/tests/additions/Makefile.kmk
@@ -0,0 +1,54 @@
+# $Id: Makefile.kmk $
+## @file
+# VirtualBox Validation Kit - Additions Tests.
+#
+
+#
+# Copyright (C) 2006-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation, in version 3 of the
+# License.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses>.
+#
+# The contents of this file may alternatively be used under the terms
+# of the Common Development and Distribution License Version 1.0
+# (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+# in the VirtualBox 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.
+#
+# SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+#
+
+SUB_DEPTH = ../../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+
+INSTALLS += ValidationKitTestsAdditions
+ValidationKitTestsAdditions_TEMPLATE = VBoxValidationKitR3
+ValidationKitTestsAdditions_INST = $(INST_VALIDATIONKIT)tests/additions/
+ValidationKitTestsAdditions_EXEC_SOURCES := \
+ $(PATH_SUB_CURRENT)/tdAddBasic1.py \
+ $(PATH_SUB_CURRENT)/tdAddGuestCtrl.py \
+ $(PATH_SUB_CURRENT)/tdAddSharedFolders1.py
+
+
+VBOX_VALIDATIONKIT_PYTHON_SOURCES += $(ValidationKitTestsAdditions_EXEC_SOURCES)
+
+$(evalcall def_vbox_validationkit_process_python_sources)
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/ValidationKit/tests/additions/tdAddBasic1.py b/src/VBox/ValidationKit/tests/additions/tdAddBasic1.py
new file mode 100755
index 00000000..572e5048
--- /dev/null
+++ b/src/VBox/ValidationKit/tests/additions/tdAddBasic1.py
@@ -0,0 +1,649 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# $Id: tdAddBasic1.py $
+
+"""
+VirtualBox Validation Kit - Additions Basics #1.
+"""
+
+__copyright__ = \
+"""
+Copyright (C) 2010-2023 Oracle and/or its affiliates.
+
+This file is part of VirtualBox base platform packages, as
+available from https://www.virtualbox.org.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation, in version 3 of the
+License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, see <https://www.gnu.org/licenses>.
+
+The contents of this file may alternatively be used under the terms
+of the Common Development and Distribution License Version 1.0
+(CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+in the VirtualBox 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.
+
+SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+"""
+__version__ = "$Revision: 155244 $"
+
+# Standard Python imports.
+import os;
+import sys;
+import uuid;
+
+# Only the main script needs to modify the path.
+try: __file__
+except: __file__ = sys.argv[0];
+g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))));
+sys.path.append(g_ksValidationKitDir);
+
+# Validation Kit imports.
+from testdriver import reporter;
+from testdriver import base;
+from testdriver import vbox;
+from testdriver import vboxcon;
+
+# Sub-test driver imports.
+sys.path.append(os.path.dirname(os.path.abspath(__file__))); # For sub-test drivers.
+from tdAddGuestCtrl import SubTstDrvAddGuestCtrl;
+from tdAddSharedFolders1 import SubTstDrvAddSharedFolders1;
+
+
+class tdAddBasic1(vbox.TestDriver): # pylint: disable=too-many-instance-attributes
+ """
+ Additions Basics #1.
+ """
+ ## @todo
+ # - More of the settings stuff can be and need to be generalized!
+ #
+
+ def __init__(self):
+ vbox.TestDriver.__init__(self);
+ self.oTestVmSet = self.oTestVmManager.getSmokeVmSet('nat');
+ self.asTestsDef = ['install', 'guestprops', 'stdguestprops', 'guestcontrol', 'sharedfolders'];
+ self.asTests = self.asTestsDef;
+ self.asRsrcs = None
+ # The file we're going to use as a beacon to wait if the Guest Additions CD-ROM is ready.
+ self.sFileCdWait = '';
+ # Path pointing to the Guest Additions on the (V)ISO file.
+ self.sGstPathGaPrefix = '';
+
+ self.addSubTestDriver(SubTstDrvAddGuestCtrl(self));
+ self.addSubTestDriver(SubTstDrvAddSharedFolders1(self));
+
+ #
+ # Overridden methods.
+ #
+ def showUsage(self):
+ """ Shows this driver's command line options. """
+ rc = vbox.TestDriver.showUsage(self);
+ reporter.log('');
+ reporter.log('tdAddBasic1 Options:');
+ reporter.log(' --tests <s1[:s2[:]]>');
+ reporter.log(' Default: %s (all)' % (':'.join(self.asTestsDef)));
+ reporter.log(' --quick');
+ reporter.log(' Same as --virt-modes hwvirt --cpu-counts 1.');
+ return rc;
+
+ def parseOption(self, asArgs, iArg): # pylint: disable=too-many-branches,too-many-statements
+ if asArgs[iArg] == '--tests':
+ iArg += 1;
+ if iArg >= len(asArgs): raise base.InvalidOption('The "--tests" takes a colon separated list of tests');
+ self.asTests = asArgs[iArg].split(':');
+ for s in self.asTests:
+ if s not in self.asTestsDef:
+ raise base.InvalidOption('The "--tests" value "%s" is not valid; valid values are: %s'
+ % (s, ' '.join(self.asTestsDef),));
+
+ elif asArgs[iArg] == '--quick':
+ self.parseOption(['--virt-modes', 'hwvirt'], 0);
+ self.parseOption(['--cpu-counts', '1'], 0);
+
+ else:
+ return vbox.TestDriver.parseOption(self, asArgs, iArg);
+ return iArg + 1;
+
+ def getResourceSet(self):
+ if self.asRsrcs is None:
+ self.asRsrcs = []
+ for oSubTstDrv in self.aoSubTstDrvs:
+ self.asRsrcs.extend(oSubTstDrv.asRsrcs)
+ self.asRsrcs.extend(self.oTestVmSet.getResourceSet())
+ return self.asRsrcs
+
+ def actionConfig(self):
+ if not self.importVBoxApi(): # So we can use the constant below.
+ return False;
+
+ eNic0AttachType = vboxcon.NetworkAttachmentType_NAT;
+ sGaIso = self.getGuestAdditionsIso();
+
+ # On 6.0 we merge the GAs with the ValidationKit so we can get at FsPerf.
+ #
+ # Note1: Not possible to do a double import as both images an '/OS2' dir.
+ # So, using same dir as with unattended VISOs for the valkit.
+ #
+ # Note2: We need to make sure that we don't change the location of the
+ # ValidationKit bits of the combined VISO, as this will break TXS' (TestExecService)
+ # automatic updating mechanism (uses hardcoded paths, e.g. "{CDROM}/linux/amd64/TestExecService").
+ #
+ ## @todo Find a solution for testing the automatic Guest Additions updates, which also looks at {CDROM}s root.
+ if self.fpApiVer >= 6.0:
+ sGaViso = os.path.join(self.sScratchPath, 'AdditionsAndValKit.viso');
+ ## @todo encode as bash cmd line:
+ sVisoContent = '--iprt-iso-maker-file-marker-bourne-sh %s ' \
+ '--import-iso \'%s\' ' \
+ '--push-iso \'%s\' ' \
+ '/vboxadditions=/ ' \
+ '--pop ' \
+ % (uuid.uuid4(), self.sVBoxValidationKitIso, sGaIso);
+ reporter.log2('Using VISO combining ValKit and GAs "%s": %s' % (sVisoContent, sGaViso));
+ with open(sGaViso, 'w') as oGaViso: # pylint: disable=unspecified-encoding
+ oGaViso.write(sVisoContent);
+ sGaIso = sGaViso;
+
+ self.sGstPathGaPrefix = 'vboxadditions';
+ else:
+ self.sGstPathGaPrefix = '';
+
+
+ reporter.log2('Path to Guest Additions on ISO is "%s"' % self.sGstPathGaPrefix);
+
+ return self.oTestVmSet.actionConfig(self, eNic0AttachType = eNic0AttachType, sDvdImage = sGaIso);
+
+ def actionExecute(self):
+ return self.oTestVmSet.actionExecute(self, self.testOneCfg);
+
+
+ #
+ # Test execution helpers.
+ #
+
+ def testOneCfg(self, oVM, oTestVm):
+ """
+ Runs the specified VM thru the tests.
+
+ Returns a success indicator on the general test execution. This is not
+ the actual test result.
+ """
+ fRc = False;
+
+ self.logVmInfo(oVM);
+
+ # We skip Linux Guest Additions testing for VBox < 6.1 for now.
+ fVersionIgnored = oTestVm.isLinux() and self.fpApiVer < 6.1;
+
+ if fVersionIgnored:
+ reporter.log('Skipping testing for "%s" because VBox version %s is ignored' % (oTestVm.sKind, self.fpApiVer,));
+ fRc = True;
+ else:
+ reporter.testStart('Waiting for TXS');
+ if oTestVm.isWindows():
+ self.sFileCdWait = ('%s/VBoxWindowsAdditions.exe' % (self.sGstPathGaPrefix,));
+ elif oTestVm.isLinux():
+ self.sFileCdWait = ('%s/VBoxLinuxAdditions.run' % (self.sGstPathGaPrefix,));
+
+ oSession, oTxsSession = self.startVmAndConnectToTxsViaTcp(oTestVm.sVmName, fCdWait = True,
+ cMsCdWait = 5 * 60 * 1000,
+ sFileCdWait = self.sFileCdWait);
+ reporter.testDone();
+
+ if oSession is not None \
+ and oTxsSession is not None:
+ self.addTask(oTxsSession);
+ # Do the testing.
+ fSkip = 'install' not in self.asTests;
+ reporter.testStart('Install');
+ if not fSkip:
+ fRc, oTxsSession = self.testInstallAdditions(oSession, oTxsSession, oTestVm);
+ reporter.testDone(fSkip);
+
+ if not fSkip \
+ and not fRc:
+ reporter.log('Skipping following tests as Guest Additions were not installed successfully');
+ else:
+ fSkip = 'guestprops' not in self.asTests;
+ reporter.testStart('Guest Properties');
+ if not fSkip:
+ fRc = self.testGuestProperties(oSession, oTxsSession, oTestVm) and fRc;
+ reporter.testDone(fSkip);
+
+ fSkip = 'guestcontrol' not in self.asTests;
+ reporter.testStart('Guest Control');
+ if not fSkip:
+ fRc, oTxsSession = self.aoSubTstDrvs[0].testIt(oTestVm, oSession, oTxsSession);
+ reporter.testDone(fSkip);
+
+ fSkip = 'sharedfolders' not in self.asTests;
+ reporter.testStart('Shared Folders');
+ if not fSkip:
+ fRc, oTxsSession = self.aoSubTstDrvs[1].testIt(oTestVm, oSession, oTxsSession);
+ reporter.testDone(fSkip or fRc is None);
+
+ ## @todo Save and restore test.
+
+ ## @todo Reset tests.
+
+ ## @todo Final test: Uninstallation.
+
+ # Download the TxS (Test Execution Service) log. This is not fatal when not being present.
+ if not fRc:
+ self.txsDownloadFiles(oSession, oTxsSession,
+ [ (oTestVm.pathJoin(self.getGuestTempDir(oTestVm), 'vbox-txs-release.log'),
+ 'vbox-txs-%s.log' % oTestVm.sVmName) ],
+ fIgnoreErrors = True);
+
+ # Cleanup.
+ self.removeTask(oTxsSession);
+ self.terminateVmBySession(oSession);
+
+ return fRc;
+
+ def testInstallAdditions(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests installing the guest additions
+ """
+ if oTestVm.isWindows():
+ (fRc, oTxsSession) = self.testWindowsInstallAdditions(oSession, oTxsSession, oTestVm);
+ elif oTestVm.isLinux():
+ (fRc, oTxsSession) = self.testLinuxInstallAdditions(oSession, oTxsSession, oTestVm);
+ else:
+ reporter.error('Guest Additions installation not implemented for %s yet! (%s)' %
+ (oTestVm.sKind, oTestVm.sVmName,));
+ fRc = False;
+
+ #
+ # Verify installation of Guest Additions using commmon bits.
+ #
+ if fRc:
+ #
+ # Check if the additions are operational.
+ #
+ try: oGuest = oSession.o.console.guest;
+ except:
+ reporter.errorXcpt('Getting IGuest failed.');
+ return (False, oTxsSession);
+
+ # Wait for the GAs to come up.
+ reporter.testStart('IGuest::additionsRunLevel');
+ fRc = self.testIGuest_additionsRunLevel(oSession, oTestVm, oGuest);
+ reporter.testDone();
+
+ # Check the additionsVersion attribute. It must not be empty.
+ reporter.testStart('IGuest::additionsVersion');
+ fRc = self.testIGuest_additionsVersion(oGuest) and fRc;
+ reporter.testDone();
+
+ # Check Guest Additions facilities
+ reporter.testStart('IGuest::getFacilityStatus');
+ fRc = self.testIGuest_getFacilityStatus(oTestVm, oGuest) and fRc;
+ reporter.testDone();
+
+ # Do a bit of diagnosis on error.
+ if not fRc:
+ if oTestVm.isLinux():
+ reporter.log('Boot log:');
+ sCmdJournalCtl = oTestVm.pathJoin(self.getGuestSystemDir(oTestVm), 'journalctl');
+ oTxsSession.syncExec(sCmdJournalCtl, (sCmdJournalCtl, '-b'), fIgnoreErrors = True);
+ reporter.log('Loaded processes:');
+ sCmdPs = oTestVm.pathJoin(self.getGuestSystemDir(oTestVm), 'ps');
+ oTxsSession.syncExec(sCmdPs, (sCmdPs, '-a', '-u', '-x'), fIgnoreErrors = True);
+ reporter.log('Kernel messages:');
+ sCmdDmesg = oTestVm.pathJoin(self.getGuestSystemDir(oTestVm), 'dmesg');
+ oTxsSession.syncExec(sCmdDmesg, (sCmdDmesg), fIgnoreErrors = True);
+ reporter.log('Loaded modules:');
+ sCmdLsMod = oTestVm.pathJoin(self.getGuestSystemAdminDir(oTestVm), 'lsmod');
+ oTxsSession.syncExec(sCmdLsMod, (sCmdLsMod), fIgnoreErrors = True);
+ elif oTestVm.isWindows() or oTestVm.isOS2():
+ sShell = self.getGuestSystemShell(oTestVm);
+ sShellOpt = '/C' if oTestVm.isWindows() or oTestVm.isOS2() else '-c';
+ reporter.log('Loaded processes:');
+ oTxsSession.syncExec(sShell, (sShell, sShellOpt, "tasklist.exe", "/FO", "CSV"), fIgnoreErrors = True);
+ reporter.log('Listing autostart entries:');
+ oTxsSession.syncExec(sShell, (sShell, sShellOpt, "wmic.exe", "startup", "get"), fIgnoreErrors = True);
+ reporter.log('Listing autostart entries:');
+ oTxsSession.syncExec(sShell, (sShell, sShellOpt, "dir",
+ oTestVm.pathJoin(self.getGuestSystemDir(oTestVm), 'VBox*')),
+ fIgnoreErrors = True);
+ reporter.log('Downloading logs ...');
+ self.txsDownloadFiles(oSession, oTxsSession,
+ [ ( self.getGuestVBoxTrayClientLogFile(oTestVm),
+ 'ga-vboxtrayclient-%s.log' % (oTestVm.sVmName,),),
+ ( "C:\\Documents and Settings\\All Users\\Application Data\\Microsoft\\Dr Watson\\drwtsn32.log",
+ 'ga-drwatson-%s.log' % (oTestVm.sVmName,), ),
+ ],
+ fIgnoreErrors = True);
+
+ return (fRc, oTxsSession);
+
+ def getGuestVBoxTrayClientLogFile(self, oTestVm):
+ """ Gets the path on the guest for the (release) log file of VBoxTray / VBoxClient. """
+ if oTestVm.isWindows():
+ return oTestVm.pathJoin(self.getGuestTempDir(oTestVm), 'VBoxTray.log');
+
+ return oTestVm.pathJoin(self.getGuestTempDir(oTestVm), 'VBoxClient.log');
+
+ def setGuestEnvVar(self, oSession, oTxsSession, oTestVm, sName, sValue):
+ """ Sets a system-wide environment variable on the guest. Only supports Windows guests so far. """
+ _ = oSession;
+ if oTestVm.isWindows():
+ sPathRegExe = oTestVm.pathJoin(self.getGuestSystemDir(oTestVm), 'reg.exe');
+ self.txsRunTest(oTxsSession, ('Set env var \"%s\"' % (sName,)),
+ 30 * 1000, sPathRegExe,
+ (sPathRegExe, 'add',
+ '"HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment"', '/v',
+ sName, '/t', 'REG_EXPAND_SZ', '/d', sValue, '/f'));
+
+ def testWindowsInstallAdditions(self, oSession, oTxsSession, oTestVm):
+ """
+ Installs the Windows guest additions using the test execution service.
+ Since this involves rebooting the guest, we will have to create a new TXS session.
+ """
+
+ # Set system-wide env vars to enable release logging on some applications.
+ self.setGuestEnvVar(oSession, oTxsSession, oTestVm, 'VBOXTRAY_RELEASE_LOG', 'all.e.l.l2.l3.f');
+ self.setGuestEnvVar(oSession, oTxsSession, oTestVm, 'VBOXTRAY_RELEASE_LOG_FLAGS', 'time thread group append');
+ self.setGuestEnvVar(oSession, oTxsSession, oTestVm, 'VBOXTRAY_RELEASE_LOG_DEST',
+ ('file=%s' % (self.getGuestVBoxTrayClientLogFile(oTestVm),)));
+
+ #
+ # Install the public signing key.
+ #
+ if oTestVm.sKind not in ('WindowsNT4', 'Windows2000', 'WindowsXP', 'Windows2003'):
+ fRc = self.txsRunTest(oTxsSession, 'VBoxCertUtil.exe', 1 * 60 * 1000,
+ '${CDROM}/%s/cert/VBoxCertUtil.exe' % self.sGstPathGaPrefix,
+ ('${CDROM}/%s/cert/VBoxCertUtil.exe' % self.sGstPathGaPrefix, 'add-trusted-publisher',
+ '${CDROM}/%s/cert/vbox-sha1.cer' % self.sGstPathGaPrefix),
+ fCheckSessionStatus = True);
+ if not fRc:
+ reporter.error('Error installing SHA1 certificate');
+ else:
+ fRc = self.txsRunTest(oTxsSession, 'VBoxCertUtil.exe', 1 * 60 * 1000,
+ '${CDROM}/%s/cert/VBoxCertUtil.exe' % self.sGstPathGaPrefix,
+ ('${CDROM}/%s/cert/VBoxCertUtil.exe' % self.sGstPathGaPrefix, 'add-trusted-publisher',
+ '${CDROM}/%s/cert/vbox-sha256.cer' % self.sGstPathGaPrefix), fCheckSessionStatus = True);
+ if not fRc:
+ reporter.error('Error installing SHA256 certificate');
+
+ #
+ # Delete relevant log files.
+ #
+ # Note! On some guests the files in question still can be locked by the OS, so ignore
+ # deletion errors from the guest side (e.g. sharing violations) and just continue.
+ #
+ sWinDir = self.getGuestWinDir(oTestVm);
+ aasLogFiles = [
+ ( oTestVm.pathJoin(sWinDir, 'setupapi.log'), 'ga-setupapi-%s.log' % (oTestVm.sVmName,), ),
+ ( oTestVm.pathJoin(sWinDir, 'setupact.log'), 'ga-setupact-%s.log' % (oTestVm.sVmName,), ),
+ ( oTestVm.pathJoin(sWinDir, 'setuperr.log'), 'ga-setuperr-%s.log' % (oTestVm.sVmName,), ),
+ ];
+
+ # Apply The SetupAPI logging level so that we also get the (most verbose) setupapi.dev.log file.
+ ## @todo !!! HACK ALERT !!! Add the value directly into the testing source image. Later.
+ sRegExe = oTestVm.pathJoin(self.getGuestSystemDir(oTestVm), 'reg.exe');
+ fHaveSetupApiDevLog = self.txsRunTest(oTxsSession, 'Enabling setupapi.dev.log', 30 * 1000,
+ sRegExe,
+ (sRegExe, 'add',
+ '"HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Setup"',
+ '/v', 'LogLevel', '/t', 'REG_DWORD', '/d', '0xFF'),
+ fCheckSessionStatus = True);
+
+ for sGstFile, _ in aasLogFiles:
+ self.txsRmFile(oSession, oTxsSession, sGstFile, 10 * 1000, fIgnoreErrors = True);
+
+ # Enable installing the optional auto-logon modules (VBoxGINA/VBoxCredProv).
+ # Also tell the installer to produce the appropriate log files.
+ sExe = '${CDROM}/%s/VBoxWindowsAdditions.exe' % self.sGstPathGaPrefix;
+ asArgs = [ sExe, '/S', '/l', '/with_autologon' ];
+
+ # Determine if we need to force installing the legacy timestamp CA to make testing succeed.
+ # Note: Don't force installing when the Guest Additions installer should do this automatically,
+ # i.e, only force it for Windows Server 2016 and up.
+ fForceInstallTimeStampCA = False;
+ if self.fpApiVer >= 6.1 \
+ and oTestVm.getNonCanonicalGuestOsType() \
+ in [ 'Windows2016', 'Windows2019', 'Windows2022', 'Windows11' ]:
+ fForceInstallTimeStampCA = True;
+
+ # As we don't have a console command line to parse for the Guest Additions installer (only a message box) and
+ # unknown / unsupported parameters get ignored with silent installs anyway, we safely can add the following parameter(s)
+ # even if older Guest Addition installers might not support those.
+ if fForceInstallTimeStampCA:
+ asArgs.extend([ '/install_timestamp_ca' ]);
+
+ #
+ # Do the actual install.
+ #
+ fRc = self.txsRunTest(oTxsSession, 'VBoxWindowsAdditions.exe', 5 * 60 * 1000,
+ sExe, asArgs, fCheckSessionStatus = True);
+
+ # Add the Windows Guest Additions installer files to the files we want to download
+ # from the guest. Note: There won't be a install_ui.log because of the silent installation.
+ sGuestAddsDir = 'C:\\Program Files\\Oracle\\VirtualBox Guest Additions\\';
+ aasLogFiles.append((sGuestAddsDir + 'install.log', 'ga-install-%s.log' % (oTestVm.sVmName,),));
+ aasLogFiles.append((sGuestAddsDir + 'install_drivers.log', 'ga-install_drivers-%s.log' % (oTestVm.sVmName,),));
+ aasLogFiles.append(('C:\\Windows\\setupapi.log', 'ga-setupapi-%s.log' % (oTestVm.sVmName,),));
+
+ # Note: setupapi.dev.log only is available since Windows 2000.
+ if fHaveSetupApiDevLog:
+ aasLogFiles.append(('C:\\Windows\\setupapi.dev.log', 'ga-setupapi.dev-%s.log' % (oTestVm.sVmName,),));
+
+ #
+ # Download log files.
+ # Ignore errors as all files above might not be present (or in different locations)
+ # on different Windows guests.
+ #
+ self.txsDownloadFiles(oSession, oTxsSession, aasLogFiles, fIgnoreErrors = True);
+
+ #
+ # Reboot the VM and reconnect the TXS session.
+ #
+ if fRc:
+ reporter.testStart('Rebooting guest w/ updated Guest Additions active');
+ (fRc, oTxsSession) = self.txsRebootAndReconnectViaTcp(oSession, oTxsSession, cMsTimeout = 15 * 60 * 1000);
+ if fRc:
+ pass;
+ else:
+ reporter.testFailure('Rebooting and reconnecting to TXS service failed');
+ reporter.testDone();
+ else:
+ reporter.error('Error installing Windows Guest Additions (installer returned with exit code <> 0)')
+
+ return (fRc, oTxsSession);
+
+ def getAdditionsInstallerResult(self, oTxsSession):
+ """
+ Extracts the Guest Additions installer exit code from a run before.
+ Assumes that nothing else has been run on the same TXS session in the meantime.
+ """
+ iRc = 0;
+ (_, sOpcode, abPayload) = oTxsSession.getLastReply();
+ if sOpcode.startswith('PROC NOK '): # Extract process rc
+ iRc = abPayload[0]; # ASSUMES 8-bit rc for now.
+ ## @todo Parse more statuses here.
+ return iRc;
+
+ def testLinuxInstallAdditions(self, oSession, oTxsSession, oTestVm):
+ #
+ # The actual install.
+ # Also tell the installer to produce the appropriate log files.
+ #
+ # Make sure to add "--nox11" to the makeself wrapper in order to not getting any blocking
+ # xterm window spawned.
+ fRc = self.txsRunTest(oTxsSession, 'VBoxLinuxAdditions.run', 30 * 60 * 1000,
+ self.getGuestSystemShell(oTestVm),
+ (self.getGuestSystemShell(oTestVm),
+ '${CDROM}/%s/VBoxLinuxAdditions.run' % self.sGstPathGaPrefix, '--nox11'));
+ if not fRc:
+ iRc = self.getAdditionsInstallerResult(oTxsSession);
+ # Check for rc == 0 just for completeness.
+ if iRc in (0, 2): # Can happen if the GA installer has detected older VBox kernel modules running and needs a reboot.
+ reporter.log('Guest has old(er) VBox kernel modules still running; requires a reboot');
+ fRc = True;
+
+ if not fRc:
+ reporter.error('Installing Linux Additions failed (isSuccess=%s, lastReply=%s, see log file for details)'
+ % (oTxsSession.isSuccess(), oTxsSession.getLastReply()));
+
+ #
+ # Download log files.
+ # Ignore errors as all files above might not be present for whatever reason.
+ #
+ self.txsDownloadFiles(oSession, oTxsSession,
+ [('/var/log/vboxadd-install.log', 'vboxadd-install-%s.log' % oTestVm.sVmName), ],
+ fIgnoreErrors = True);
+
+ # Do the final reboot to get the just installed Guest Additions up and running.
+ if fRc:
+ reporter.testStart('Rebooting guest w/ updated Guest Additions active');
+ (fRc, oTxsSession) = self.txsRebootAndReconnectViaTcp(oSession, oTxsSession, cMsTimeout = 15 * 60 * 1000);
+ if fRc:
+ pass
+ else:
+ reporter.testFailure('Rebooting and reconnecting to TXS service failed');
+ reporter.testDone();
+
+ return (fRc, oTxsSession);
+
+ def testIGuest_additionsRunLevel(self, oSession, oTestVm, oGuest):
+ """
+ Do run level tests.
+ """
+
+ _ = oGuest;
+
+ if oTestVm.isWindows():
+ if oTestVm.isLoggedOntoDesktop():
+ eExpectedRunLevel = vboxcon.AdditionsRunLevelType_Desktop;
+ else:
+ eExpectedRunLevel = vboxcon.AdditionsRunLevelType_Userland;
+ else:
+ ## @todo VBoxClient does not have facility statuses implemented yet.
+ eExpectedRunLevel = vboxcon.AdditionsRunLevelType_Userland;
+
+ return self.waitForGAs(oSession, aenmWaitForRunLevels = [ eExpectedRunLevel ]);
+
+ def testIGuest_additionsVersion(self, oGuest):
+ """
+ Returns False if no version string could be obtained, otherwise True
+ even though errors are logged.
+ """
+ try:
+ sVer = oGuest.additionsVersion;
+ except:
+ reporter.errorXcpt('Getting the additions version failed.');
+ return False;
+ reporter.log('IGuest::additionsVersion="%s"' % (sVer,));
+
+ if sVer.strip() == '':
+ reporter.error('IGuest::additionsVersion is empty.');
+ return False;
+
+ if sVer != sVer.strip():
+ reporter.error('IGuest::additionsVersion is contains spaces: "%s".' % (sVer,));
+
+ asBits = sVer.split('.');
+ if len(asBits) < 3:
+ reporter.error('IGuest::additionsVersion does not contain at least tree dot separated fields: "%s" (%d).'
+ % (sVer, len(asBits)));
+
+ ## @todo verify the format.
+ return True;
+
+ def checkFacilityStatus(self, oGuest, eFacilityType, sDesc, fMustSucceed = True):
+ """
+ Prints the current status of a Guest Additions facility.
+
+ Return success status.
+ """
+
+ fRc = True;
+
+ try:
+ eStatus, tsLastUpdatedMs = oGuest.getFacilityStatus(eFacilityType);
+ except:
+ if fMustSucceed:
+ reporter.errorXcpt('Getting facility status for "%s" failed' % (sDesc,));
+ fRc = False;
+ else:
+ if eStatus == vboxcon.AdditionsFacilityStatus_Inactive:
+ sStatus = "INACTIVE";
+ elif eStatus == vboxcon.AdditionsFacilityStatus_Paused:
+ sStatus = "PAUSED";
+ elif eStatus == vboxcon.AdditionsFacilityStatus_PreInit:
+ sStatus = "PREINIT";
+ elif eStatus == vboxcon.AdditionsFacilityStatus_Init:
+ sStatus = "INIT";
+ elif eStatus == vboxcon.AdditionsFacilityStatus_Active:
+ sStatus = "ACTIVE";
+ elif eStatus == vboxcon.AdditionsFacilityStatus_Terminating:
+ sStatus = "TERMINATING";
+ fRc = not fMustSucceed;
+ elif eStatus == vboxcon.AdditionsFacilityStatus_Terminated:
+ sStatus = "TERMINATED";
+ fRc = not fMustSucceed;
+ elif eStatus == vboxcon.AdditionsFacilityStatus_Failed:
+ sStatus = "FAILED";
+ fRc = not fMustSucceed;
+ elif eStatus == vboxcon.AdditionsFacilityStatus_Unknown:
+ sStatus = "UNKNOWN";
+ fRc = not fMustSucceed;
+ else:
+ sStatus = "???";
+ fRc = not fMustSucceed;
+
+ reporter.log('Guest Additions facility "%s": %s (last updated: %sms)' % (sDesc, sStatus, str(tsLastUpdatedMs)));
+ if fMustSucceed \
+ and not fRc:
+ reporter.error('Guest Additions facility "%s" did not report expected status (is "%s")' % (sDesc, sStatus));
+
+ return fRc;
+
+ def testIGuest_getFacilityStatus(self, oTestVm, oGuest):
+ """
+ Checks Guest Additions facilities for their status.
+
+ Returns success status.
+ """
+
+ reporter.testStart('Status VBoxGuest Driver');
+ fRc = self.checkFacilityStatus(oGuest, vboxcon.AdditionsFacilityType_VBoxGuestDriver, "VBoxGuest Driver");
+ reporter.testDone();
+
+ reporter.testStart('Status VBoxService');
+ fRc = self.checkFacilityStatus(oGuest, vboxcon.AdditionsFacilityType_VBoxService, "VBoxService") and fRc;
+ reporter.testDone();
+
+ if oTestVm.isWindows():
+ if oTestVm.isLoggedOntoDesktop():
+ ## @todo VBoxClient does not have facility statuses implemented yet.
+ reporter.testStart('Status VBoxTray / VBoxClient');
+ fRc = self.checkFacilityStatus(oGuest, vboxcon.AdditionsFacilityType_VBoxTrayClient,
+ "VBoxTray / VBoxClient") and fRc;
+ reporter.testDone();
+ ## @todo Add more.
+
+ return fRc;
+
+ def testGuestProperties(self, oSession, oTxsSession, oTestVm):
+ """
+ Test guest properties.
+ """
+ _ = oSession; _ = oTxsSession; _ = oTestVm;
+ return True;
+
+if __name__ == '__main__':
+ sys.exit(tdAddBasic1().main(sys.argv));
diff --git a/src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py b/src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py
new file mode 100755
index 00000000..0b4ef4bf
--- /dev/null
+++ b/src/VBox/ValidationKit/tests/additions/tdAddGuestCtrl.py
@@ -0,0 +1,5503 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# pylint: disable=too-many-lines
+
+"""
+VirtualBox Validation Kit - Guest Control Tests.
+"""
+
+__copyright__ = \
+"""
+Copyright (C) 2010-2023 Oracle and/or its affiliates.
+
+This file is part of VirtualBox base platform packages, as
+available from https://www.virtualbox.org.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation, in version 3 of the
+License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, see <https://www.gnu.org/licenses>.
+
+The contents of this file may alternatively be used under the terms
+of the Common Development and Distribution License Version 1.0
+(CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+in the VirtualBox 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.
+
+SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+"""
+__version__ = "$Revision: 155473 $"
+
+# Standard Python imports.
+import errno
+import os
+import random
+import string
+import struct
+import sys
+import threading
+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 testfileset;
+from testdriver import vbox;
+from testdriver import vboxcon;
+from testdriver import vboxtestfileset;
+from testdriver import vboxwrappers;
+from common import utils;
+
+# Python 3 hacks:
+if sys.version_info[0] >= 3:
+ long = int # pylint: disable=redefined-builtin,invalid-name
+ xrange = range; # pylint: disable=redefined-builtin,invalid-name
+
+def limitString(sString, cLimit = 128):
+ """
+ Returns a string with ellipsis ("...") when exceeding the specified limit.
+ Useful for toning down logging. By default strings will be shortened at 128 characters.
+ """
+ if not isinstance(sString, str):
+ sString = str(sString);
+ cLen = len(sString);
+ if not cLen:
+ return '';
+ return (sString[:cLimit] + '...[%d more]' % (cLen - cLimit)) if cLen > cLimit else sString;
+
+class GuestStream(bytearray):
+ """
+ Class for handling a guest process input/output stream.
+
+ @todo write stdout/stderr tests.
+ """
+ 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 tdCtxCreds(object):
+ """
+ Provides credentials to pass to the guest.
+ """
+ def __init__(self, sUser = None, sPassword = None, sDomain = None):
+ self.oTestVm = None;
+ self.sUser = sUser;
+ self.sPassword = sPassword;
+ self.sDomain = sDomain;
+
+ def applyDefaultsIfNotSet(self, oTestVm):
+ """
+ Applies credential defaults, based on the test VM (guest OS), if
+ no credentials were set yet.
+
+ Returns success status.
+ """
+ self.oTestVm = oTestVm;
+ if not self.oTestVm:
+ reporter.log('VM object is invalid -- did VBoxSVC or a client crash?');
+ return False;
+
+ if self.sUser is None:
+ self.sUser = self.oTestVm.getTestUser();
+
+ if self.sPassword is None:
+ self.sPassword = self.oTestVm.getTestUserPassword(self.sUser);
+
+ if self.sDomain is None:
+ self.sDomain = '';
+
+ return True;
+
+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, oCreds = None):
+ self.oGuest = None; ##< IGuest.
+ self.oTestVm = None;
+ self.oCreds = oCreds ##< type: tdCtxCreds
+ self.timeoutMS = 30 * 1000; ##< 30s timeout
+ self.oGuestSession = None; ##< IGuestSession reference or None.
+
+ def setEnvironment(self, oSession, oTxsSession, oTestVm):
+ """
+ Sets the test environment required for this test.
+
+ Returns success status.
+ """
+ _ = oTxsSession;
+
+ fRc = True;
+ try:
+ self.oGuest = oSession.o.console.guest;
+ self.oTestVm = oTestVm;
+ except:
+ fRc = reporter.errorXcpt();
+
+ if self.oCreds is None:
+ self.oCreds = tdCtxCreds();
+
+ fRc = fRc and self.oCreds.applyDefaultsIfNotSet(self.oTestVm);
+
+ if not fRc:
+ reporter.log('Error setting up Guest Control testing environment!');
+
+ return fRc;
+
+ def uploadLogData(self, oTstDrv, aData, sFileName, sDesc):
+ """
+ Uploads (binary) data to a log file for manual (later) inspection.
+ """
+ reporter.log('Creating + uploading log data file "%s"' % sFileName);
+ sHstFileName = os.path.join(oTstDrv.sScratchPath, sFileName);
+ try:
+ with open(sHstFileName, "wb") as oCurTestFile:
+ oCurTestFile.write(aData);
+ except:
+ return reporter.error('Unable to create temporary file for "%s"' % (sDesc,));
+ return reporter.addLogFile(sHstFileName, 'misc/other', sDesc);
+
+ def createSession(self, sName, fIsError = True):
+ """
+ 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>";
+
+ reporter.log('Creating session "%s" ...' % (sName,));
+ try:
+ self.oGuestSession = self.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.maybeErrXcpt(fIsError, '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);
+
+ tsStartMs = base.timestampMilli();
+ while base.timestampMilli() - tsStartMs < self.timeoutMS:
+ reporter.log('Waiting for session "%s" to start within %dms...' % (sName, self.timeoutMS));
+ aeWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start, ];
+ try:
+ waitResult = self.oGuestSession.waitForArray(aeWaitFor, self.timeoutMS);
+
+ # Log session status changes.
+ if waitResult is vboxcon.GuestSessionWaitResult_Status:
+ reporter.log('Session "%s" indicated status change (status is now %d)' \
+ % (sName, self.oGuestSession.status));
+ if self.oGuestSession.status is vboxcon.GuestSessionStatus_Started:
+ # We indicate an error here, as we intentionally waited for the session start
+ # in the wait call above and got back a status change instead.
+ reporter.error('Session "%s" successfully started (thru status change)' % (sName,));
+ break;
+ continue; # Continue waiting for the session to start.
+
+ #
+ # Be nice to Guest Additions < 4.3: They don't support session handling and
+ # therefore return WaitFlagNotSupported.
+ #
+ if waitResult not in (vboxcon.GuestSessionWaitResult_Start, \
+ vboxcon.GuestSessionWaitResult_WaitFlagNotSupported):
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.maybeErr(fIsError, 'Session did not start successfully, returned wait result: %d' \
+ % (waitResult,));
+ return (False, None);
+ reporter.log('Session "%s" successfully started' % (sName,));
+
+ #
+ # Make sure that the test VM configuration and Guest Control use the same path separator style for the guest.
+ #
+ sGstSep = '\\' if self.oGuestSession.pathStyle is vboxcon.PathStyle_DOS else '/';
+ if self.oTestVm.pathSep() != sGstSep:
+ reporter.error('Configured test VM uses a different path style (%s) than Guest Control (%s)' \
+ % (self.oTestVm.pathSep(), sGstSep));
+ break;
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.maybeErrXcpt(fIsError, '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, fIsError = True):
+ """
+ Closes the guest session.
+ """
+ if self.oGuestSession is not None:
+ try:
+ sName = self.oGuestSession.name;
+ except:
+ return reporter.errorXcpt();
+
+ reporter.log('Closing session "%s" ...' % (sName,));
+ try:
+ self.oGuestSession.close();
+ self.oGuestSession = None;
+ except:
+ # Just log, don't assume an error here (will be done in the main loop then).
+ reporter.maybeErrXcpt(fIsError, '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 = "", oCreds = None, afFlags = None, oSrc = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sSrc = sSrc;
+ self.sDst = sDst;
+ self.afFlags = afFlags;
+ self.oSrc = oSrc # type: testfileset.TestFsObj
+ if oSrc and not sSrc:
+ self.sSrc = oSrc.sPath;
+
+class tdTestCopyFromDir(tdTestCopyFrom):
+
+ def __init__(self, sSrc = "", sDst = "", oCreds = None, afFlags = None, oSrc = None, fIntoDst = False):
+ tdTestCopyFrom.__init__(self, sSrc, sDst, oCreds, afFlags, oSrc);
+ self.fIntoDst = fIntoDst; # hint to the verification code that sDst == oSrc, rather than sDst+oSrc.sNAme == oSrc.
+
+class tdTestCopyFromFile(tdTestCopyFrom):
+ pass;
+
+class tdTestRemoveHostDir(object):
+ """
+ Test step that removes a host directory tree.
+ """
+ def __init__(self, sDir):
+ self.sDir = sDir;
+
+ def execute(self, oTstDrv, oVmSession, oTxsSession, oTestVm, sMsgPrefix):
+ _ = oTstDrv; _ = oVmSession; _ = oTxsSession; _ = oTestVm; _ = sMsgPrefix;
+ if os.path.exists(self.sDir):
+ if base.wipeDirectory(self.sDir) != 0:
+ return False;
+ try:
+ os.rmdir(self.sDir);
+ except:
+ return reporter.errorXcpt('%s: sDir=%s' % (sMsgPrefix, self.sDir,));
+ return True;
+
+
+
+class tdTestCopyTo(tdTestGuestCtrlBase):
+ """
+ Test for copying files from the host to the guest.
+ """
+ def __init__(self, sSrc = "", sDst = "", oCreds = None, afFlags = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sSrc = sSrc;
+ self.sDst = sDst;
+ self.afFlags = afFlags;
+
+class tdTestCopyToFile(tdTestCopyTo):
+ pass;
+
+class tdTestCopyToDir(tdTestCopyTo):
+ pass;
+
+class tdTestDirCreate(tdTestGuestCtrlBase):
+ """
+ Test for directoryCreate call.
+ """
+ def __init__(self, sDirectory = "", oCreds = None, fMode = 0, afFlags = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sDirectory = sDirectory;
+ self.fMode = fMode;
+ self.afFlags = afFlags;
+
+class tdTestDirCreateTemp(tdTestGuestCtrlBase):
+ """
+ Test for the directoryCreateTemp call.
+ """
+ def __init__(self, sDirectory = "", sTemplate = "", oCreds = None, fMode = 0, fSecure = False):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sDirectory = sDirectory;
+ self.sTemplate = sTemplate;
+ self.fMode = fMode;
+ self.fSecure = fSecure;
+
+class tdTestDirOpen(tdTestGuestCtrlBase):
+ """
+ Test for the directoryOpen call.
+ """
+ def __init__(self, sDirectory = "", oCreds = None, sFilter = "", afFlags = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sDirectory = sDirectory;
+ self.sFilter = sFilter;
+ self.afFlags = afFlags or [];
+
+class tdTestDirRead(tdTestDirOpen):
+ """
+ Test for the opening, reading and closing a certain directory.
+ """
+ def __init__(self, sDirectory = "", oCreds = None, sFilter = "", afFlags = None):
+ tdTestDirOpen.__init__(self, sDirectory, oCreds, sFilter, afFlags);
+
+class tdTestExec(tdTestGuestCtrlBase):
+ """
+ Specifies exactly one guest control execution test.
+ Has a default timeout of 5 minutes (for safety).
+ """
+ def __init__(self, sCmd = "", asArgs = None, aEnv = None, afFlags = None, # pylint: disable=too-many-arguments
+ timeoutMS = 5 * 60 * 1000, oCreds = None, fWaitForExit = True):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sCmd = sCmd;
+ self.asArgs = asArgs if asArgs is not None else [sCmd,];
+ self.aEnv = aEnv;
+ self.afFlags = afFlags 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 = "", oCreds = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sFile = sFile;
+
+class tdTestFileRemove(tdTestGuestCtrlBase):
+ """
+ Test querying guest file information.
+ """
+ def __init__(self, sFile = "", oCreds = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sFile = sFile;
+
+class tdTestRemoveBase(tdTestGuestCtrlBase):
+ """
+ Removal base.
+ """
+ def __init__(self, sPath, fRcExpect = True, oCreds = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sPath = sPath;
+ self.fRcExpect = fRcExpect;
+
+ def execute(self, oSubTstDrv):
+ """
+ Executes the test, returns True/False.
+ """
+ _ = oSubTstDrv;
+ return True;
+
+ def checkRemoved(self, sType):
+ """ Check that the object was removed using fObjExists. """
+ try:
+ fExists = self.oGuestSession.fsObjExists(self.sPath, False);
+ except:
+ return reporter.errorXcpt('fsObjExists failed on "%s" after deletion (type: %s)' % (self.sPath, sType));
+ if fExists:
+ return reporter.error('fsObjExists says "%s" still exists after deletion (type: %s)!' % (self.sPath, sType));
+ return True;
+
+class tdTestRemoveFile(tdTestRemoveBase):
+ """
+ Remove a single file.
+ """
+ def __init__(self, sPath, fRcExpect = True, oCreds = None):
+ tdTestRemoveBase.__init__(self, sPath, fRcExpect, oCreds);
+
+ def execute(self, oSubTstDrv):
+ reporter.log2('Deleting file "%s" ...' % (limitString(self.sPath),));
+ try:
+ if oSubTstDrv.oTstDrv.fpApiVer >= 5.0:
+ self.oGuestSession.fsObjRemove(self.sPath);
+ else:
+ self.oGuestSession.fileRemove(self.sPath);
+ except:
+ reporter.maybeErrXcpt(self.fRcExpect, 'Removing "%s" failed' % (self.sPath,));
+ return not self.fRcExpect;
+ if not self.fRcExpect:
+ return reporter.error('Expected removing "%s" to failed, but it succeeded' % (self.sPath,));
+
+ return self.checkRemoved('file');
+
+class tdTestRemoveDir(tdTestRemoveBase):
+ """
+ Remove a single directory if empty.
+ """
+ def __init__(self, sPath, fRcExpect = True, oCreds = None):
+ tdTestRemoveBase.__init__(self, sPath, fRcExpect, oCreds);
+
+ def execute(self, oSubTstDrv):
+ _ = oSubTstDrv;
+ reporter.log2('Deleting directory "%s" ...' % (limitString(self.sPath),));
+ try:
+ self.oGuestSession.directoryRemove(self.sPath);
+ except:
+ reporter.maybeErrXcpt(self.fRcExpect, 'Removing "%s" (as a directory) failed' % (self.sPath,));
+ return not self.fRcExpect;
+ if not self.fRcExpect:
+ return reporter.error('Expected removing "%s" (dir) to failed, but it succeeded' % (self.sPath,));
+
+ return self.checkRemoved('directory');
+
+class tdTestRemoveTree(tdTestRemoveBase):
+ """
+ Recursively remove a directory tree.
+ """
+ def __init__(self, sPath, afFlags = None, fRcExpect = True, fNotExist = False, oCreds = None):
+ tdTestRemoveBase.__init__(self, sPath, fRcExpect, oCreds = None);
+ self.afFlags = afFlags if afFlags is not None else [];
+ self.fNotExist = fNotExist; # Hack for the ContentOnly scenario where the dir does not exist.
+
+ def execute(self, oSubTstDrv):
+ reporter.log2('Deleting tree "%s" ...' % (limitString(self.sPath),));
+ try:
+ oProgress = self.oGuestSession.directoryRemoveRecursive(self.sPath, self.afFlags);
+ except:
+ reporter.maybeErrXcpt(self.fRcExpect, 'Removing directory tree "%s" failed (afFlags=%s)'
+ % (self.sPath, self.afFlags));
+ return not self.fRcExpect;
+
+ oWrappedProgress = vboxwrappers.ProgressWrapper(oProgress, oSubTstDrv.oTstDrv.oVBoxMgr, oSubTstDrv.oTstDrv,
+ "remove-tree: %s" % (self.sPath,));
+ oWrappedProgress.wait();
+ if not oWrappedProgress.isSuccess():
+ oWrappedProgress.logResult(fIgnoreErrors = not self.fRcExpect);
+ return not self.fRcExpect;
+ if not self.fRcExpect:
+ return reporter.error('Expected removing "%s" (tree) to failed, but it succeeded' % (self.sPath,));
+
+ if vboxcon.DirectoryRemoveRecFlag_ContentAndDir not in self.afFlags and not self.fNotExist:
+ # Cannot use directoryExists here as it is buggy.
+ try:
+ if oSubTstDrv.oTstDrv.fpApiVer >= 5.0:
+ oFsObjInfo = self.oGuestSession.fsObjQueryInfo(self.sPath, False);
+ else:
+ oFsObjInfo = self.oGuestSession.fileQueryInfo(self.sPath);
+ eType = oFsObjInfo.type;
+ except:
+ return reporter.errorXcpt('sPath=%s' % (self.sPath,));
+ if eType != vboxcon.FsObjType_Directory:
+ return reporter.error('Found file type %d, expected directory (%d) for %s after rmtree/OnlyContent'
+ % (eType, vboxcon.FsObjType_Directory, self.sPath,));
+ return True;
+
+ return self.checkRemoved('tree');
+
+
+class tdTestFileStat(tdTestGuestCtrlBase):
+ """
+ Test querying guest file information.
+ """
+ def __init__(self, sFile = "", oCreds = None, cbSize = 0, eFileType = 0):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sFile = sFile;
+ self.cbSize = cbSize;
+ self.eFileType = eFileType;
+
+class tdTestFileIO(tdTestGuestCtrlBase):
+ """
+ Test for the IGuestFile object.
+ """
+ def __init__(self, sFile = "", oCreds = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sFile = sFile;
+
+class tdTestFileQuerySize(tdTestGuestCtrlBase):
+ """
+ Test for the file size query API call (fileQuerySize).
+ """
+ def __init__(self, sFile = "", oCreds = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sFile = sFile;
+
+class tdTestFileOpen(tdTestGuestCtrlBase):
+ """
+ Tests opening a guest files.
+ """
+ def __init__(self, sFile = "", eAccessMode = None, eAction = None, eSharing = None,
+ fCreationMode = 0o660, oCreds = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sFile = sFile;
+ self.eAccessMode = eAccessMode if eAccessMode is not None else vboxcon.FileAccessMode_ReadOnly;
+ self.eAction = eAction if eAction is not None else vboxcon.FileOpenAction_OpenExisting;
+ self.eSharing = eSharing if eSharing is not None else vboxcon.FileSharingMode_All;
+ self.fCreationMode = fCreationMode;
+ self.afOpenFlags = [];
+ self.oOpenedFile = None;
+
+ def toString(self):
+ """ Get a summary string. """
+ return 'eAccessMode=%s eAction=%s sFile=%s' % (self.eAccessMode, self.eAction, self.sFile);
+
+ def doOpenStep(self, fExpectSuccess):
+ """
+ Does the open step, putting the resulting file in oOpenedFile.
+ """
+ try:
+ self.oOpenedFile = self.oGuestSession.fileOpenEx(self.sFile, self.eAccessMode, self.eAction,
+ self.eSharing, self.fCreationMode, self.afOpenFlags);
+ except:
+ reporter.maybeErrXcpt(fExpectSuccess, 'fileOpenEx(%s, %s, %s, %s, %s, %s)'
+ % (self.sFile, self.eAccessMode, self.eAction, self.eSharing,
+ self.fCreationMode, self.afOpenFlags,));
+ return False;
+ return True;
+
+ def doStepsOnOpenedFile(self, fExpectSuccess, oSubTst):
+ """ Overridden by children to do more testing. """
+ _ = fExpectSuccess; _ = oSubTst;
+ return True;
+
+ def doCloseStep(self):
+ """ Closes the file. """
+ if self.oOpenedFile:
+ try:
+ self.oOpenedFile.close();
+ except:
+ return reporter.errorXcpt('close([%s, %s, %s, %s, %s, %s])'
+ % (self.sFile, self.eAccessMode, self.eAction, self.eSharing,
+ self.fCreationMode, self.afOpenFlags,));
+ self.oOpenedFile = None;
+ return True;
+
+ def doSteps(self, fExpectSuccess, oSubTst):
+ """ Do the tests. """
+ fRc = self.doOpenStep(fExpectSuccess);
+ if fRc is True:
+ fRc = self.doStepsOnOpenedFile(fExpectSuccess, oSubTst);
+ if self.oOpenedFile:
+ fRc = self.doCloseStep() and fRc;
+ return fRc;
+
+
+class tdTestFileOpenCheckSize(tdTestFileOpen):
+ """
+ Opens a file and checks the size.
+ """
+ def __init__(self, sFile = "", eAccessMode = None, eAction = None, eSharing = None,
+ fCreationMode = 0o660, cbOpenExpected = 0, oCreds = None):
+ tdTestFileOpen.__init__(self, sFile, eAccessMode, eAction, eSharing, fCreationMode, oCreds);
+ self.cbOpenExpected = cbOpenExpected;
+
+ def toString(self):
+ return 'cbOpenExpected=%s %s' % (self.cbOpenExpected, tdTestFileOpen.toString(self),);
+
+ def doStepsOnOpenedFile(self, fExpectSuccess, oSubTst):
+ #
+ # Call parent.
+ #
+ fRc = tdTestFileOpen.doStepsOnOpenedFile(self, fExpectSuccess, oSubTst);
+
+ #
+ # Check the size. Requires 6.0 or later (E_NOTIMPL in 5.2).
+ #
+ if oSubTst.oTstDrv.fpApiVer >= 6.0:
+ try:
+ oFsObjInfo = self.oOpenedFile.queryInfo();
+ except:
+ return reporter.errorXcpt('queryInfo([%s, %s, %s, %s, %s, %s])'
+ % (self.sFile, self.eAccessMode, self.eAction, self.eSharing,
+ self.fCreationMode, self.afOpenFlags,));
+ if oFsObjInfo is None:
+ return reporter.error('IGuestFile::queryInfo returned None');
+ try:
+ cbFile = oFsObjInfo.objectSize;
+ except:
+ return reporter.errorXcpt();
+ if cbFile != self.cbOpenExpected:
+ return reporter.error('Wrong file size after open (%d): %s, expected %s (file %s) (#1)'
+ % (self.eAction, cbFile, self.cbOpenExpected, self.sFile));
+
+ try:
+ cbFile = self.oOpenedFile.querySize();
+ except:
+ return reporter.errorXcpt('querySize([%s, %s, %s, %s, %s, %s])'
+ % (self.sFile, self.eAccessMode, self.eAction, self.eSharing,
+ self.fCreationMode, self.afOpenFlags,));
+ if cbFile != self.cbOpenExpected:
+ return reporter.error('Wrong file size after open (%d): %s, expected %s (file %s) (#2)'
+ % (self.eAction, cbFile, self.cbOpenExpected, self.sFile));
+
+ return fRc;
+
+
+class tdTestFileOpenAndWrite(tdTestFileOpen):
+ """
+ Opens the file and writes one or more chunks to it.
+
+ The chunks are a list of tuples(offset, bytes), where offset can be None
+ if no seeking should be performed.
+ """
+ def __init__(self, sFile = "", eAccessMode = None, eAction = None, eSharing = None, # pylint: disable=too-many-arguments
+ fCreationMode = 0o660, atChunks = None, fUseAtApi = False, abContent = None, oCreds = None):
+ tdTestFileOpen.__init__(self, sFile, eAccessMode if eAccessMode is not None else vboxcon.FileAccessMode_WriteOnly,
+ eAction, eSharing, fCreationMode, oCreds);
+ assert atChunks is not None;
+ self.atChunks = atChunks # type: list(tuple(int,bytearray))
+ self.fUseAtApi = fUseAtApi;
+ self.fAppend = ( eAccessMode in (vboxcon.FileAccessMode_AppendOnly, vboxcon.FileAccessMode_AppendRead)
+ or eAction == vboxcon.FileOpenAction_AppendOrCreate);
+ self.abContent = abContent # type: bytearray
+
+ def toString(self):
+ sChunks = ', '.join('%s LB %s' % (tChunk[0], len(tChunk[1]),) for tChunk in self.atChunks);
+ sApi = 'writeAt' if self.fUseAtApi else 'write';
+ return '%s [%s] %s' % (sApi, sChunks, tdTestFileOpen.toString(self),);
+
+ def doStepsOnOpenedFile(self, fExpectSuccess, oSubTst):
+ #
+ # Call parent.
+ #
+ fRc = tdTestFileOpen.doStepsOnOpenedFile(self, fExpectSuccess, oSubTst);
+
+ #
+ # Do the writing.
+ #
+ for offFile, abBuf in self.atChunks:
+ if self.fUseAtApi:
+ #
+ # writeAt:
+ #
+ assert offFile is not None;
+ reporter.log2('writeAt(%s, %s bytes)' % (offFile, len(abBuf),));
+ if self.fAppend:
+ if self.abContent is not None: # Try avoid seek as it updates the cached offset in GuestFileImpl.
+ offExpectAfter = len(self.abContent);
+ else:
+ try:
+ offSave = self.oOpenedFile.seek(0, vboxcon.FileSeekOrigin_Current);
+ offExpectAfter = self.oOpenedFile.seek(0, vboxcon.FileSeekOrigin_End);
+ self.oOpenedFile.seek(offSave, vboxcon.FileSeekOrigin_Begin);
+ except:
+ return reporter.errorXcpt();
+ offExpectAfter += len(abBuf);
+ else:
+ offExpectAfter = offFile + len(abBuf);
+
+ try:
+ cbWritten = self.oOpenedFile.writeAt(offFile, abBuf, 30*1000);
+ except:
+ return reporter.errorXcpt('writeAt(%s, %s bytes)' % (offFile, len(abBuf),));
+
+ else:
+ #
+ # write:
+ #
+ if self.fAppend:
+ if self.abContent is not None: # Try avoid seek as it updates the cached offset in GuestFileImpl.
+ offExpectAfter = len(self.abContent);
+ else:
+ try:
+ offSave = self.oOpenedFile.seek(0, vboxcon.FileSeekOrigin_Current);
+ offExpectAfter = self.oOpenedFile.seek(0, vboxcon.FileSeekOrigin_End);
+ self.oOpenedFile.seek(offSave, vboxcon.FileSeekOrigin_Begin);
+ except:
+ return reporter.errorXcpt('seek(0,End)');
+ if offFile is not None:
+ try:
+ self.oOpenedFile.seek(offFile, vboxcon.FileSeekOrigin_Begin);
+ except:
+ return reporter.errorXcpt('seek(%s,Begin)' % (offFile,));
+ else:
+ try:
+ offFile = self.oOpenedFile.seek(0, vboxcon.FileSeekOrigin_Current);
+ except:
+ return reporter.errorXcpt();
+ if not self.fAppend:
+ offExpectAfter = offFile;
+ offExpectAfter += len(abBuf);
+
+ reporter.log2('write(%s bytes @ %s)' % (len(abBuf), offFile,));
+ try:
+ cbWritten = self.oOpenedFile.write(abBuf, 30*1000);
+ except:
+ return reporter.errorXcpt('write(%s bytes @ %s)' % (len(abBuf), offFile));
+
+ #
+ # Check how much was written, ASSUMING nothing we push thru here is too big:
+ #
+ if cbWritten != len(abBuf):
+ fRc = reporter.errorXcpt('Wrote less than expected: %s out of %s, expected all to be written'
+ % (cbWritten, len(abBuf),));
+ if not self.fAppend:
+ offExpectAfter -= len(abBuf) - cbWritten;
+
+ #
+ # Update the file content tracker if we've got one and can:
+ #
+ if self.abContent is not None:
+ if cbWritten < len(abBuf):
+ abBuf = abBuf[:cbWritten];
+
+ #
+ # In append mode, the current file offset shall be disregarded and the
+ # write always goes to the end of the file, regardless of writeAt or write.
+ # Note that RTFileWriteAt only naturally behaves this way on linux and
+ # (probably) windows, so VBoxService makes that behaviour generic across
+ # all OSes.
+ #
+ if self.fAppend:
+ reporter.log2('len(self.abContent)=%s + %s' % (len(self.abContent), cbWritten, ));
+ self.abContent.extend(abBuf);
+ else:
+ if offFile is None:
+ offFile = offExpectAfter - cbWritten;
+ reporter.log2('len(self.abContent)=%s + %s @ %s' % (len(self.abContent), cbWritten, offFile, ));
+ if offFile > len(self.abContent):
+ self.abContent.extend(bytearray(offFile - len(self.abContent)));
+ self.abContent[offFile:offFile + cbWritten] = abBuf;
+ reporter.log2('len(self.abContent)=%s' % (len(self.abContent),));
+
+ #
+ # Check the resulting file offset with IGuestFile::offset.
+ #
+ try:
+ offApi = self.oOpenedFile.offset; # Must be gotten first!
+ offSeek = self.oOpenedFile.seek(0, vboxcon.FileSeekOrigin_Current);
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ reporter.log2('offApi=%s offSeek=%s offExpectAfter=%s' % (offApi, offSeek, offExpectAfter,));
+ if offSeek != offExpectAfter:
+ fRc = reporter.error('Seek offset is %s, expected %s after %s bytes write @ %s (offApi=%s)'
+ % (offSeek, offExpectAfter, len(abBuf), offFile, offApi,));
+ if offApi != offExpectAfter:
+ fRc = reporter.error('IGuestFile::offset is %s, expected %s after %s bytes write @ %s (offSeek=%s)'
+ % (offApi, offExpectAfter, len(abBuf), offFile, offSeek,));
+ # for each chunk - end
+ return fRc;
+
+
+class tdTestFileOpenAndCheckContent(tdTestFileOpen):
+ """
+ Opens the file and checks the content using the read API.
+ """
+ def __init__(self, sFile = "", eSharing = None, abContent = None, cbContentExpected = None, oCreds = None):
+ tdTestFileOpen.__init__(self, sFile = sFile, eSharing = eSharing, oCreds = oCreds);
+ self.abContent = abContent # type: bytearray
+ self.cbContentExpected = cbContentExpected;
+
+ def toString(self):
+ return 'check content %s (%s) %s' % (len(self.abContent), self.cbContentExpected, tdTestFileOpen.toString(self),);
+
+ def doStepsOnOpenedFile(self, fExpectSuccess, oSubTst):
+ #
+ # Call parent.
+ #
+ fRc = tdTestFileOpen.doStepsOnOpenedFile(self, fExpectSuccess, oSubTst);
+
+ #
+ # Check the expected content size.
+ #
+ if self.cbContentExpected is not None:
+ if len(self.abContent) != self.cbContentExpected:
+ fRc = reporter.error('Incorrect abContent size: %s, expected %s'
+ % (len(self.abContent), self.cbContentExpected,));
+
+ #
+ # Read the file and compare it with the content.
+ #
+ offFile = 0;
+ while True:
+ try:
+ abChunk = self.oOpenedFile.read(512*1024, 30*1000);
+ except:
+ return reporter.errorXcpt('read(512KB) @ %s' % (offFile,));
+ cbChunk = len(abChunk);
+ if cbChunk == 0:
+ if offFile != len(self.abContent):
+ fRc = reporter.error('Unexpected EOF @ %s, len(abContent)=%s' % (offFile, len(self.abContent),));
+ break;
+ if offFile + cbChunk > len(self.abContent):
+ fRc = reporter.error('File is larger than expected: at least %s bytes, expected %s bytes'
+ % (offFile + cbChunk, len(self.abContent),));
+ elif not utils.areBytesEqual(abChunk, self.abContent[offFile:(offFile + cbChunk)]):
+ fRc = reporter.error('Mismatch in range %s LB %s!' % (offFile, cbChunk,));
+ offFile += cbChunk;
+
+ return fRc;
+
+
+class tdTestSession(tdTestGuestCtrlBase):
+ """
+ Test the guest session handling.
+ """
+ def __init__(self, sUser = None, sPassword = None, sDomain = None, sSessionName = ""):
+ tdTestGuestCtrlBase.__init__(self, oCreds = tdCtxCreds(sUser, sPassword, sDomain));
+ self.sSessionName = sSessionName;
+
+ def getSessionCount(self, oVBoxMgr):
+ """
+ Helper for returning the number of currently
+ opened guest sessions of a VM.
+ """
+ if self.oGuest is None:
+ return 0;
+ try:
+ aoSession = oVBoxMgr.getArray(self.oGuest, 'sessions')
+ except:
+ reporter.errorXcpt('sSessionName: %s' % (self.sSessionName,));
+ return 0;
+ 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();
+ fRc = self.setEnvironment(oVmSession, oTxsSession, oTestVm);
+ if not fRc:
+ return False;
+ 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:
+ fRc = reporter.errorXcpt('%s: Unexpected exception executing test steps' % (sMsgPrefix,));
+
+ #
+ # Close the session.
+ #
+ fRc2 = self.closeSession();
+ if fRc2 is False:
+ fRc = reporter.error('%s: Session could not be closed' % (sMsgPrefix,));
+ else:
+ fRc = reporter.error('%s: Session creation failed' % (sMsgPrefix,));
+ 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('%s: skipping remaining %d steps' % (sMsgPrefix, 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 / %#d' % (sMsgPrefix, i,));
+ if fRc2 is not True:
+ fRc = False;
+ except:
+ fRc = reporter.errorXcpt('%s: Unexpected exception executing test #%d' % (sMsgPrefix, i ,));
+
+ 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.
+ """
+ _ = oTstDrv;
+ _ = oGstCtrlSession;
+ return reporter.error('%s: Missing execute implementation: %s' % (sMsgPrefix, self,));
+
+
+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;
+ return 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,));
+ except:
+ return reporter.errorXcpt('%s: Unexpected exception in tdStepSessionSetEnv::execute (%s=%s)'
+ % (sMsgPrefix, self.sVar, self.sValue,));
+
+ # Should we succeed?
+ if self.hrcExpected != 0:
+ return reporter.error('%s: Expected hrcExpected=%#x, got S_OK (putenv %s=%s)'
+ % (sMsgPrefix, self.hrcExpected, self.sVar, self.sValue,));
+ 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;
+ return 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,));
+ except:
+ return reporter.errorXcpt('%s: Unexpected exception in tdStepSessionUnsetEnv::execute (%s)'
+ % (sMsgPrefix, self.sVar,));
+
+ # Should we succeed?
+ if self.hrcExpected != 0:
+ return reporter.error('%s: Expected hrcExpected=%#x, got S_OK (unsetenv %s)'
+ % (sMsgPrefix, self.hrcExpected, self.sVar,));
+ 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;
+ return 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,));
+ except:
+ return reporter.errorXcpt('%s: Unexpected exception writing the environmentChanges property (asEnv=%s).'
+ % (sMsgPrefix, self.asEnv));
+ 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:
+ return reporter.errorXcpt('%s: Unexpected exception reading the environmentChanges property.' % (sMsgPrefix,));
+
+ #
+ # 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:
+ fRc = reporter.error('%s: Expected "%s" to be in the resulting environment' % (sMsgPrefix, sExpected,));
+ for sUnexpected in asCopy:
+ fRc = reporter.error('%s: Unexpected "%s" in the resulting environment' % (sMsgPrefix, sUnexpected,));
+
+ 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, oTestFsObj = 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;
+ self.oTestFsObj = oTestFsObj # type: testfileset.TestFsObj
+
+ def execute(self, oTstDrv, oGstCtrlSession, sMsgPrefix):
+ """
+ Execute the test step.
+ """
+ reporter.log2('tdStepStat: sPath=%s enmType=%s hrcExpected=%s fFound=%s fFollowLinks=%s'
+ % (limitString(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, oTestDir = None):
+ tdStepStat.__init__(self, sPath = sDirPath, enmType = vboxcon.FsObjType_Directory, oTestFsObj = oTestDir);
+
+class tdStepStatDirEx(tdStepStatDir):
+ """ Checks for an existing directory given a TestDir object. """
+ def __init__(self, oTestDir): # type: (testfileset.TestDir)
+ tdStepStatDir.__init__(self, oTestDir.sPath, oTestDir);
+
+class tdStepStatFile(tdStepStat):
+ """ Checks for an existing file """
+ def __init__(self, sFilePath = None, oTestFile = None):
+ tdStepStat.__init__(self, sPath = sFilePath, enmType = vboxcon.FsObjType_File, oTestFsObj = oTestFile);
+
+class tdStepStatFileEx(tdStepStatFile):
+ """ Checks for an existing file given a TestFile object. """
+ def __init__(self, oTestFile): # type: (testfileset.TestFile)
+ tdStepStatFile.__init__(self, oTestFile.sPath, oTestFile);
+
+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 = "", asArgs = None, afFlags = None, oCreds = None):
+ tdTestGuestCtrlBase.__init__(self, oCreds = oCreds);
+ self.sSrc = sSrc;
+ self.asArgs = asArgs;
+ self.afFlags = afFlags;
+
+class tdTestResult(object):
+ """
+ Base class for test results.
+ """
+ def __init__(self, fRc = False):
+ ## The overall test result.
+ self.fRc = fRc;
+
+class tdTestResultFailure(tdTestResult):
+ """
+ Base class for test results.
+ """
+ def __init__(self):
+ tdTestResult.__init__(self, fRc = False);
+
+class tdTestResultSuccess(tdTestResult):
+ """
+ Base class for test results.
+ """
+ def __init__(self):
+ tdTestResult.__init__(self, fRc = True);
+
+class tdTestResultDirRead(tdTestResult):
+ """
+ Test result for reading guest directories.
+ """
+ def __init__(self, fRc = False, cFiles = 0, cDirs = 0, cOthers = None):
+ tdTestResult.__init__(self, fRc = fRc);
+ self.cFiles = cFiles;
+ self.cDirs = cDirs;
+ self.cOthers = cOthers;
+
+class tdTestResultExec(tdTestResult):
+ """
+ Holds a guest process execution test result,
+ including the exit code, status + afFlags.
+ """
+ def __init__(self, fRc = False, uExitStatus = 500, iExitCode = 0, sBuf = None, cbBuf = 0, cbStdOut = None, cbStdErr = None):
+ 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, offFile = 0, abBuf = None):
+ tdTestResult.__init__(self, fRc = fRc);
+ self.cbProcessed = cbProcessed;
+ self.offFile = offFile;
+ self.abBuf = abBuf;
+
+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 tdDebugSettings(object):
+ """
+ Contains local test debug settings.
+ """
+ def __init__(self, sVBoxServiceExeHst = None):
+ self.sVBoxServiceExeHst = sVBoxServiceExeHst;
+ self.sGstVBoxServiceLogPath = '';
+
+class SubTstDrvAddGuestCtrl(base.SubTestDriverBase):
+ """
+ Sub-test driver for executing guest control (VBoxService, IGuest) tests.
+ """
+
+ def __init__(self, oTstDrv):
+ base.SubTestDriverBase.__init__(self, oTstDrv, 'add-guest-ctrl', 'Guest Control');
+
+ ## @todo base.TestBase.
+ self.asTestsDef = [
+ 'debug',
+ 'session_basic', 'session_env', 'session_file_ref', 'session_dir_ref', 'session_proc_ref', 'session_reboot',
+ 'exec_basic', 'exec_timeout',
+ 'dir_create', 'dir_create_temp', 'dir_read',
+ 'file_open', 'file_remove', 'file_stat', 'file_read', 'file_write',
+ 'copy_to', 'copy_from',
+ 'update_additions'
+ ];
+ self.asTests = self.asTestsDef;
+ self.fSkipKnownBugs = False;
+ self.oTestFiles = None # type: vboxtestfileset.TestFileSet
+ self.oDebug = tdDebugSettings();
+ self.sPathVBoxServiceExeGst = '';
+
+ def parseOption(self, asArgs, iArg): # pylint: disable=too-many-branches,too-many-statements
+ if asArgs[iArg] == '--add-guest-ctrl-tests':
+ iArg += 1;
+ iNext = self.oTstDrv.requireMoreArgs(1, asArgs, iArg);
+ if asArgs[iArg] == 'all': # Nice for debugging scripts.
+ self.asTests = self.asTestsDef;
+ else:
+ 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;
+ if asArgs[iArg] == '--add-guest-ctrl-skip-known-bugs':
+ self.fSkipKnownBugs = True;
+ return iArg + 1;
+ if asArgs[iArg] == '--no-add-guest-ctrl-skip-known-bugs':
+ self.fSkipKnownBugs = False;
+ return iArg + 1;
+ if asArgs[iArg] == '--add-guest-ctrl-debug-img':
+ iArg += 1;
+ iNext = self.oTstDrv.requireMoreArgs(1, asArgs, iArg);
+ self.oDebug.sVBoxServiceExeHst = asArgs[iArg];
+ 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)));
+ reporter.log(' --add-guest-ctrl-skip-known-bugs');
+ reporter.log(' Skips known bugs. Default: --no-add-guest-ctrl-skip-known-bugs');
+ reporter.log('Debugging:');
+ reporter.log(' --add-guest-ctrl-debug-img');
+ reporter.log(' Sets VBoxService image to deploy for debugging');
+ return True;
+
+ def testIt(self, oTestVm, oSession, oTxsSession):
+ """
+ Executes the test.
+
+ Returns fRc, oTxsSession. The latter may have changed.
+ """
+
+ self.sPathVBoxServiceExeGst = oTestVm.pathJoin(self.oTstDrv.getGuestSystemAdminDir(oTestVm), 'VBoxService') \
+ + base.exeSuff();
+
+ reporter.log("Active tests: %s" % (self.asTests,));
+
+ # The tests. Must-succeed tests should be first.
+ atTests = [
+ ( True, self.prepareGuestForDebugging, None, 'Manual Debugging',),
+ ( True, self.prepareGuestForTesting, None, 'Preparations',),
+ ( True, self.testGuestCtrlSession, 'session_basic', 'Session Basics',),
+ ( True, self.testGuestCtrlExec, 'exec_basic', 'Execution',),
+ ( False, self.testGuestCtrlExecTimeout, 'exec_timeout', 'Execution Timeouts',),
+ ( False, self.testGuestCtrlSessionEnvironment, 'session_env', 'Session Environment',),
+ ( False, self.testGuestCtrlSessionFileRefs, 'session_file_ref', 'Session File References',),
+ #( False, self.testGuestCtrlSessionDirRefs, 'session_dir_ref', 'Session Directory References',),
+ ( False, self.testGuestCtrlSessionProcRefs, 'session_proc_ref', 'Session Process References',),
+ ( False, self.testGuestCtrlDirCreate, 'dir_create', 'Creating directories',),
+ ( False, self.testGuestCtrlDirCreateTemp, 'dir_create_temp', 'Creating temporary directories',),
+ ( False, self.testGuestCtrlDirRead, 'dir_read', 'Reading directories',),
+ ( False, self.testGuestCtrlCopyTo, 'copy_to', 'Copy to guest',),
+ ( False, self.testGuestCtrlCopyFrom, 'copy_from', 'Copy from guest',),
+ ( False, self.testGuestCtrlFileStat, 'file_stat', 'Querying file information (stat)',),
+ ( False, self.testGuestCtrlFileOpen, 'file_open', 'File open',),
+ ( False, self.testGuestCtrlFileRead, 'file_read', 'File read',),
+ ( False, self.testGuestCtrlFileWrite, 'file_write', 'File write',),
+ ( False, self.testGuestCtrlFileRemove, 'file_remove', 'Removing files',), # Destroys prepped files.
+ ( False, self.testGuestCtrlUpdateAdditions, 'update_additions', 'Updating Guest Additions',),
+ ];
+
+ if not self.fSkipKnownBugs:
+ atTests.extend([
+ ## @todo Seems to (mainly?) fail on Linux guests, primarily running with systemd as service supervisor.
+ # Needs to be investigated and fixed.
+ ( False, self.testGuestCtrlSessionReboot, 'session_reboot', 'Session w/ Guest Reboot',), # May zap /tmp.
+ ]);
+
+ fRc = True;
+ for fMustSucceed, fnHandler, sShortNm, sTestNm in atTests:
+
+ # If for whatever reason the VM object became invalid, bail out.
+ if not oTestVm:
+ reporter.error('Test VM object invalid (VBoxSVC or client process crashed?), aborting tests');
+ fRc = False;
+ break;
+
+ reporter.testStart(sTestNm);
+ if sShortNm is None or sShortNm in self.asTests:
+ # Returns (fRc, oTxsSession, oSession) - but only the first one is mandatory.
+ aoResult = fnHandler(oSession, oTxsSession, oTestVm);
+ if aoResult is None or isinstance(aoResult, bool):
+ fRcTest = aoResult;
+ else:
+ fRcTest = aoResult[0];
+ if len(aoResult) > 1:
+ oTxsSession = aoResult[1];
+ if len(aoResult) > 2:
+ oSession = aoResult[2];
+ assert len(aoResult) == 3;
+ else:
+ fRcTest = None;
+
+ if fRcTest is False and reporter.testErrorCount() == 0:
+ fRcTest = reporter.error('Buggy test! Returned False w/o logging the error!');
+ if reporter.testDone(fRcTest is None)[1] != 0:
+ fRcTest = False;
+ fRc = False;
+
+ # Stop execution if this is a must-succeed test and it failed.
+ if fRcTest is False and fMustSucceed is True:
+ reporter.log('Skipping any remaining tests since the previous one failed.');
+ break;
+
+ # Upload VBoxService logs on failure.
+ if reporter.testErrorCount() > 0 \
+ and self.oDebug.sGstVBoxServiceLogPath:
+ sVBoxServiceLogsTarGz = 'ga-vboxservice-logs-%s.tar.gz' % oTestVm.sVmName;
+ sGstVBoxServiceLogsTarGz = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), sVBoxServiceLogsTarGz);
+ if self.oTstDrv.txsPackFile(oSession, oTxsSession, \
+ sGstVBoxServiceLogsTarGz, self.oDebug.sGstVBoxServiceLogPath, fIgnoreErrors = True):
+ self.oTstDrv.txsDownloadFiles(oSession, oTxsSession, [ (sGstVBoxServiceLogsTarGz, sVBoxServiceLogsTarGz) ], \
+ fIgnoreErrors = True);
+
+ return (fRc, oTxsSession);
+
+ def prepareGuestForDebugging(self, oSession, oTxsSession, oTestVm): # pylint: disable=unused-argument
+ """
+ Prepares a guest for (manual) debugging.
+
+ This involves copying over and invoking a the locally built VBoxService binary.
+ """
+
+ if self.oDebug.sVBoxServiceExeHst is None: # If no debugging enabled, bail out.
+ reporter.log('Skipping debugging');
+ return True;
+
+ reporter.log('Preparing for debugging ...');
+
+ try:
+ self.vboxServiceControl(oTxsSession, oTestVm, fStart = False);
+
+ self.oTstDrv.sleep(5); # Fudge factor -- wait until the service stopped.
+
+ reporter.log('Uploading "%s" to "%s" ...' % (self.oDebug.sVBoxServiceExeHst, self.sPathVBoxServiceExeGst));
+ oTxsSession.syncUploadFile(self.oDebug.sVBoxServiceExeHst, self.sPathVBoxServiceExeGst);
+
+ if oTestVm.isLinux():
+ oTxsSession.syncChMod(self.sPathVBoxServiceExeGst, 0o755);
+
+ self.vboxServiceControl(oTxsSession, oTestVm, fStart = True);
+
+ self.oTstDrv.sleep(5); # Fudge factor -- wait until the service is ready.
+
+ except:
+ return reporter.errorXcpt('Unable to prepare for debugging');
+
+ return True;
+
+ #
+ # VBoxService handling.
+ #
+ def vboxServiceControl(self, oTxsSession, oTestVm, fStart):
+ """
+ Controls VBoxService on the guest by starting or stopping the service.
+ Returns success indicator.
+ """
+
+ fRc = True;
+
+ if oTestVm.isWindows():
+ sPathSC = os.path.join(self.oTstDrv.getGuestSystemDir(oTestVm), 'sc.exe');
+ if fStart is True:
+ fRc = self.oTstDrv.txsRunTest(oTxsSession, 'Starting VBoxService', 30 * 1000, \
+ sPathSC, (sPathSC, 'start', 'VBoxService'));
+ else:
+ fRc = self.oTstDrv.txsRunTest(oTxsSession, 'Stopping VBoxService', 30 * 1000, \
+ sPathSC, (sPathSC, 'stop', 'VBoxService'));
+ elif oTestVm.isLinux():
+ sPathService = "/sbin/rcvboxadd-service";
+ if fStart is True:
+ fRc = self.oTstDrv.txsRunTest(oTxsSession, 'Starting VBoxService', 30 * 1000, \
+ sPathService, (sPathService, 'start'));
+ else:
+ fRc = self.oTstDrv.txsRunTest(oTxsSession, 'Stopping VBoxService', 30 * 1000, \
+ sPathService, (sPathService, 'stop'));
+ else:
+ reporter.log('Controlling VBoxService not supported for this guest yet');
+
+ return fRc;
+
+ def waitForGuestFacility(self, oSession, eFacilityType, sDesc,
+ eFacilityStatus, cMsTimeout = 30 * 1000):
+ """
+ Waits for a guest facility to enter a certain status.
+ By default the "Active" status is being used.
+
+ Returns success status.
+ """
+
+ reporter.log('Waiting for Guest Additions facility "%s" to change to status %s (%dms timeout)...'
+ % (sDesc, str(eFacilityStatus), cMsTimeout));
+
+ fRc = False;
+
+ eStatusOld = None;
+ tsStart = base.timestampMilli();
+ while base.timestampMilli() - tsStart < cMsTimeout:
+ try:
+ eStatus, _ = oSession.o.console.guest.getFacilityStatus(eFacilityType);
+ reporter.log('Current status is %s' % (str(eStatus)));
+ if eStatusOld is None:
+ eStatusOld = eStatus;
+ except:
+ reporter.errorXcpt('Getting facility status failed');
+ break;
+ if eStatus != eStatusOld:
+ reporter.log('Status changed to %s' % (str(eStatus)));
+ eStatusOld = eStatus;
+ if eStatus == eFacilityStatus:
+ fRc = True;
+ break;
+ self.oTstDrv.sleep(5); # Do some busy waiting.
+
+ if not fRc:
+ reporter.error('Waiting for Guest Additions facility "%s" timed out' % (sDesc));
+ else:
+ reporter.log('Guest Additions facility "%s" reached requested status %s after %dms'
+ % (sDesc, str(eFacilityStatus), base.timestampMilli() - tsStart));
+
+ return fRc;
+
+ #
+ # Guest test files.
+ #
+
+ def prepareGuestForTesting(self, oSession, oTxsSession, oTestVm):
+ """
+ Prepares the VM for testing, uploading a bunch of files and stuff via TXS.
+ Returns success indicator.
+ """
+ _ = oSession;
+
+ #
+ # Make sure the temporary directory exists.
+ #
+ for sDir in [self.oTstDrv.getGuestTempDir(oTestVm), ]:
+ if oTxsSession.syncMkDirPath(sDir, 0o777) is not True:
+ return reporter.error('Failed to create directory "%s"!' % (sDir,));
+
+ # Query the TestExecService (TXS) version first to find out on what we run.
+ fGotTxsVer = self.oTstDrv.txsVer(oSession, oTxsSession, 30 * 100, fIgnoreErrors = True);
+
+ # Whether to enable verbose logging for VBoxService.
+ fEnableVerboseLogging = False;
+
+ # On Windows guests we always can enable verbose logging.
+ if oTestVm.isWindows():
+ fEnableVerboseLogging = True;
+
+ # Old TxS versions had a bug which caused an infinite loop when executing stuff containing "$xxx",
+ # so check if we got the version here first and skip enabling verbose logging nonetheless if needed.
+ if not fGotTxsVer:
+ reporter.log('Too old TxS service running')
+ fEnableVerboseLogging = False;
+
+ #
+ # Enable VBoxService verbose logging.
+ #
+ reporter.log('Enabling verbose VBoxService logging: %s' % (fEnableVerboseLogging));
+ if fEnableVerboseLogging:
+ self.oDebug.sGstVBoxServiceLogPath = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), "VBoxService");
+ if oTxsSession.syncMkDirPath(self.oDebug.sGstVBoxServiceLogPath, 0o777) is not True:
+ return reporter.error('Failed to create directory "%s"!' % (self.oDebug.sGstVBoxServiceLogPath,));
+ sPathLogFile = oTestVm.pathJoin(self.oDebug.sGstVBoxServiceLogPath, 'VBoxService.log');
+
+ reporter.log('VBoxService logs will be stored in "%s"' % (self.oDebug.sGstVBoxServiceLogPath,));
+
+ fRestartVBoxService = False;
+ if oTestVm.isWindows():
+ sPathRegExe = oTestVm.pathJoin(self.oTstDrv.getGuestSystemDir(oTestVm), 'reg.exe');
+ sImagePath = '%s -vvvv --logfile %s' % (self.sPathVBoxServiceExeGst, sPathLogFile);
+ fRestartVBoxService = self.oTstDrv.txsRunTest(oTxsSession, 'Enabling VBoxService verbose logging (via registry)',
+ 30 * 1000,
+ sPathRegExe,
+ (sPathRegExe, 'add',
+ 'HKLM\\SYSTEM\\CurrentControlSet\\Services\\VBoxService',
+ '/v', 'ImagePath', '/t', 'REG_SZ', '/d', sImagePath, '/f'));
+ elif oTestVm.isLinux():
+ sPathSed = oTestVm.pathJoin(self.oTstDrv.getGuestSystemDir(oTestVm), 'sed');
+ fRestartVBoxService = self.oTstDrv.txsRunTest(oTxsSession, 'Enabling VBoxService verbose logging', 30 * 1000,
+ sPathSed,
+ (sPathSed, '-i', '-e', 's/'
+ '\\$2 \\$3'
+ '/'
+ '\\$2 \\$3 -vvvv --logfile \\/var\\/tmp\\/VBoxService\\/VBoxService.log'
+ '/g',
+ '/sbin/rcvboxadd-service'));
+ else:
+ reporter.log('Verbose logging for VBoxService not supported for this guest yet');
+
+ if fRestartVBoxService:
+ self.vboxServiceControl(oTxsSession, oTestVm, fStart = False);
+ self.oTstDrv.sleep(5);
+ self.vboxServiceControl(oTxsSession, oTestVm, fStart = True);
+ else:
+ reporter.testStart('Waiting for VBoxService to get started');
+ fRc = self.waitForGuestFacility(oSession, vboxcon.AdditionsFacilityType_VBoxService, "VBoxService",
+ vboxcon.AdditionsFacilityStatus_Active);
+ reporter.testDone();
+ if not fRc:
+ return False;
+
+ #
+ # Generate and upload some random files and dirs to the guest.
+ # Note! Make sure we don't run into too-long-path issues when using
+ # the test files on the host if.
+ #
+ cchGst = len(self.oTstDrv.getGuestTempDir(oTestVm)) + 1 + len('addgst-1') + 1;
+ cchHst = len(self.oTstDrv.sScratchPath) + 1 + len('copyto/addgst-1') + 1;
+ cchMaxPath = 230;
+ if cchHst > cchGst:
+ cchMaxPath -= cchHst - cchGst;
+ reporter.log('cchMaxPath=%s (cchHst=%s, cchGst=%s)' % (cchMaxPath, cchHst, cchGst,));
+ self.oTestFiles = vboxtestfileset.TestFileSet(oTestVm,
+ self.oTstDrv.getGuestTempDir(oTestVm), 'addgst-1',
+ # Make sure that we use a lowest common denominator across all supported
+ # platforms, to make testing the randomly generated file paths work
+ # reliably.
+ cchMaxPath = cchMaxPath, asCompatibleWith = [ ('cross') ]);
+ return self.oTestFiles.upload(oTxsSession, self.oTstDrv);
+
+
+ #
+ # gctrlXxxx stuff.
+ #
+
+ def gctrlCopyFileFrom(self, oGuestSession, oTest, fExpected):
+ """
+ Helper function to copy a single file from the guest to the host.
+ """
+
+ # As we pass-in randomly generated file names, the source sometimes can be empty, which
+ # in turn will result in a (correct) error by the API. Simply skip this function then.
+ if not oTest.sSrc:
+ reporter.log2('Skipping guest file "%s"' % (limitString(oTest.sSrc)));
+ return fExpected;
+
+ #
+ # Do the copying.
+ #
+ reporter.log2('Copying guest file "%s" to host "%s"' % (limitString(oTest.sSrc), limitString(oTest.sDst)));
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ oCurProgress = oGuestSession.fileCopyFromGuest(oTest.sSrc, oTest.sDst, oTest.afFlags);
+ else:
+ oCurProgress = oGuestSession.copyFrom(oTest.sSrc, oTest.sDst, oTest.afFlags);
+ except:
+ reporter.maybeErrXcpt(fExpected, 'Copy from exception for sSrc="%s", sDst="%s":' % (oTest.sSrc, oTest.sDst,));
+ return False;
+ if oCurProgress is None:
+ return reporter.error('No progress object returned');
+ oProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, "gctrlFileCopyFrom");
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = not fExpected);
+ return False;
+
+ #
+ # Check the result if we can.
+ #
+ if oTest.oSrc:
+ assert isinstance(oTest.oSrc, testfileset.TestFile);
+ sDst = oTest.sDst;
+ if os.path.isdir(sDst):
+ sDst = os.path.join(sDst, oTest.oSrc.sName);
+ try:
+ oFile = open(sDst, 'rb'); # pylint: disable=consider-using-with
+ except:
+ # Don't report expected non-existing paths / files as an error.
+ return reporter.maybeErrXcpt(fExpected, 'open(%s) failed during verfication (file / path not found)' % (sDst,));
+ fEqual = oTest.oSrc.equalFile(oFile);
+ oFile.close();
+ if not fEqual:
+ return reporter.error('Content differs for "%s"' % (sDst,));
+
+ return True;
+
+ def __compareTestDir(self, oDir, sHostPath): # type: (testfileset.TestDir, str) -> bool
+ """
+ Recursively compare the content of oDir and sHostPath.
+
+ Returns True on success, False + error logging on failure.
+
+ Note! This ASSUMES that nothing else was copied to sHostPath!
+ """
+ #
+ # First check out all the entries and files in the directory.
+ #
+ dLeftUpper = dict(oDir.dChildrenUpper);
+ try:
+ asEntries = os.listdir(sHostPath);
+ except:
+ return reporter.errorXcpt('os.listdir(%s) failed' % (sHostPath,));
+
+ fRc = True;
+ for sEntry in asEntries:
+ sEntryUpper = sEntry.upper();
+ if sEntryUpper not in dLeftUpper:
+ fRc = reporter.error('Unexpected entry "%s" in "%s"' % (sEntry, sHostPath,));
+ else:
+ oFsObj = dLeftUpper[sEntryUpper];
+ del dLeftUpper[sEntryUpper];
+
+ if isinstance(oFsObj, testfileset.TestFile):
+ sFilePath = os.path.join(sHostPath, oFsObj.sName);
+ try:
+ oFile = open(sFilePath, 'rb'); # pylint: disable=consider-using-with
+ except:
+ fRc = reporter.errorXcpt('open(%s) failed during verfication' % (sFilePath,));
+ else:
+ fEqual = oFsObj.equalFile(oFile);
+ oFile.close();
+ if not fEqual:
+ fRc = reporter.error('Content differs for "%s"' % (sFilePath,));
+
+ # List missing entries:
+ for sKey in dLeftUpper:
+ oEntry = dLeftUpper[sKey];
+ fRc = reporter.error('%s: Missing %s "%s" (src path: %s)'
+ % (sHostPath, oEntry.sName,
+ 'file' if isinstance(oEntry, testfileset.TestFile) else 'directory', oEntry.sPath));
+
+ #
+ # Recurse into subdirectories.
+ #
+ for oFsObj in oDir.aoChildren:
+ if isinstance(oFsObj, testfileset.TestDir):
+ fRc = self.__compareTestDir(oFsObj, os.path.join(sHostPath, oFsObj.sName)) and fRc;
+ return fRc;
+
+ def gctrlCopyDirFrom(self, oGuestSession, oTest, fExpected):
+ """
+ Helper function to copy a directory from the guest to the host.
+ """
+
+ # As we pass-in randomly generated directories, the source sometimes can be empty, which
+ # in turn will result in a (correct) error by the API. Simply skip this function then.
+ if not oTest.sSrc:
+ reporter.log2('Skipping guest dir "%s"' % (limitString(oTest.sSrc)));
+ return fExpected;
+
+ #
+ # Do the copying.
+ #
+ reporter.log2('Copying guest dir "%s" to host "%s"' % (limitString(oTest.sSrc), limitString(oTest.sDst)));
+ try:
+ if self.oTstDrv.fpApiVer >= 7.0:
+ ## @todo Make the following new flags implicit for 7.0 for now. Develop dedicated tests for this later and remove.
+ if not oTest.afFlags:
+ oTest.afFlags = [ vboxcon.DirectoryCopyFlag_Recursive, ];
+ elif vboxcon.DirectoryCopyFlag_Recursive not in oTest.afFlags:
+ oTest.afFlags.append(vboxcon.DirectoryCopyFlag_Recursive);
+ ## @todo Ditto.
+ if not oTest.afFlags:
+ oTest.afFlags = [ vboxcon.DirectoryCopyFlag_FollowLinks, ];
+ elif vboxcon.DirectoryCopyFlag_FollowLinks not in oTest.afFlags:
+ oTest.afFlags.append(vboxcon.DirectoryCopyFlag_FollowLinks);
+ oCurProgress = oGuestSession.directoryCopyFromGuest(oTest.sSrc, oTest.sDst, oTest.afFlags);
+ except:
+ reporter.maybeErrXcpt(fExpected, 'Copy dir from exception for sSrc="%s", sDst="%s":' % (oTest.sSrc, oTest.sDst,));
+ return False;
+ if oCurProgress is None:
+ return reporter.error('No progress object returned');
+
+ oProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, "gctrlDirCopyFrom");
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = not fExpected);
+ return False;
+
+ #
+ # Check the result if we can.
+ #
+ if oTest.oSrc:
+ assert isinstance(oTest.oSrc, testfileset.TestDir);
+ sDst = oTest.sDst;
+ if oTest.fIntoDst:
+ return self.__compareTestDir(oTest.oSrc, os.path.join(sDst, oTest.oSrc.sName));
+ oDummy = testfileset.TestDir(None, 'dummy');
+ oDummy.aoChildren = [oTest.oSrc,]
+ oDummy.dChildrenUpper = { oTest.oSrc.sName.upper(): oTest.oSrc, };
+ return self.__compareTestDir(oDummy, sDst);
+ return True;
+
+ def gctrlCopyFileTo(self, oGuestSession, sSrc, sDst, afFlags, fIsError):
+ """
+ Helper function to copy a single file from the host to the guest.
+
+ afFlags is either None or an array of vboxcon.DirectoryCopyFlag_Xxxx values.
+ """
+ reporter.log2('Copying host file "%s" to guest "%s" (flags %s)' % (limitString(sSrc), limitString(sDst), afFlags));
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ oCurProgress = oGuestSession.fileCopyToGuest(sSrc, sDst, afFlags);
+ else:
+ oCurProgress = oGuestSession.copyTo(sSrc, sDst, afFlags);
+ except:
+ reporter.maybeErrXcpt(fIsError, 'sSrc=%s sDst=%s' % (sSrc, sDst,));
+ return False;
+
+ if oCurProgress is None:
+ return reporter.error('No progress object returned');
+ oProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, "gctrlCopyFileTo");
+
+ try:
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = not fIsError);
+ return False;
+ except:
+ reporter.maybeErrXcpt(fIsError, 'Wait exception for sSrc="%s", sDst="%s":' % (sSrc, sDst));
+ return False;
+ return True;
+
+ def gctrlCopyDirTo(self, oGuestSession, sSrc, sDst, afFlags, fIsError):
+ """
+ Helper function to copy a directory (tree) from the host to the guest.
+
+ afFlags is either None or an array of vboxcon.DirectoryCopyFlag_Xxxx values.
+ """
+ reporter.log2('Copying host directory "%s" to guest "%s" (flags %s)' % (limitString(sSrc), limitString(sDst), afFlags));
+ try:
+ if self.oTstDrv.fpApiVer >= 7.0:
+ ## @todo Make the following new flags implicit for 7.0 for now. Develop dedicated tests for this later and remove.
+ if not afFlags:
+ afFlags = [ vboxcon.DirectoryCopyFlag_Recursive, ];
+ elif vboxcon.DirectoryCopyFlag_Recursive not in afFlags:
+ afFlags.append(vboxcon.DirectoryCopyFlag_Recursive);
+ ## @todo Ditto.
+ if not afFlags:
+ afFlags = [vboxcon.DirectoryCopyFlag_FollowLinks,];
+ elif vboxcon.DirectoryCopyFlag_FollowLinks not in afFlags:
+ afFlags.append(vboxcon.DirectoryCopyFlag_FollowLinks);
+ oCurProgress = oGuestSession.directoryCopyToGuest(sSrc, sDst, afFlags);
+ except:
+ reporter.maybeErrXcpt(fIsError, 'sSrc=%s sDst=%s' % (sSrc, sDst,));
+ return False;
+
+ if oCurProgress is None:
+ return reporter.error('No progress object returned');
+ oProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv, "gctrlCopyFileTo");
+
+ try:
+ oProgress.wait();
+ if not oProgress.isSuccess():
+ oProgress.logResult(fIgnoreErrors = not fIsError);
+ return False;
+ except:
+ reporter.maybeErrXcpt(fIsError, 'Wait exception for sSrc="%s", sDst="%s":' % (sSrc, sDst));
+ return False;
+ return True;
+
+ def gctrlCreateDir(self, oTest, oRes, oGuestSession):
+ """
+ Helper function to create a guest directory specified in the current test.
+ """
+ reporter.log2('Creating directory "%s"' % (limitString(oTest.sDirectory),));
+ try:
+ oGuestSession.directoryCreate(oTest.sDirectory, oTest.fMode, oTest.afFlags);
+ except:
+ reporter.maybeErrXcpt(oRes.fRc, 'Failed to create "%s" fMode=%o afFlags=%s'
+ % (oTest.sDirectory, oTest.fMode, oTest.afFlags,));
+ return not oRes.fRc;
+ if oRes.fRc is not True:
+ return reporter.error('Did not expect to create directory "%s"!' % (oTest.sDirectory,));
+
+ # Check if the directory now exists.
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ fDirExists = oGuestSession.directoryExists(oTest.sDirectory, False);
+ else:
+ fDirExists = oGuestSession.directoryExists(oTest.sDirectory);
+ except:
+ return reporter.errorXcpt('directoryExists failed on "%s"!' % (oTest.sDirectory,));
+ if not fDirExists:
+ return reporter.errorXcpt('directoryExists returned False on "%s" after directoryCreate succeeded!'
+ % (oTest.sDirectory,));
+ return True;
+
+ def gctrlReadDirTree(self, oTest, oGuestSession, fIsError, sSubDir = None):
+ """
+ Helper function to recursively read a guest directory tree specified in the current test.
+ """
+ sDir = oTest.sDirectory;
+ sFilter = oTest.sFilter;
+ afFlags = oTest.afFlags;
+ oTestVm = oTest.oCreds.oTestVm;
+ sCurDir = oTestVm.pathJoin(sDir, sSubDir) if sSubDir else sDir;
+
+ fRc = True; # Be optimistic.
+ cDirs = 0; # Number of directories read.
+ cFiles = 0; # Number of files read.
+ cOthers = 0; # Other files.
+
+ # Open the directory:
+ reporter.log2('Directory="%s", filter="%s", afFlags="%s"' % (limitString(sCurDir), sFilter, afFlags));
+ try:
+ oCurDir = oGuestSession.directoryOpen(sCurDir, sFilter, afFlags);
+ except:
+ reporter.maybeErrXcpt(fIsError, 'sCurDir=%s sFilter=%s afFlags=%s' % (sCurDir, sFilter, afFlags,))
+ return (False, 0, 0, 0);
+
+ # Read the directory.
+ while fRc is True:
+ try:
+ oFsObjInfo = oCurDir.read();
+ except Exception as oXcpt:
+ if vbox.ComError.notEqual(oXcpt, vbox.ComError.VBOX_E_OBJECT_NOT_FOUND):
+ if self.oTstDrv.fpApiVer > 5.2:
+ reporter.errorXcpt('Error reading directory "%s":' % (sCurDir,));
+ else:
+ # Unlike fileOpen, directoryOpen will not fail if the directory does not exist.
+ reporter.maybeErrXcpt(fIsError, 'Error reading directory "%s":' % (sCurDir,));
+ fRc = False;
+ else:
+ reporter.log2('\tNo more directory entries for "%s"' % (limitString(sCurDir),));
+ break;
+
+ try:
+ sName = oFsObjInfo.name;
+ eType = oFsObjInfo.type;
+ except:
+ fRc = reporter.errorXcpt();
+ break;
+
+ if sName in ('.', '..', ):
+ if eType != vboxcon.FsObjType_Directory:
+ fRc = reporter.error('Wrong type for "%s": %d, expected %d (Directory)'
+ % (sName, eType, vboxcon.FsObjType_Directory));
+ elif eType == vboxcon.FsObjType_Directory:
+ reporter.log2(' Directory "%s"' % limitString(oFsObjInfo.name));
+ aSubResult = self.gctrlReadDirTree(oTest, oGuestSession, fIsError,
+ oTestVm.pathJoin(sSubDir, sName) if sSubDir else sName);
+ fRc = aSubResult[0];
+ cDirs += aSubResult[1] + 1;
+ cFiles += aSubResult[2];
+ cOthers += aSubResult[3];
+ elif eType is vboxcon.FsObjType_File:
+ reporter.log4(' File "%s"' % oFsObjInfo.name);
+ cFiles += 1;
+ elif eType is vboxcon.FsObjType_Symlink:
+ reporter.log4(' Symlink "%s" -- not tested yet' % oFsObjInfo.name);
+ cOthers += 1;
+ elif oTestVm.isWindows() \
+ or oTestVm.isOS2() \
+ or eType not in (vboxcon.FsObjType_Fifo, vboxcon.FsObjType_DevChar, vboxcon.FsObjType_DevBlock,
+ vboxcon.FsObjType_Socket, vboxcon.FsObjType_WhiteOut):
+ fRc = reporter.error('Directory "%s" contains invalid directory entry "%s" (type %d)' %
+ (sCurDir, oFsObjInfo.name, oFsObjInfo.type,));
+ else:
+ cOthers += 1;
+
+ # Close the directory
+ try:
+ oCurDir.close();
+ except:
+ fRc = reporter.errorXcpt('sCurDir=%s' % (sCurDir));
+
+ return (fRc, cDirs, cFiles, cOthers);
+
+ def gctrlReadDirTree2(self, oGuestSession, oDir): # type: (testfileset.TestDir) -> bool
+ """
+ Helper function to recursively read a guest directory tree specified in the current test.
+ """
+
+ #
+ # Process the directory.
+ #
+
+ # Open the directory:
+ try:
+ oCurDir = oGuestSession.directoryOpen(oDir.sPath, '', None);
+ except:
+ return reporter.errorXcpt('sPath=%s' % (oDir.sPath,));
+
+ # Read the directory.
+ dLeftUpper = dict(oDir.dChildrenUpper);
+ cDot = 0;
+ cDotDot = 0;
+ fRc = True;
+ while True:
+ try:
+ oFsObjInfo = oCurDir.read();
+ except Exception as oXcpt:
+ if vbox.ComError.notEqual(oXcpt, vbox.ComError.VBOX_E_OBJECT_NOT_FOUND):
+ fRc = reporter.errorXcpt('Error reading directory "%s":' % (oDir.sPath,));
+ break;
+
+ try:
+ sName = oFsObjInfo.name;
+ eType = oFsObjInfo.type;
+ cbFile = oFsObjInfo.objectSize;
+ ## @todo check further attributes.
+ except:
+ fRc = reporter.errorXcpt();
+ break;
+
+ # '.' and '..' entries are not present in oDir.aoChildren, so special treatment:
+ if sName in ('.', '..', ):
+ if eType != vboxcon.FsObjType_Directory:
+ fRc = reporter.error('Wrong type for "%s": %d, expected %d (Directory)'
+ % (sName, eType, vboxcon.FsObjType_Directory));
+ if sName == '.': cDot += 1;
+ else: cDotDot += 1;
+ else:
+ # Find the child and remove it from the dictionary.
+ sNameUpper = sName.upper();
+ oFsObj = dLeftUpper.get(sNameUpper);
+ if oFsObj is None:
+ fRc = reporter.error('Unknown object "%s" found in "%s" (type %s, size %s)!'
+ % (sName, oDir.sPath, eType, cbFile,));
+ else:
+ del dLeftUpper[sNameUpper];
+
+ # Check type
+ if isinstance(oFsObj, testfileset.TestDir):
+ if eType != vboxcon.FsObjType_Directory:
+ fRc = reporter.error('%s: expected directory (%d), got eType=%d!'
+ % (oFsObj.sPath, vboxcon.FsObjType_Directory, eType,));
+ elif isinstance(oFsObj, testfileset.TestFile):
+ if eType != vboxcon.FsObjType_File:
+ fRc = reporter.error('%s: expected file (%d), got eType=%d!'
+ % (oFsObj.sPath, vboxcon.FsObjType_File, eType,));
+ else:
+ fRc = reporter.error('%s: WTF? type=%s' % (oFsObj.sPath, type(oFsObj),));
+
+ # Check the name.
+ if oFsObj.sName != sName:
+ fRc = reporter.error('%s: expected name "%s", got "%s" instead!' % (oFsObj.sPath, oFsObj.sName, sName,));
+
+ # Check the size if a file.
+ if isinstance(oFsObj, testfileset.TestFile) and cbFile != oFsObj.cbContent:
+ fRc = reporter.error('%s: expected size %s, got %s instead!' % (oFsObj.sPath, oFsObj.cbContent, cbFile,));
+
+ ## @todo check timestamps and attributes.
+
+ # Close the directory
+ try:
+ oCurDir.close();
+ except:
+ fRc = reporter.errorXcpt('oDir.sPath=%s' % (oDir.sPath,));
+
+ # Any files left over?
+ for sKey in dLeftUpper:
+ oFsObj = dLeftUpper[sKey];
+ fRc = reporter.error('%s: Was not returned! (%s)' % (oFsObj.sPath, type(oFsObj),));
+
+ # Check the dot and dot-dot counts.
+ if cDot != 1:
+ fRc = reporter.error('%s: Found %s "." entries, expected exactly 1!' % (oDir.sPath, cDot,));
+ if cDotDot != 1:
+ fRc = reporter.error('%s: Found %s ".." entries, expected exactly 1!' % (oDir.sPath, cDotDot,));
+
+ #
+ # Recurse into subdirectories using info from oDir.
+ #
+ for oFsObj in oDir.aoChildren:
+ if isinstance(oFsObj, testfileset.TestDir):
+ fRc = self.gctrlReadDirTree2(oGuestSession, oFsObj) and fRc;
+
+ return fRc;
+
+ 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));
+ fRcExec = self.gctrlExecute(oTest, oGuestSession, oRes.fRc);
+ if fRcExec == oRes.fRc:
+ fRc = True;
+ if fRcExec is True:
+ # Compare exit status / code on successful process execution.
+ if oTest.uExitStatus != oRes.uExitStatus \
+ or oTest.iExitCode != oRes.iExitCode:
+ fRc = reporter.error('Test #%d (%s) failed: Got exit status + code %d,%d, expected %d,%d'
+ % (i, oTest.asArgs, oTest.uExitStatus, oTest.iExitCode,
+ oRes.uExitStatus, oRes.iExitCode));
+
+ # Compare test / result buffers on successful process execution.
+ if oTest.sBuf is not None and oRes.sBuf is not None:
+ if not utils.areBytesEqual(oTest.sBuf, oRes.sBuf):
+ fRc = reporter.error('Test #%d (%s) failed: Got buffer\n%s (%d bytes), expected\n%s (%d bytes)'
+ % (i, oTest.asArgs,
+ map(hex, map(ord, oTest.sBuf)), len(oTest.sBuf),
+ map(hex, map(ord, oRes.sBuf)), len(oRes.sBuf)));
+ reporter.log2('Test #%d passed: Buffers match (%d bytes)' % (i, len(oRes.sBuf)));
+ elif oRes.sBuf and not oTest.sBuf:
+ fRc = reporter.error('Test #%d (%s) failed: Got no buffer data, expected\n%s (%dbytes)' %
+ (i, oTest.asArgs, map(hex, map(ord, oRes.sBuf)), len(oRes.sBuf),));
+
+ if oRes.cbStdOut is not None and oRes.cbStdOut != oTest.cbStdOut:
+ fRc = reporter.error('Test #%d (%s) failed: Got %d bytes of stdout data, expected %d'
+ % (i, oTest.asArgs, oTest.cbStdOut, oRes.cbStdOut));
+ if oRes.cbStdErr is not None and oRes.cbStdErr != oTest.cbStdErr:
+ fRc = reporter.error('Test #%d (%s) failed: Got %d bytes of stderr data, expected %d'
+ % (i, oTest.asArgs, oTest.cbStdErr, oRes.cbStdErr));
+ else:
+ fRc = reporter.error('Test #%d (%s) failed: Got %s, expected %s' % (i, oTest.asArgs, fRcExec, oRes.fRc));
+ return fRc;
+
+ def gctrlExecute(self, oTest, oGuestSession, fIsError): # pylint: disable=too-many-statements
+ """
+ Helper function to execute a program on a guest, specified in the current test.
+
+ Note! This weirdo returns results (process exitcode and status) in oTest.
+ """
+ fRc = True; # Be optimistic.
+
+ # Reset the weird result stuff:
+ oTest.cbStdOut = 0;
+ oTest.cbStdErr = 0;
+ oTest.sBuf = '';
+ oTest.uExitStatus = 0;
+ oTest.iExitCode = 0;
+
+ ## @todo Compare execution timeouts!
+ #tsStart = base.timestampMilli();
+
+ try:
+ reporter.log2('Using session user=%s, sDomain=%s, name=%s, timeout=%d'
+ % (oGuestSession.user, oGuestSession.domain, oGuestSession.name, oGuestSession.timeout,));
+ except:
+ return reporter.errorXcpt();
+
+ #
+ # Start the process:
+ #
+ reporter.log2('Executing sCmd=%s, afFlags=%s, timeoutMS=%d, asArgs=%s, asEnv=%s'
+ % (oTest.sCmd, oTest.afFlags, oTest.timeoutMS, limitString(oTest.asArgs), limitString(oTest.aEnv),));
+ try:
+ oProcess = oGuestSession.processCreate(oTest.sCmd,
+ oTest.asArgs if self.oTstDrv.fpApiVer >= 5.0 else oTest.asArgs[1:],
+ oTest.aEnv, oTest.afFlags, oTest.timeoutMS);
+ except:
+ reporter.maybeErrXcpt(fIsError, 'type=%s, asArgs=%s' % (type(oTest.asArgs), oTest.asArgs,));
+ return False;
+ if oProcess is None:
+ return reporter.error('oProcess is None! (%s)' % (oTest.asArgs,));
+
+ #time.sleep(5); # try this if you want to see races here.
+
+ # Wait for the process to start properly:
+ reporter.log2('Process start requested, waiting for start (%dms) ...' % (oTest.timeoutMS,));
+ iPid = -1;
+ aeWaitFor = [ vboxcon.ProcessWaitForFlag_Start, ];
+ try:
+ eWaitResult = oProcess.waitForArray(aeWaitFor, oTest.timeoutMS);
+ except:
+ reporter.maybeErrXcpt(fIsError, 'waitforArray failed for asArgs=%s' % (oTest.asArgs,));
+ fRc = False;
+ else:
+ try:
+ eStatus = oProcess.status;
+ iPid = oProcess.PID;
+ except:
+ fRc = reporter.errorXcpt('asArgs=%s' % (oTest.asArgs,));
+ else:
+ reporter.log2('Wait result returned: %d, current process status is: %d' % (eWaitResult, eStatus,));
+
+ #
+ # Wait for the process to run to completion if necessary.
+ #
+ # Note! The above eWaitResult return value can be ignored as it will
+ # (mostly) reflect the process status anyway.
+ #
+ if eStatus == vboxcon.ProcessStatus_Started:
+
+ # What to wait for:
+ aeWaitFor = [ vboxcon.ProcessWaitForFlag_Terminate, ];
+ if vboxcon.ProcessCreateFlag_WaitForStdOut in oTest.afFlags:
+ aeWaitFor.append(vboxcon.ProcessWaitForFlag_StdOut);
+ if vboxcon.ProcessCreateFlag_WaitForStdErr in oTest.afFlags:
+ aeWaitFor.append(vboxcon.ProcessWaitForFlag_StdErr);
+ ## @todo Add vboxcon.ProcessWaitForFlag_StdIn.
+
+ reporter.log2('Process (PID %d) started, waiting for termination (%dms), aeWaitFor=%s ...'
+ % (iPid, oTest.timeoutMS, aeWaitFor));
+ acbFdOut = [0,0,0];
+ while True:
+ try:
+ eWaitResult = oProcess.waitForArray(aeWaitFor, oTest.timeoutMS);
+ except KeyboardInterrupt: # Not sure how helpful this is, but whatever.
+ reporter.error('Process (PID %d) execution interrupted' % (iPid,));
+ try: oProcess.close();
+ except: pass;
+ break;
+ except:
+ fRc = reporter.errorXcpt('asArgs=%s' % (oTest.asArgs,));
+ break;
+ #reporter.log2('Wait returned: %d' % (eWaitResult,));
+
+ # Process output:
+ for eFdResult, iFd, sFdNm in [ (vboxcon.ProcessWaitResult_StdOut, 1, 'stdout'),
+ (vboxcon.ProcessWaitResult_StdErr, 2, 'stderr'), ]:
+ if eWaitResult in (eFdResult, vboxcon.ProcessWaitResult_WaitFlagNotSupported):
+ try:
+ abBuf = oProcess.read(iFd, 64 * 1024, oTest.timeoutMS);
+ except KeyboardInterrupt: # Not sure how helpful this is, but whatever.
+ reporter.error('Process (PID %d) execution interrupted' % (iPid,));
+ try: oProcess.close();
+ except: pass;
+ except:
+ reporter.maybeErrXcpt(fIsError, 'asArgs=%s' % (oTest.asArgs,));
+ else:
+ if abBuf:
+ reporter.log2('Process (PID %d) got %d bytes of %s data (type: %s)'
+ % (iPid, len(abBuf), sFdNm, type(abBuf)));
+ if reporter.getVerbosity() >= 4:
+ sBuf = '';
+ if sys.version_info >= (2, 7):
+ if isinstance(abBuf, memoryview): ## @todo Why is this happening?
+ abBuf = abBuf.tobytes();
+ sBuf = abBuf.decode("utf-8");
+ if sys.version_info <= (2, 7):
+ if isinstance(abBuf, buffer): # (for 3.0+) pylint: disable=undefined-variable
+ sBuf = str(abBuf);
+ for sLine in sBuf.splitlines():
+ reporter.log4('%s: %s' % (sFdNm, sLine));
+ acbFdOut[iFd] += len(abBuf);
+ oTest.sBuf = abBuf; ## @todo Figure out how to uniform + append!
+
+ ## Process input (todo):
+ #if eWaitResult in (vboxcon.ProcessWaitResult_StdIn, vboxcon.ProcessWaitResult_WaitFlagNotSupported):
+ # reporter.log2('Process (PID %d) needs stdin data' % (iPid,));
+
+ # Termination or error?
+ if eWaitResult in (vboxcon.ProcessWaitResult_Terminate,
+ vboxcon.ProcessWaitResult_Error,
+ vboxcon.ProcessWaitResult_Timeout,):
+ try: eStatus = oProcess.status;
+ except: fRc = reporter.errorXcpt('asArgs=%s' % (oTest.asArgs,));
+ reporter.log2('Process (PID %d) reported terminate/error/timeout: %d, status: %d'
+ % (iPid, eWaitResult, eStatus,));
+ break;
+
+ # End of the wait loop.
+ _, oTest.cbStdOut, oTest.cbStdErr = acbFdOut;
+
+ try: eStatus = oProcess.status;
+ except: fRc = reporter.errorXcpt('asArgs=%s' % (oTest.asArgs,));
+ reporter.log2('Final process status (PID %d) is: %d' % (iPid, eStatus));
+ reporter.log2('Process (PID %d) %d stdout, %d stderr' % (iPid, oTest.cbStdOut, oTest.cbStdErr));
+
+ #
+ # Get the final status and exit code of the process.
+ #
+ try:
+ oTest.uExitStatus = oProcess.status;
+ oTest.iExitCode = oProcess.exitCode;
+ except:
+ fRc = reporter.errorXcpt('asArgs=%s' % (oTest.asArgs,));
+ reporter.log2('Process (PID %d) has exit code: %d; status: %d ' % (iPid, oTest.iExitCode, oTest.uExitStatus));
+ return fRc;
+
+ def testGuestCtrlSessionEnvironment(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ 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!
+ tdStepSessionBulkEnv(['', 'foo=bar'], vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionSetEnv('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',]),
+ ]),
+ ];
+ # Leading '=' in the name is okay for windows guests in 6.1 and later (for driver letter CWDs).
+ if (self.oTstDrv.fpApiVer < 6.1 and self.oTstDrv.fpApiVer >= 5.0) or not oTestVm.isWindows():
+ aoTests.append(tdTestSessionEx([tdStepSessionSetEnv('=', '===', vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionSetEnv('=FOO', 'BAR', vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionBulkEnv(['=', 'foo=bar'], vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionBulkEnv(['=FOO', 'foo=bar'], vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionBulkEnv(['=D:=D:/tmp', 'foo=bar'], vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ tdStepSessionSetEnv('=D:', 'D:/temp', vbox.ComError.E_INVALIDARG),
+ tdStepSessionCheckEnv(),
+ ]));
+ elif self.oTstDrv.fpApiVer >= 6.1 and oTestVm.isWindows():
+ aoTests.append(tdTestSessionEx([tdStepSessionSetEnv('=D:', 'D:/tmp'),
+ tdStepSessionCheckEnv(['=D:=D:/tmp',]),
+ tdStepSessionBulkEnv(['=D:=D:/temp', '=FOO', 'foo=bar']),
+ tdStepSessionCheckEnv(['=D:=D:/temp', '=FOO', 'foo=bar']),
+ tdStepSessionUnsetEnv('=D:'),
+ tdStepSessionCheckEnv(['=D:', '=FOO', 'foo=bar']),
+ ]));
+
+ return tdTestSessionEx.executeListTestSessions(aoTests, self.oTstDrv, oSession, oTxsSession, oTestVm, 'SessionEnv');
+
+ def testGuestCtrlSession(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests the guest session handling.
+ """
+
+ #
+ # Tests:
+ #
+ atTests = [
+ # Invalid parameters.
+ [ tdTestSession(sUser = ''), tdTestResultSession() ],
+ # User account without a passwort - forbidden.
+ [ tdTestSession(sPassword = "" ), tdTestResultSession() ],
+ # Various wrong credentials.
+ # Note! Only windows cares about sDomain, the other guests ignores it.
+ # 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(sPassword = 'bar'), tdTestResultSession() ],
+ [ tdTestSession(sUser = 'foo', sPassword = 'bar'), tdTestResultSession() ],
+ [ tdTestSession(sPassword = 'bar', sDomain = 'boo'), tdTestResultSession() ],
+ [ tdTestSession(sUser = 'foo', sPassword = 'bar', sDomain = 'boo'), tdTestResultSession() ],
+ ];
+ if oTestVm.isWindows(): # domain is ignored elsewhere.
+ atTests.append([ tdTestSession(sDomain = 'boo'), tdTestResultSession() ]);
+
+ # Finally, correct credentials.
+ atTests.append([ tdTestSession(), tdTestResultSession(fRc = True, cNumSessions = 1) ]);
+
+ #
+ # Run the tests.
+ #
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestSession
+ oCurRes = tTest[1] # type: tdTestResult
+
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ reporter.log('Testing #%d, user="%s", sPassword="%s", sDomain="%s" ...'
+ % (i, oCurTest.oCreds.sUser, oCurTest.oCreds.sPassword, oCurTest.oCreds.sDomain));
+ sCurGuestSessionName = 'testGuestCtrlSession: Test #%d' % (i,);
+ fRc2, oCurGuestSession = oCurTest.createSession(sCurGuestSessionName, fIsError = oCurRes.fRc);
+
+ # See note about < 4.3 Guest Additions above.
+ uProtocolVersion = 2;
+ if oCurGuestSession is not None:
+ try:
+ uProtocolVersion = oCurGuestSession.protocolVersion;
+ except:
+ fRc = reporter.errorXcpt('Test #%d' % (i,));
+
+ if uProtocolVersion >= 2 and fRc2 is not oCurRes.fRc:
+ fRc = reporter.error('Test #%d failed: Session creation failed: Got %s, expected %s' % (i, fRc2, oCurRes.fRc,));
+
+ if fRc2 and oCurGuestSession is None:
+ fRc = reporter.error('Test #%d failed: no session object' % (i,));
+ fRc2 = False;
+
+ if fRc2:
+ if uProtocolVersion >= 2: # For Guest Additions < 4.3 getSessionCount() always will return 1.
+ cCurSessions = oCurTest.getSessionCount(self.oTstDrv.oVBoxMgr);
+ if cCurSessions != oCurRes.cNumSessions:
+ fRc = reporter.error('Test #%d failed: Session count does not match: Got %d, expected %d'
+ % (i, cCurSessions, oCurRes.cNumSessions));
+ try:
+ sObjName = oCurGuestSession.name;
+ except:
+ fRc = reporter.errorXcpt('Test #%d' % (i,));
+ else:
+ if sObjName != sCurGuestSessionName:
+ fRc = reporter.error('Test #%d failed: Session name does not match: Got "%s", expected "%s"'
+ % (i, sObjName, sCurGuestSessionName));
+ fRc2 = oCurTest.closeSession();
+ if fRc2 is False:
+ fRc = reporter.error('Test #%d failed: Session could not be closed' % (i,));
+
+ if fRc is False:
+ return (False, oTxsSession);
+
+ #
+ # Multiple sessions.
+ #
+ cMaxGuestSessions = 31; # Maximum number of concurrent guest session allowed.
+ # Actually, this is 32, but we don't test session 0.
+ aoMultiSessions = {};
+ reporter.log2('Opening multiple guest tsessions at once ...');
+ for i in xrange(cMaxGuestSessions + 1):
+ aoMultiSessions[i] = tdTestSession(sSessionName = 'MultiSession #%d' % (i,));
+ fRc = aoMultiSessions[i].setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+
+ cCurSessions = aoMultiSessions[i].getSessionCount(self.oTstDrv.oVBoxMgr);
+ reporter.log2('MultiSession test #%d count is %d' % (i, cCurSessions));
+ if cCurSessions != i:
+ return (reporter.error('MultiSession count is %d, expected %d' % (cCurSessions, i)), oTxsSession);
+ fRc2, _ = aoMultiSessions[i].createSession('MultiSession #%d' % (i,), i < cMaxGuestSessions);
+ if fRc2 is not True:
+ if i < cMaxGuestSessions:
+ return (reporter.error('MultiSession #%d test failed' % (i,)), oTxsSession);
+ reporter.log('MultiSession #%d exceeded concurrent guest session count, good' % (i,));
+ break;
+
+ cCurSessions = aoMultiSessions[i].getSessionCount(self.oTstDrv.oVBoxMgr);
+ if cCurSessions is not cMaxGuestSessions:
+ return (reporter.error('Final session count %d, expected %d ' % (cCurSessions, cMaxGuestSessions,)), oTxsSession);
+
+ reporter.log2('Closing MultiSessions ...');
+ for i in xrange(cMaxGuestSessions):
+ # Close this session:
+ oClosedGuestSession = aoMultiSessions[i].oGuestSession;
+ fRc2 = aoMultiSessions[i].closeSession();
+ cCurSessions = aoMultiSessions[i].getSessionCount(self.oTstDrv.oVBoxMgr)
+ reporter.log2('MultiSession #%d count is %d' % (i, cCurSessions,));
+ if fRc2 is False:
+ fRc = reporter.error('Closing MultiSession #%d failed' % (i,));
+ elif cCurSessions != cMaxGuestSessions - (i + 1):
+ fRc = reporter.error('Expected %d session after closing #%d, got %d instead'
+ % (cMaxGuestSessions - (i + 1), cCurSessions, i,));
+ assert aoMultiSessions[i].oGuestSession is None or not fRc2;
+ ## @todo any way to check that the session is closed other than the 'sessions' attribute?
+
+ # Try check that none of the remaining sessions got closed.
+ try:
+ aoGuestSessions = self.oTstDrv.oVBoxMgr.getArray(atTests[0][0].oGuest, 'sessions');
+ except:
+ return (reporter.errorXcpt('i=%d/%d' % (i, cMaxGuestSessions,)), oTxsSession);
+ if oClosedGuestSession in aoGuestSessions:
+ fRc = reporter.error('i=%d/%d: %s should not be in %s'
+ % (i, cMaxGuestSessions, oClosedGuestSession, aoGuestSessions));
+ if i + 1 < cMaxGuestSessions: # Not sure what xrange(2,2) does...
+ for j in xrange(i + 1, cMaxGuestSessions):
+ if aoMultiSessions[j].oGuestSession not in aoGuestSessions:
+ fRc = reporter.error('i=%d/j=%d/%d: %s should be in %s'
+ % (i, j, cMaxGuestSessions, aoMultiSessions[j].oGuestSession, aoGuestSessions));
+ ## @todo any way to check that they work?
+
+ ## @todo Test session timeouts.
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlSessionFileRefs(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests the guest session file reference handling.
+ """
+
+ # Find a file to play around with:
+ sFile = self.oTstDrv.getGuestSystemFileForReading(oTestVm);
+
+ # Use credential defaults.
+ oCreds = tdCtxCreds();
+ oCreds.applyDefaultsIfNotSet(oTestVm);
+
+ # Number of stale guest files to create.
+ cStaleFiles = 10;
+
+ #
+ # Start a session.
+ #
+ aeWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ try:
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(oCreds.sUser, oCreds.sPassword, oCreds.sDomain, "testGuestCtrlSessionFileRefs");
+ eWaitResult = oGuestSession.waitForArray(aeWaitFor, 30 * 1000);
+ except:
+ return (reporter.errorXcpt(), oTxsSession);
+
+ # Be nice to Guest Additions < 4.3: They don't support session handling and therefore return WaitFlagNotSupported.
+ if eWaitResult not in (vboxcon.GuestSessionWaitResult_Start, vboxcon.GuestSessionWaitResult_WaitFlagNotSupported):
+ return (reporter.error('Session did not start successfully - wait error: %d' % (eWaitResult,)), 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');
+ fRc = True;
+ for i in xrange(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:
+ fRc = reporter.errorXcpt('Opening stale file #%d failed:' % (i,));
+ break;
+
+ try: cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ except: fRc = reporter.errorXcpt();
+ else:
+ if cFiles != cStaleFiles:
+ fRc = reporter.error('Got %d stale files, expected %d' % (cFiles, cStaleFiles));
+
+ if fRc is True:
+ #
+ # Open non-stale files and close them again.
+ #
+ reporter.log2('Opening non-stale files');
+ aoFiles = [];
+ for i in xrange(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);
+ aoFiles.append(oCurFile);
+ except:
+ fRc = reporter.errorXcpt('Opening non-stale file #%d failed:' % (i,));
+ break;
+
+ # Check the count.
+ try: cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ except: fRc = reporter.errorXcpt();
+ else:
+ if cFiles != cStaleFiles * 2:
+ fRc = reporter.error('Got %d total files, expected %d' % (cFiles, cStaleFiles * 2));
+
+ # Close them.
+ reporter.log2('Closing all non-stale files again ...');
+ for i, oFile in enumerate(aoFiles):
+ try:
+ oFile.close();
+ except:
+ fRc = reporter.errorXcpt('Closing non-stale file #%d failed:' % (i,));
+
+ # Check the count again.
+ try: cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ except: fRc = reporter.errorXcpt();
+ # 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 aoFiles[] for).
+ if cFiles != cStaleFiles:
+ fRc = reporter.error('Got %d total files, expected %d' % (cFiles, cStaleFiles));
+
+ #
+ # Check that all (referenced) non-stale files are now in the "closed" state.
+ #
+ reporter.log2('Checking statuses of all non-stale files ...');
+ for i, oFile in enumerate(aoFiles):
+ try:
+ eFileStatus = aoFiles[i].status;
+ except:
+ fRc = reporter.errorXcpt('Checking status of file #%d failed:' % (i,));
+ else:
+ if eFileStatus != vboxcon.FileStatus_Closed:
+ fRc = reporter.error('Non-stale file #%d has status %d, expected %d'
+ % (i, eFileStatus, vboxcon.FileStatus_Closed));
+
+ if fRc is True:
+ reporter.log2('All non-stale files closed');
+
+ try: cFiles = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'files'));
+ except: fRc = reporter.errorXcpt();
+ else: reporter.log2('Final guest session file count: %d' % (cFiles,));
+
+ #
+ # Now try to close the session and see what happens.
+ # Note! Session closing is why we've been doing all the 'if fRc is True' stuff above rather than returning.
+ #
+ reporter.log2('Closing guest session ...');
+ try:
+ oGuestSession.close();
+ except:
+ fRc = reporter.errorXcpt('Testing for stale processes failed:');
+
+ 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=too-many-locals,too-many-statements
+ """
+ Tests the guest session process reference handling.
+ """
+
+ sShell = self.oTstDrv.getGuestSystemShell(oTestVm);
+ asArgs = [sShell,];
+
+ # Use credential defaults.
+ oCreds = tdCtxCreds();
+ oCreds.applyDefaultsIfNotSet(oTestVm);
+
+ # Number of guest processes per group to create.
+ cProcsPerGroup = 10;
+
+ #
+ # Start a session.
+ #
+ aeWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ try:
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(oCreds.sUser, oCreds.sPassword, oCreds.sDomain, "testGuestCtrlSessionProcRefs");
+ eWaitResult = oGuestSession.waitForArray(aeWaitFor, 30 * 1000);
+ except:
+ return (reporter.errorXcpt(), oTxsSession);
+
+ # Be nice to Guest Additions < 4.3: They don't support session handling and therefore return WaitFlagNotSupported.
+ if eWaitResult not in (vboxcon.GuestSessionWaitResult_Start, vboxcon.GuestSessionWaitResult_WaitFlagNotSupported):
+ return (reporter.error('Session did not start successfully - wait error: %d' % (eWaitResult,)), 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.log('Starting stale processes...');
+ fRc = True;
+ for i in xrange(0, cProcsPerGroup):
+ try:
+ reporter.log2('Starting stale process #%d...' % (i));
+ oGuestSession.processCreate(sShell,
+ asArgs if self.oTstDrv.fpApiVer >= 5.0 else asArgs[1:], [],
+ [ vboxcon.ProcessCreateFlag_WaitForStdOut ], 30 * 1000);
+ # Note: Not keeping a process reference from the created process above is intentional and part of the test!
+
+ # 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:
+ fRc = reporter.errorXcpt('Creating stale process #%d failed:' % (i,));
+ break;
+
+ if fRc:
+ reporter.log2('Starting stale processes successful');
+ try: cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ except: fRc = reporter.errorXcpt();
+ else:
+ reporter.log2('Proccess count is: %d' % (cProcs));
+ if cProcs != cProcsPerGroup:
+ fRc = reporter.error('Got %d stale processes, expected %d (stale)' % (cProcs, cProcsPerGroup));
+
+ if fRc:
+ #
+ # Fire off non-stale processes and wait for termination.
+ #
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ asArgs = [ sShell, '/C', 'dir', '/S', self.oTstDrv.getGuestSystemDir(oTestVm), ];
+ else:
+ asArgs = [ sShell, '-c', 'ls -la ' + self.oTstDrv.getGuestSystemDir(oTestVm), ];
+ reporter.log('Starting non-stale processes...');
+ aoProcs = [];
+ for i in xrange(0, cProcsPerGroup):
+ try:
+ reporter.log2('Starting non-stale process #%d...' % (i));
+ oCurProc = oGuestSession.processCreate(sShell, asArgs if self.oTstDrv.fpApiVer >= 5.0 else asArgs[1:],
+ [], [], 0); # Infinite timeout.
+ aoProcs.append(oCurProc);
+ except:
+ fRc = reporter.errorXcpt('Creating non-stale process #%d failed:' % (i,));
+ break;
+
+ try: cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ except: fRc = reporter.errorXcpt();
+ else:
+ reporter.log2('Proccess count is: %d' % (cProcs));
+
+ reporter.log('Waiting for non-stale processes to terminate...');
+ for i, oProcess in enumerate(aoProcs):
+ try:
+ reporter.log('Waiting for non-stale process #%d...' % (i));
+ eWaitResult = oProcess.waitForArray([ vboxcon.ProcessWaitForFlag_Terminate, ], 30 * 1000);
+ eProcessStatus = oProcess.status;
+ except:
+ fRc = reporter.errorXcpt('Waiting for non-stale process #%d failed:' % (i,));
+ else:
+ if eProcessStatus != vboxcon.ProcessStatus_TerminatedNormally:
+ fRc = reporter.error('Waiting for non-stale processes #%d resulted in status %d, expected %d (wr=%d)'
+ % (i, eProcessStatus, vboxcon.ProcessStatus_TerminatedNormally, eWaitResult));
+ if fRc:
+ reporter.log('All non-stale processes ended successfully');
+
+ try: cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ except: fRc = reporter.errorXcpt();
+ else:
+ reporter.log2('Proccess count is: %d' % (cProcs));
+
+ # Here we count the stale processes (that is, processes we don't have a reference
+ # anymore for) and the started + ended non-stale processes (that we still keep
+ # a reference in aoProcesses[] for).
+ cProcsExpected = cProcsPerGroup * 2;
+ if cProcs != cProcsExpected:
+ fRc = reporter.error('Got %d total processes, expected %d (stale vs. non-stale)' \
+ % (cProcs, cProcsExpected));
+ #
+ # Fire off non-stale blocking processes which are terminated via terminate().
+ #
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ sCmd = sShell;
+ asArgs = [ sCmd, '/C', 'pause'];
+ else:
+ sCmd = '/usr/bin/yes';
+ asArgs = [ sCmd ];
+ reporter.log('Starting blocking processes...');
+ aoProcs = [];
+ for i in xrange(0, cProcsPerGroup):
+ try:
+ reporter.log2('Starting blocking process #%d...' % (i));
+ oCurProc = oGuestSession.processCreate(sCmd, asArgs if self.oTstDrv.fpApiVer >= 5.0 else asArgs[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.
+ try:
+ reporter.log('Waiting for blocking process #%d getting started...' % (i));
+ eWaitResult = oCurProc.waitForArray([ vboxcon.ProcessWaitForFlag_Start, ], 30 * 1000);
+ eProcessStatus = oCurProc.status;
+ except:
+ fRc = reporter.errorXcpt('Waiting for blocking process #%d failed:' % (i,));
+ else:
+ if eProcessStatus != vboxcon.ProcessStatus_Started:
+ fRc = reporter.error('Waiting for blocking processes #%d resulted in status %d, expected %d (wr=%d)'
+ % (i, eProcessStatus, vboxcon.ProcessStatus_Started, eWaitResult));
+ aoProcs.append(oCurProc);
+ except:
+ fRc = reporter.errorXcpt('Creating blocking process #%d failed:' % (i,));
+ break;
+
+ if fRc:
+ reporter.log2('Starting blocking processes successful');
+
+ reporter.log2('Terminating blocking processes...');
+ for i, oProcess in enumerate(aoProcs):
+ try:
+ reporter.log('Terminating blocking process #%d...' % (i));
+ oProcess.terminate();
+ except: # Termination might not be supported, just skip and log it.
+ reporter.logXcpt('Termination of blocking process #%d failed, skipped:' % (i,));
+ if self.oTstDrv.fpApiVer >= 6.1: # Termination is supported since 5.2 or so.
+ fRc = False;
+ if fRc:
+ reporter.log('All blocking processes were terminated successfully');
+
+ try: cProcs = len(self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes'));
+ except: fRc = reporter.errorXcpt();
+ else:
+ # There still should be 20 processes because we just terminated the 10 blocking ones above.
+ cProcsExpected = cProcsPerGroup * 2;
+ if cProcs != cProcsExpected:
+ fRc = reporter.error('Got %d total processes, expected %d (final)' % (cProcs, cProcsExpected));
+ reporter.log2('Final guest session processes count: %d' % (cProcs,));
+
+ if not fRc:
+ aoProcs = self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes');
+ for i, oProc in enumerate(aoProcs):
+ try:
+ aoArgs = self.oTstDrv.oVBoxMgr.getArray(oProc, 'arguments');
+ reporter.log('Process %d (\'%s\') still around, status is %d' \
+ % (i, ' '.join([str(x) for x in aoArgs]), oProc.status));
+ except:
+ reporter.errorXcpt('Process lookup failed:');
+ #
+ # Now try to close the session and see what happens.
+ #
+ reporter.log('Closing guest session ...');
+ try:
+ oGuestSession.close();
+ except:
+ fRc = reporter.errorXcpt('Closing session for testing process references failed:');
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlExec(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals,too-many-statements
+ """
+ Tests the basic execution feature.
+ """
+
+ # Paths:
+ sVBoxControl = None; ## @todo Get path of installed Guest Additions. Later.
+ sShell = self.oTstDrv.getGuestSystemShell(oTestVm);
+ sShellOpt = '/C' if oTestVm.isWindows() or oTestVm.isOS2() else '-c';
+ sSystemDir = self.oTstDrv.getGuestSystemDir(oTestVm);
+ sFileForReading = self.oTstDrv.getGuestSystemFileForReading(oTestVm);
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ sImageOut = self.oTstDrv.getGuestSystemShell(oTestVm);
+ if oTestVm.isWindows():
+ sVBoxControl = "C:\\Program Files\\Oracle\\VirtualBox Guest Additions\\VBoxControl.exe";
+ else:
+ sImageOut = oTestVm.pathJoin(self.oTstDrv.getGuestSystemDir(oTestVm), 'ls');
+ if oTestVm.isLinux(): ## @todo check solaris and darwin.
+ sVBoxControl = "/usr/bin/VBoxControl"; # Symlink
+
+ # Use credential defaults.
+ oCreds = tdCtxCreds();
+ oCreds.applyDefaultsIfNotSet(oTestVm);
+
+ atInvalid = [
+ # Invalid parameters.
+ [ tdTestExec(), tdTestResultExec() ],
+ # Non-existent / invalid image.
+ [ tdTestExec(sCmd = "non-existent"), tdTestResultExec() ],
+ [ tdTestExec(sCmd = "non-existent2"), tdTestResultExec() ],
+ # Use an invalid format string.
+ [ tdTestExec(sCmd = "%$%%%&"), tdTestResultExec() ],
+ # More stuff.
+ [ tdTestExec(sCmd = u"ƒ‰‹ˆ÷‹¸"), tdTestResultExec() ],
+ [ tdTestExec(sCmd = "???://!!!"), tdTestResultExec() ],
+ [ tdTestExec(sCmd = "<>!\\"), tdTestResultExec() ],
+ # Enable as soon as ERROR_BAD_DEVICE is implemented.
+ #[ tdTestExec(sCmd = "CON", tdTestResultExec() ],
+ ];
+
+ atExec = [];
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ atExec += [
+ # Basic execution.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', sFileForReading ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', sSystemDir + '\\nonexist.dll' ]),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', '/wrongparam' ]),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ [ tdTestExec(sCmd = sShell, asArgs = [ sShell, sShellOpt, 'wrongcommand' ]),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # StdOut.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', 'stdout-non-existing' ]),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # StdErr.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', 'stderr-non-existing' ]),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ # StdOut + StdErr.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'dir', '/S', 'stdouterr-non-existing' ]),
+ tdTestResultExec(fRc = True, iExitCode = 1) ],
+ ];
+ # atExec.extend([
+ # FIXME: Failing tests.
+ # Environment variables.
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'TEST_NONEXIST' ],
+ # tdTestResultExec(fRc = True, iExitCode = 1) ]
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'windir' ],
+ # afFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, sBuf = 'windir=C:\\WINDOWS\r\n') ],
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'TEST_FOO' ],
+ # aEnv = [ 'TEST_FOO=BAR' ],
+ # afFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, sBuf = 'TEST_FOO=BAR\r\n') ],
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'TEST_FOO' ],
+ # aEnv = [ 'TEST_FOO=BAR', 'TEST_BAZ=BAR' ],
+ # afFlags = [ 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.
+ #];
+ else:
+ atExec += [
+ # Basic execution.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '-R', sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, sFileForReading ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '--wrong-parameter' ]),
+ tdTestResultExec(fRc = True, iExitCode = 2) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/non/existent' ]),
+ tdTestResultExec(fRc = True, iExitCode = 2) ],
+ [ tdTestExec(sCmd = sShell, asArgs = [ sShell, sShellOpt, 'wrongcommand' ]),
+ tdTestResultExec(fRc = True, iExitCode = 127) ],
+ # StdOut.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, 'stdout-non-existing' ]),
+ tdTestResultExec(fRc = True, iExitCode = 2) ],
+ # StdErr.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, 'stderr-non-existing' ]),
+ tdTestResultExec(fRc = True, iExitCode = 2) ],
+ # StdOut + StdErr.
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, sSystemDir ]),
+ tdTestResultExec(fRc = True) ],
+ [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, 'stdouterr-non-existing' ]),
+ tdTestResultExec(fRc = True, iExitCode = 2) ],
+ ];
+ # atExec.extend([
+ # FIXME: Failing tests.
+ # Environment variables.
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'TEST_NONEXIST' ],
+ # tdTestResultExec(fRc = True, iExitCode = 1) ]
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'windir' ],
+ #
+ # afFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, sBuf = 'windir=C:\\WINDOWS\r\n') ],
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'TEST_FOO' ],
+ # aEnv = [ 'TEST_FOO=BAR' ],
+ # afFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut, vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ # tdTestResultExec(fRc = True, sBuf = 'TEST_FOO=BAR\r\n') ],
+ # [ tdTestExec(sCmd = sImageOut, asArgs = [ sImageOut, '/C', 'set', 'TEST_FOO' ],
+ # aEnv = [ 'TEST_FOO=BAR', 'TEST_BAZ=BAR' ],
+ # afFlags = [ 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.
+ #];
+
+ #
+ #for iExitCode in xrange(0, 127):
+ # atExec.append([ tdTestExec(sCmd = sShell, asArgs = [ sShell, sShellOpt, 'exit %s' % iExitCode ]),
+ # tdTestResultExec(fRc = True, iExitCode = iExitCode) ]);
+
+ if sVBoxControl \
+ and self.oTstDrv.fpApiVer >= 6.0: # Investigate with this doesn't work on (<) 5.2.
+ # Paths with spaces on windows.
+ atExec.append([ tdTestExec(sCmd = sVBoxControl, asArgs = [ sVBoxControl, 'version' ],
+ afFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut,
+ vboxcon.ProcessCreateFlag_WaitForStdErr ]),
+ tdTestResultExec(fRc = True) ]);
+
+ # Test very long arguments. Be careful when tweaking this to not break the tests.
+ # Regarding paths:
+ # - We have RTPATH_BIG_MAX (64K)
+ # - MSDN says 32K for CreateFileW()
+ # - On Windows, each path component must not be longer than MAX_PATH (260), see
+ # https://docs.microsoft.com/en-us/windows/win32/fileio/filesystem-functionality-comparison#limits
+ #
+ # Old(er) Windows OSes tend to crash in cmd.exe, so skip this on these OSes.
+ if self.oTstDrv.fpApiVer >= 6.1 \
+ and oTestVm.sKind not in ('WindowsNT4', 'Windows2000', 'WindowsXP', 'Windows2003'):
+ sEndMarker = '--end-marker';
+ if oTestVm.isWindows() \
+ or oTestVm.isOS2():
+ sCmd = sShell;
+ else:
+ sCmd = oTestVm.pathJoin(self.oTstDrv.getGuestSystemDir(oTestVm), 'echo');
+
+ for _ in xrange(0, 16):
+ if oTestVm.isWindows() \
+ or oTestVm.isOS2():
+ asArgs = [ sShell, sShellOpt, "echo" ];
+ else:
+ asArgs = [ sCmd ];
+
+ # Append a random number of arguments with random length.
+ for _ in xrange(0, self.oTestFiles.oRandom.randrange(1, 64)):
+ asArgs.append(''.join(random.choice(string.ascii_lowercase)
+ for _ in range(self.oTestFiles.oRandom.randrange(1, 196))));
+
+ asArgs.append(sEndMarker);
+
+ reporter.log2('asArgs=%s (%d args), type=%s' % (limitString(asArgs), len(asArgs), type(asArgs)));
+
+ ## @todo Check limits; on Ubuntu with 256KB IPRT returns VERR_NOT_IMPLEMENTED.
+ # Use a higher timeout (15 min) than usual for these long checks.
+ atExec.append([ tdTestExec(sCmd, asArgs,
+ afFlags = [ vboxcon.ProcessCreateFlag_WaitForStdOut,
+ vboxcon.ProcessCreateFlag_WaitForStdErr ],
+ timeoutMS = 15 * 60 * 1000),
+ tdTestResultExec(fRc = True) ]);
+
+ # Build up the final test array for the first batch.
+ atTests = atInvalid + atExec;
+
+ #
+ # First batch: One session per guest process.
+ #
+ reporter.log('One session per guest process ...');
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestExec
+ oCurRes = tTest[1] # type: tdTestResultExec
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc2, oCurGuestSession = oCurTest.createSession('testGuestCtrlExec: Test #%d' % (i,));
+ if fRc2 is not True:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ fRc = self.gctrlExecDoTest(i, oCurTest, oCurRes, oCurGuestSession) and fRc;
+ fRc = oCurTest.closeSession() and fRc;
+
+ reporter.log('Execution of all tests done, checking for stale sessions');
+
+ # No sessions left?
+ try:
+ aSessions = self.oTstDrv.oVBoxMgr.getArray(oSession.o.console.guest, 'sessions');
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ cSessions = len(aSessions);
+ if cSessions != 0:
+ fRc = reporter.error('Found %d stale session(s), expected 0:' % (cSessions,));
+ for (i, aSession) in enumerate(aSessions):
+ try: reporter.log(' Stale session #%d ("%s")' % (aSession.id, aSession.name));
+ except: reporter.errorXcpt();
+
+ if fRc is not True:
+ return (fRc, oTxsSession);
+
+ reporter.log('Now using one guest session for all tests ...');
+
+ #
+ # Second batch: One session for *all* guest processes.
+ #
+
+ # Create session.
+ reporter.log('Creating session for all tests ...');
+ aeWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start, ];
+ try:
+ oGuest = oSession.o.console.guest;
+ oCurGuestSession = oGuest.createSession(oCreds.sUser, oCreds.sPassword, oCreds.sDomain,
+ 'testGuestCtrlExec: One session for all tests');
+ except:
+ return (reporter.errorXcpt(), oTxsSession);
+
+ try:
+ eWaitResult = oCurGuestSession.waitForArray(aeWaitFor, 30 * 1000);
+ except:
+ fRc = reporter.errorXcpt('Waiting for guest session to start failed:');
+ else:
+ if eWaitResult not in (vboxcon.GuestSessionWaitResult_Start, vboxcon.GuestSessionWaitResult_WaitFlagNotSupported):
+ fRc = reporter.error('Session did not start successfully, returned wait result: %d' % (eWaitResult,));
+ else:
+ reporter.log('Session successfully started');
+
+ # Do the tests within this session.
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestExec
+ oCurRes = tTest[1] # type: tdTestResultExec
+
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc = self.gctrlExecDoTest(i, oCurTest, oCurRes, oCurGuestSession);
+ if fRc is False:
+ break;
+
+ # Close the session.
+ reporter.log2('Closing guest session ...');
+ try:
+ oCurGuestSession.close();
+ oCurGuestSession = None;
+ except:
+ fRc = reporter.errorXcpt('Closing guest session failed:');
+
+ # No sessions left?
+ reporter.log('Execution of all tests done, checking for stale sessions again');
+ try: cSessions = len(self.oTstDrv.oVBoxMgr.getArray(oSession.o.console.guest, 'sessions'));
+ except: fRc = reporter.errorXcpt();
+ else:
+ if cSessions != 0:
+ fRc = reporter.error('Found %d stale session(s), expected 0' % (cSessions,));
+ return (fRc, oTxsSession);
+
+ def threadForTestGuestCtrlSessionReboot(self, oGuestProcess):
+ """
+ Thread routine which waits for the stale guest process getting terminated (or some error)
+ while the main test routine reboots the guest. It then compares the expected guest process result
+ and logs an error if appropriate.
+ """
+ reporter.log('Waiting for process to get terminated at reboot ...');
+ try:
+ eWaitResult = oGuestProcess.waitForArray([ vboxcon.ProcessWaitForFlag_Terminate ], 5 * 60 * 1000);
+ except:
+ return reporter.errorXcpt('waitForArray failed');
+ try:
+ eStatus = oGuestProcess.status
+ except:
+ return reporter.errorXcpt('failed to get status (wait result %d)' % (eWaitResult,));
+
+ if eWaitResult == vboxcon.ProcessWaitResult_Terminate and eStatus == vboxcon.ProcessStatus_Down:
+ reporter.log('Stale process was correctly terminated (status: down)');
+ return True;
+
+ return reporter.error('Process wait across reboot failed: eWaitResult=%d, expected %d; eStatus=%d, expected %d'
+ % (eWaitResult, vboxcon.ProcessWaitResult_Terminate, eStatus, vboxcon.ProcessStatus_Down,));
+
+ def testGuestCtrlSessionReboot(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests guest object notifications when a guest gets rebooted / shutdown.
+
+ These notifications gets sent from the guest sessions in order to make API clients
+ aware of guest session changes.
+
+ To test that we create a stale guest process and trigger a reboot of the guest.
+ """
+
+ ## @todo backport fixes to 6.0 and maybe 5.2
+ if self.oTstDrv.fpApiVer <= 6.0:
+ reporter.log('Skipping: Required fixes not yet backported!');
+ return None;
+
+ # Use credential defaults.
+ oCreds = tdCtxCreds();
+ oCreds.applyDefaultsIfNotSet(oTestVm);
+
+ fRebooted = False;
+ fRc = True;
+
+ #
+ # Start a session.
+ #
+ aeWaitFor = [ vboxcon.GuestSessionWaitForFlag_Start ];
+ try:
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(oCreds.sUser, oCreds.sPassword, oCreds.sDomain, "testGuestCtrlSessionReboot");
+ eWaitResult = oGuestSession.waitForArray(aeWaitFor, 30 * 1000);
+ except:
+ return (reporter.errorXcpt(), oTxsSession);
+
+ # Be nice to Guest Additions < 4.3: They don't support session handling and therefore return WaitFlagNotSupported.
+ if eWaitResult not in (vboxcon.GuestSessionWaitResult_Start, vboxcon.GuestSessionWaitResult_WaitFlagNotSupported):
+ return (reporter.error('Session did not start successfully - wait error: %d' % (eWaitResult,)), oTxsSession);
+ reporter.log('Session successfully started');
+
+ #
+ # Create a process.
+ #
+ # That process will also be used later to see if the session cleanup worked upon reboot.
+ #
+ sImage = self.oTstDrv.getGuestSystemShell(oTestVm);
+ asArgs = [ sImage, ];
+ aEnv = [];
+ afFlags = [];
+ try:
+ oGuestProcess = oGuestSession.processCreate(sImage,
+ asArgs if self.oTstDrv.fpApiVer >= 5.0 else asArgs[1:], aEnv, afFlags,
+ 30 * 1000);
+ except:
+ fRc = reporter.error('Failed to start shell process (%s)' % (sImage,));
+ else:
+ try:
+ eWaitResult = oGuestProcess.waitForArray([ vboxcon.ProcessWaitForFlag_Start ], 30 * 1000);
+ except:
+ fRc = reporter.errorXcpt('Waiting for shell process (%s) to start failed' % (sImage,));
+ else:
+ # Check the result and state:
+ try: eStatus = oGuestProcess.status;
+ except: fRc = reporter.errorXcpt('Waiting for shell process (%s) to start failed' % (sImage,));
+ else:
+ reporter.log2('Starting process wait result returned: %d; Process status is: %d' % (eWaitResult, eStatus,));
+ if eWaitResult != vboxcon.ProcessWaitResult_Start:
+ fRc = reporter.error('wait for ProcessWaitForFlag_Start failed: %d, expected %d (Start)'
+ % (eWaitResult, vboxcon.ProcessWaitResult_Start,));
+ elif eStatus != vboxcon.ProcessStatus_Started:
+ fRc = reporter.error('Unexpected process status after startup: %d, wanted %d (Started)'
+ % (eStatus, vboxcon.ProcessStatus_Started,));
+ else:
+ # Create a thread that waits on the process to terminate
+ reporter.log('Creating reboot thread ...');
+ oThreadReboot = threading.Thread(target = self.threadForTestGuestCtrlSessionReboot,
+ args = (oGuestProcess,),
+ name = ('threadForTestGuestCtrlSessionReboot'));
+ oThreadReboot.setDaemon(True); # pylint: disable=deprecated-method
+ oThreadReboot.start();
+
+ # Do the reboot.
+ reporter.log('Rebooting guest and reconnecting TXS ...');
+ (oSession, oTxsSession) = self.oTstDrv.txsRebootAndReconnectViaTcp(oSession, oTxsSession,
+ cMsTimeout = 3 * 60000);
+ if oSession \
+ and oTxsSession:
+ # Set reboot flag (needed later for session closing).
+ fRebooted = True;
+ else:
+ reporter.error('Rebooting via TXS failed');
+ try: oGuestProcess.terminate();
+ except: reporter.logXcpt();
+ fRc = False;
+
+ reporter.log('Waiting for thread to finish ...');
+ oThreadReboot.join();
+
+ # Check that the guest session now still has the formerly guest process object created above,
+ # but with the "down" status now (because of guest reboot).
+ try:
+ aoGuestProcs = self.oTstDrv.oVBoxMgr.getArray(oGuestSession, 'processes');
+ if len(aoGuestProcs) == 1:
+ enmProcSts = aoGuestProcs[0].status;
+ if enmProcSts != vboxcon.ProcessStatus_Down:
+ fRc = reporter.error('Old guest process (before reboot) has status %d, expected %s' \
+ % (enmProcSts, vboxcon.ProcessStatus_Down));
+ else:
+ fRc = reporter.error('Old guest session (before reboot) has %d processes registered, expected 1' \
+ % (len(aoGuestProcs)));
+ except:
+ fRc = reporter.errorXcpt();
+ #
+ # Try make sure we don't leave with a stale process on failure.
+ #
+ try: oGuestProcess.terminate();
+ except: reporter.logXcpt();
+
+ #
+ # Close the session.
+ #
+ reporter.log2('Closing guest session ...');
+ try:
+ oGuestSession.close();
+ except:
+ # Closing the guest session will fail when the guest reboot has been triggered,
+ # as the session object will be cleared on a guest reboot.
+ if fRebooted:
+ reporter.logXcpt('Closing guest session failed, good (guest rebooted)');
+ else: # ... otherwise this (still) should succeed. Report so if it doesn't.
+ reporter.errorXcpt('Closing guest session failed');
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlExecTimeout(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests handling of timeouts of started guest processes.
+ """
+
+ sShell = self.oTstDrv.getGuestSystemShell(oTestVm);
+
+ # Use credential defaults.
+ oCreds = tdCtxCreds();
+ oCreds.applyDefaultsIfNotSet(oTestVm);
+
+ #
+ # Create a session.
+ #
+ try:
+ oGuest = oSession.o.console.guest;
+ oGuestSession = oGuest.createSession(oCreds.sUser, oCreds.sPassword, oCreds.sDomain, "testGuestCtrlExecTimeout");
+ eWaitResult = oGuestSession.waitForArray([ vboxcon.GuestSessionWaitForFlag_Start, ], 30 * 1000);
+ except:
+ return (reporter.errorXcpt(), oTxsSession);
+
+ # Be nice to Guest Additions < 4.3: They don't support session handling and therefore return WaitFlagNotSupported.
+ if eWaitResult not in (vboxcon.GuestSessionWaitResult_Start, vboxcon.GuestSessionWaitResult_WaitFlagNotSupported):
+ return (reporter.error('Session did not start successfully - wait error: %d' % (eWaitResult,)), oTxsSession);
+ reporter.log('Session successfully started');
+
+ #
+ # Create a process which never terminates and should timeout when
+ # waiting for termination.
+ #
+ fRc = True;
+ try:
+ oCurProcess = oGuestSession.processCreate(sShell, [sShell,] if self.oTstDrv.fpApiVer >= 5.0 else [],
+ [], [], 30 * 1000);
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ reporter.log('Waiting for process 1 being started ...');
+ try:
+ eWaitResult = oCurProcess.waitForArray([ vboxcon.ProcessWaitForFlag_Start ], 30 * 1000);
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ if eWaitResult != vboxcon.ProcessWaitResult_Start:
+ fRc = reporter.error('Waiting for process 1 to start failed, got status %d' % (eWaitResult,));
+ else:
+ for msWait in (1, 32, 2000,):
+ reporter.log('Waiting for process 1 to time out within %sms ...' % (msWait,));
+ try:
+ eWaitResult = oCurProcess.waitForArray([ vboxcon.ProcessWaitForFlag_Terminate, ], msWait);
+ except:
+ fRc = reporter.errorXcpt();
+ break;
+ if eWaitResult != vboxcon.ProcessWaitResult_Timeout:
+ fRc = reporter.error('Waiting for process 1 did not time out in %sms as expected: %d'
+ % (msWait, eWaitResult,));
+ break;
+ reporter.log('Waiting for process 1 timed out in %u ms, good' % (msWait,));
+
+ try:
+ oCurProcess.terminate();
+ except:
+ reporter.errorXcpt();
+ oCurProcess = None;
+
+ #
+ # Create another process that doesn't terminate, but which will be killed by VBoxService
+ # because it ran out of execution time (3 seconds).
+ #
+ try:
+ oCurProcess = oGuestSession.processCreate(sShell, [sShell,] if self.oTstDrv.fpApiVer >= 5.0 else [],
+ [], [], 3 * 1000);
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ reporter.log('Waiting for process 2 being started ...');
+ try:
+ eWaitResult = oCurProcess.waitForArray([ vboxcon.ProcessWaitForFlag_Start ], 30 * 1000);
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ if eWaitResult != vboxcon.ProcessWaitResult_Start:
+ fRc = reporter.error('Waiting for process 2 to start failed, got status %d' % (eWaitResult,));
+ else:
+ reporter.log('Waiting for process 2 to get killed for running out of execution time ...');
+ try:
+ eWaitResult = oCurProcess.waitForArray([ vboxcon.ProcessWaitForFlag_Terminate, ], 15 * 1000);
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ if eWaitResult != vboxcon.ProcessWaitResult_Timeout:
+ fRc = reporter.error('Waiting for process 2 did not time out when it should, got wait result %d'
+ % (eWaitResult,));
+ else:
+ reporter.log('Waiting for process 2 did not time out, good: %s' % (eWaitResult,));
+ try:
+ eStatus = oCurProcess.status;
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ if eStatus != vboxcon.ProcessStatus_TimedOutKilled:
+ fRc = reporter.error('Status of process 2 wrong; excepted %d, got %d'
+ % (vboxcon.ProcessStatus_TimedOutKilled, eStatus));
+ else:
+ reporter.log('Status of process 2 is TimedOutKilled (%d) is it should be.'
+ % (vboxcon.ProcessStatus_TimedOutKilled,));
+ try:
+ oCurProcess.terminate();
+ except:
+ reporter.logXcpt();
+ oCurProcess = None;
+
+ #
+ # Clean up the session.
+ #
+ try:
+ oGuestSession.close();
+ except:
+ fRc = reporter.errorXcpt();
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlDirCreate(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests creation of guest directories.
+ """
+
+ sScratch = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), 'testGuestCtrlDirCreate');
+
+ atTests = [
+ # Invalid stuff.
+ [ tdTestDirCreate(sDirectory = '' ), tdTestResultFailure() ],
+ # More unusual stuff.
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin('..', '.') ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin('..', '..') ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = '..' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = '../' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = '../../' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = '/' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = '/..' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = '/../' ), tdTestResultFailure() ],
+ ];
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ atTests.extend([
+ [ tdTestDirCreate(sDirectory = 'C:\\' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = 'C:\\..' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = 'C:\\..\\' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = 'C:/' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = 'C:/.' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = 'C:/./' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = 'C:/..' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = 'C:/../' ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = '\\\\uncrulez\\foo' ), tdTestResultFailure() ],
+ ]);
+ atTests.extend([
+ # Existing directories and files.
+ [ tdTestDirCreate(sDirectory = self.oTstDrv.getGuestSystemDir(oTestVm) ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = self.oTstDrv.getGuestSystemShell(oTestVm) ), tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = self.oTstDrv.getGuestSystemFileForReading(oTestVm) ), tdTestResultFailure() ],
+ # Creating directories.
+ [ tdTestDirCreate(sDirectory = sScratch ), tdTestResultSuccess() ],
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, 'foo', 'bar', 'baz'),
+ afFlags = (vboxcon.DirectoryCreateFlag_Parents,) ), tdTestResultSuccess() ],
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, 'foo', 'bar', 'baz'),
+ afFlags = (vboxcon.DirectoryCreateFlag_Parents,) ), tdTestResultSuccess() ],
+ # Try format strings as directories.
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, 'foo%sbar%sbaz%d' )), tdTestResultSuccess() ],
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, '%f%%boo%%bar%RI32' )), tdTestResultSuccess() ],
+ # Long random names.
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, self.oTestFiles.generateFilenameEx(36, 28))),
+ tdTestResultSuccess() ],
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, self.oTestFiles.generateFilenameEx(140, 116))),
+ tdTestResultSuccess() ],
+ # Too long names. ASSUMES a guests has a 255 filename length limitation.
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, self.oTestFiles.generateFilenameEx(2048, 256))),
+ tdTestResultFailure() ],
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, self.oTestFiles.generateFilenameEx(2048, 256))),
+ tdTestResultFailure() ],
+ # Missing directory in path.
+ [ tdTestDirCreate(sDirectory = oTestVm.pathJoin(sScratch, 'foo1', 'bar') ), tdTestResultFailure() ],
+ ]);
+
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestDirCreate
+ oCurRes = tTest[1] # type: tdTestResult
+ reporter.log('Testing #%d, sDirectory="%s" ...' % (i, limitString(oCurTest.sDirectory)));
+
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, oCurGuestSession = oCurTest.createSession('testGuestCtrlDirCreate: Test #%d' % (i,));
+ if fRc is False:
+ return reporter.error('Test #%d failed: Could not create session' % (i,));
+
+ fRc = self.gctrlCreateDir(oCurTest, oCurRes, oCurGuestSession);
+
+ fRc = oCurTest.closeSession() and fRc;
+ if fRc is False:
+ fRc = reporter.error('Test #%d failed' % (i,));
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlDirCreateTemp(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests creation of temporary directories.
+ """
+
+ sSystemDir = self.oTstDrv.getGuestSystemDir(oTestVm);
+ atTests = [
+ # Invalid stuff (template must have one or more trailin 'X'es (upper case only), or a cluster of three or more).
+ [ tdTestDirCreateTemp(sDirectory = ''), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sDirectory = sSystemDir, fMode = 1234), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'xXx', sDirectory = sSystemDir, fMode = 0o700), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'xxx', sDirectory = sSystemDir, fMode = 0o700), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XXx', sDirectory = sSystemDir, fMode = 0o700), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'bar', sDirectory = 'whatever', fMode = 0o700), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'foo', sDirectory = 'it is not used', fMode = 0o700), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'X,so', sDirectory = 'pointless test', fMode = 0o700), tdTestResultFailure() ],
+ # Non-existing stuff.
+ [ tdTestDirCreateTemp(sTemplate = 'XXXXXXX',
+ sDirectory = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), 'non', 'existing')),
+ tdTestResultFailure() ],
+ # Working stuff:
+ [ tdTestDirCreateTemp(sTemplate = 'X', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm)), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm)), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XXX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm)), tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XXXXXXX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm)),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm)),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm)),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm)),
+ tdTestResultFailure() ],
+ ];
+
+ if self.oTstDrv.fpApiVer >= 7.0:
+ # Weird mode set.
+ atTests.extend([
+ [ tdTestDirCreateTemp(sTemplate = 'XXX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o42333),
+ tdTestResultFailure() ]
+ ]);
+ # Same as working stuff above, but with a different mode set.
+ atTests.extend([
+ [ tdTestDirCreateTemp(sTemplate = 'X', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o777),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o777),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XXX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o777),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XXXXXXX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o777),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o777),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o777),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fMode = 0o777),
+ tdTestResultFailure() ]
+ ]);
+ # Same as working stuff above, but with secure mode set.
+ atTests.extend([
+ [ tdTestDirCreateTemp(sTemplate = 'X', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fSecure = True),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fSecure = True),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XXX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fSecure = True),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'XXXXXXX', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm), fSecure = True),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm),
+ fSecure = True),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm),
+ fSecure = True),
+ tdTestResultFailure() ],
+ [ tdTestDirCreateTemp(sTemplate = 'tmpXXXtst', sDirectory = self.oTstDrv.getGuestTempDir(oTestVm),
+ fSecure = True),
+ tdTestResultFailure() ]
+ ]);
+
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestDirCreateTemp
+ oCurRes = tTest[1] # type: tdTestResult
+ reporter.log('Testing #%d, sTemplate="%s", fMode=%#o, path="%s", secure="%s" ...' %
+ (i, oCurTest.sTemplate, oCurTest.fMode, oCurTest.sDirectory, oCurTest.fSecure));
+
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, oCurGuestSession = oCurTest.createSession('testGuestCtrlDirCreateTemp: Test #%d' % (i,));
+ if fRc is False:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ sDirTemp = '';
+ try:
+ sDirTemp = oCurGuestSession.directoryCreateTemp(oCurTest.sTemplate, oCurTest.fMode,
+ oCurTest.sDirectory, oCurTest.fSecure);
+ except:
+ if oCurRes.fRc is True:
+ fRc = reporter.errorXcpt('Creating temp directory "%s" failed:' % (oCurTest.sDirectory,));
+ else:
+ reporter.logXcpt('Creating temp directory "%s" failed expectedly, skipping:' % (oCurTest.sDirectory,));
+ else:
+ reporter.log2('Temporary directory is: "%s"' % (limitString(sDirTemp),));
+ if not sDirTemp:
+ fRc = reporter.error('Resulting directory is empty!');
+ else:
+ ## @todo This does not work for some unknown reason.
+ #try:
+ # if self.oTstDrv.fpApiVer >= 5.0:
+ # fExists = oCurGuestSession.directoryExists(sDirTemp, False);
+ # else:
+ # fExists = oCurGuestSession.directoryExists(sDirTemp);
+ #except:
+ # fRc = reporter.errorXcpt('sDirTemp=%s' % (sDirTemp,));
+ #else:
+ # if fExists is not True:
+ # fRc = reporter.error('Test #%d failed: Temporary directory "%s" does not exists (%s)'
+ # % (i, sDirTemp, fExists));
+ try:
+ oFsObjInfo = oCurGuestSession.fsObjQueryInfo(sDirTemp, False);
+ eType = oFsObjInfo.type;
+ except:
+ fRc = reporter.errorXcpt('sDirTemp="%s"' % (sDirTemp,));
+ else:
+ reporter.log2('%s: eType=%s (dir=%d)' % (limitString(sDirTemp), eType, vboxcon.FsObjType_Directory,));
+ if eType != vboxcon.FsObjType_Directory:
+ fRc = reporter.error('Temporary directory "%s" not created as a directory: eType=%d'
+ % (sDirTemp, eType));
+ fRc = oCurTest.closeSession() and fRc;
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlDirRead(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests opening and reading (enumerating) guest directories.
+ """
+
+ sSystemDir = self.oTstDrv.getGuestSystemDir(oTestVm);
+ atTests = [
+ # Invalid stuff.
+ [ tdTestDirRead(sDirectory = ''), tdTestResultDirRead() ],
+ [ tdTestDirRead(sDirectory = sSystemDir, afFlags = [ 1234 ]), tdTestResultDirRead() ],
+ [ tdTestDirRead(sDirectory = sSystemDir, sFilter = '*.foo'), tdTestResultDirRead() ],
+ # Non-existing stuff.
+ [ tdTestDirRead(sDirectory = oTestVm.pathJoin(sSystemDir, 'really-no-such-subdir')), tdTestResultDirRead() ],
+ [ tdTestDirRead(sDirectory = oTestVm.pathJoin(sSystemDir, 'non', 'existing')), tdTestResultDirRead() ],
+ ];
+
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ atTests.extend([
+ # More unusual stuff.
+ [ tdTestDirRead(sDirectory = 'z:\\'), tdTestResultDirRead() ],
+ [ tdTestDirRead(sDirectory = '\\\\uncrulez\\foo'), tdTestResultDirRead() ],
+ ]);
+
+ # Read the system directory (ASSUMES at least 5 files in it):
+ # Windows 7+ has inaccessible system32/com/dmp directory that screws up this test, so skip it on windows:
+ if not oTestVm.isWindows():
+ atTests.append([ tdTestDirRead(sDirectory = sSystemDir),
+ tdTestResultDirRead(fRc = True, cFiles = -5, cDirs = None) ]);
+ ## @todo trailing slash
+
+ # Read from the test file set.
+ atTests.extend([
+ [ tdTestDirRead(sDirectory = self.oTestFiles.oEmptyDir.sPath),
+ tdTestResultDirRead(fRc = True, cFiles = 0, cDirs = 0, cOthers = 0) ],
+ [ tdTestDirRead(sDirectory = self.oTestFiles.oManyDir.sPath),
+ tdTestResultDirRead(fRc = True, cFiles = len(self.oTestFiles.oManyDir.aoChildren), cDirs = 0, cOthers = 0) ],
+ [ tdTestDirRead(sDirectory = self.oTestFiles.oTreeDir.sPath),
+ tdTestResultDirRead(fRc = True, cFiles = self.oTestFiles.cTreeFiles, cDirs = self.oTestFiles.cTreeDirs,
+ cOthers = self.oTestFiles.cTreeOthers) ],
+ ]);
+
+
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestExec
+ oCurRes = tTest[1] # type: tdTestResultDirRead
+
+ reporter.log('Testing #%d, dir="%s" ...' % (i, oCurTest.sDirectory));
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, oCurGuestSession = oCurTest.createSession('testGuestCtrlDirRead: Test #%d' % (i,));
+ if fRc is not True:
+ break;
+ (fRc2, cDirs, cFiles, cOthers) = self.gctrlReadDirTree(oCurTest, oCurGuestSession, oCurRes.fRc);
+ fRc = oCurTest.closeSession() and fRc;
+
+ reporter.log2('Test #%d: Returned %d directories, %d files total' % (i, cDirs, cFiles));
+ if fRc2 is oCurRes.fRc:
+ if fRc2 is True:
+ if oCurRes.cFiles is None:
+ pass; # ignore
+ elif oCurRes.cFiles >= 0 and cFiles != oCurRes.cFiles:
+ fRc = reporter.error('Test #%d failed: Got %d files, expected %d' % (i, cFiles, oCurRes.cFiles));
+ elif oCurRes.cFiles < 0 and cFiles < -oCurRes.cFiles:
+ fRc = reporter.error('Test #%d failed: Got %d files, expected at least %d'
+ % (i, cFiles, -oCurRes.cFiles));
+ if oCurRes.cDirs is None:
+ pass; # ignore
+ elif oCurRes.cDirs >= 0 and cDirs != oCurRes.cDirs:
+ fRc = reporter.error('Test #%d failed: Got %d directories, expected %d' % (i, cDirs, oCurRes.cDirs));
+ elif oCurRes.cDirs < 0 and cDirs < -oCurRes.cDirs:
+ fRc = reporter.error('Test #%d failed: Got %d directories, expected at least %d'
+ % (i, cDirs, -oCurRes.cDirs));
+ if oCurRes.cOthers is None:
+ pass; # ignore
+ elif oCurRes.cOthers >= 0 and cOthers != oCurRes.cOthers:
+ fRc = reporter.error('Test #%d failed: Got %d other types, expected %d' % (i, cOthers, oCurRes.cOthers));
+ elif oCurRes.cOthers < 0 and cOthers < -oCurRes.cOthers:
+ fRc = reporter.error('Test #%d failed: Got %d other types, expected at least %d'
+ % (i, cOthers, -oCurRes.cOthers));
+
+ else:
+ fRc = reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc2, oCurRes.fRc));
+
+
+ #
+ # Go over a few directories in the test file set and compare names,
+ # types and sizes rather than just the counts like we did above.
+ #
+ if fRc is True:
+ oCurTest = tdTestDirRead();
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if fRc:
+ fRc, oCurGuestSession = oCurTest.createSession('testGuestCtrlDirRead: gctrlReadDirTree2');
+ if fRc is True:
+ for oDir in (self.oTestFiles.oEmptyDir, self.oTestFiles.oManyDir, self.oTestFiles.oTreeDir):
+ reporter.log('Checking "%s" ...' % (oDir.sPath,));
+ fRc = self.gctrlReadDirTree2(oCurGuestSession, oDir) and fRc;
+ fRc = oCurTest.closeSession() and fRc;
+
+ return (fRc, oTxsSession);
+
+
+ def testGuestCtrlFileRemove(self, oSession, oTxsSession, oTestVm):
+ """
+ Tests removing guest files.
+ """
+
+ #
+ # Create a directory with a few files in it using TXS that we'll use for the initial tests.
+ #
+ asTestDirs = [
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-1'), # [0]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-1', 'subdir-1'), # [1]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-1', 'subdir-1', 'subsubdir-1'), # [2]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-2'), # [3]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-2', 'subdir-2'), # [4]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-2', 'subdir-2', 'subsbudir-2'), # [5]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-3'), # [6]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-4'), # [7]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-5'), # [8]
+ oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'rmtestdir-5', 'subdir-5'), # [9]
+ ]
+ asTestFiles = [
+ oTestVm.pathJoin(asTestDirs[0], 'file-0'), # [0]
+ oTestVm.pathJoin(asTestDirs[0], 'file-1'), # [1]
+ oTestVm.pathJoin(asTestDirs[0], 'file-2'), # [2]
+ oTestVm.pathJoin(asTestDirs[1], 'file-3'), # [3] - subdir-1
+ oTestVm.pathJoin(asTestDirs[1], 'file-4'), # [4] - subdir-1
+ oTestVm.pathJoin(asTestDirs[2], 'file-5'), # [5] - subsubdir-1
+ oTestVm.pathJoin(asTestDirs[3], 'file-6'), # [6] - rmtestdir-2
+ oTestVm.pathJoin(asTestDirs[4], 'file-7'), # [7] - subdir-2
+ oTestVm.pathJoin(asTestDirs[5], 'file-8'), # [8] - subsubdir-2
+ ];
+ for sDir in asTestDirs:
+ if oTxsSession.syncMkDir(sDir, 0o777) is not True:
+ return reporter.error('Failed to create test dir "%s"!' % (sDir,));
+ for sFile in asTestFiles:
+ if oTxsSession.syncUploadString(sFile, sFile, 0o666) is not True:
+ return reporter.error('Failed to create test file "%s"!' % (sFile,));
+
+ #
+ # Tear down the directories and files.
+ #
+ aoTests = [
+ # Negative tests first:
+ tdTestRemoveFile(asTestDirs[0], fRcExpect = False),
+ tdTestRemoveDir(asTestDirs[0], fRcExpect = False),
+ tdTestRemoveDir(asTestFiles[0], fRcExpect = False),
+ tdTestRemoveFile(oTestVm.pathJoin(self.oTestFiles.oEmptyDir.sPath, 'no-such-file'), fRcExpect = False),
+ tdTestRemoveDir(oTestVm.pathJoin(self.oTestFiles.oEmptyDir.sPath, 'no-such-dir'), fRcExpect = False),
+ tdTestRemoveFile(oTestVm.pathJoin(self.oTestFiles.oEmptyDir.sPath, 'no-such-dir', 'no-file'), fRcExpect = False),
+ tdTestRemoveDir(oTestVm.pathJoin(self.oTestFiles.oEmptyDir.sPath, 'no-such-dir', 'no-subdir'), fRcExpect = False),
+ tdTestRemoveTree(asTestDirs[0], afFlags = [], fRcExpect = False), # Only removes empty dirs, this isn't empty.
+ tdTestRemoveTree(asTestDirs[0], afFlags = [vboxcon.DirectoryRemoveRecFlag_None,], fRcExpect = False), # ditto
+ # Empty paths:
+ tdTestRemoveFile('', fRcExpect = False),
+ tdTestRemoveDir('', fRcExpect = False),
+ tdTestRemoveTree('', fRcExpect = False),
+ # Now actually remove stuff:
+ tdTestRemoveDir(asTestDirs[7], fRcExpect = True),
+ tdTestRemoveFile(asTestDirs[6], fRcExpect = False),
+ tdTestRemoveDir(asTestDirs[6], fRcExpect = True),
+ tdTestRemoveFile(asTestFiles[0], fRcExpect = True),
+ tdTestRemoveFile(asTestFiles[0], fRcExpect = False),
+ # 17:
+ tdTestRemoveTree(asTestDirs[8], fRcExpect = True), # Removes empty subdirs and leaves the dir itself.
+ tdTestRemoveDir(asTestDirs[8], fRcExpect = True),
+ tdTestRemoveTree(asTestDirs[3], fRcExpect = False), # Have subdirs & files,
+ tdTestRemoveTree(asTestDirs[3], afFlags = [vboxcon.DirectoryRemoveRecFlag_ContentOnly,], fRcExpect = True),
+ tdTestRemoveDir(asTestDirs[3], fRcExpect = True),
+ tdTestRemoveTree(asTestDirs[0], afFlags = [vboxcon.DirectoryRemoveRecFlag_ContentAndDir,], fRcExpect = True),
+ # No error if already delete (RTDirRemoveRecursive artifact).
+ tdTestRemoveTree(asTestDirs[0], afFlags = [vboxcon.DirectoryRemoveRecFlag_ContentAndDir,], fRcExpect = True),
+ tdTestRemoveTree(asTestDirs[0], afFlags = [vboxcon.DirectoryRemoveRecFlag_ContentOnly,],
+ fNotExist = True, fRcExpect = True),
+ tdTestRemoveTree(asTestDirs[0], afFlags = [vboxcon.DirectoryRemoveRecFlag_None,], fNotExist = True, fRcExpect = True),
+ ];
+
+ #
+ # Execution loop
+ #
+ fRc = True;
+ for (i, oTest) in enumerate(aoTests): # int, tdTestRemoveBase
+ reporter.log('Testing #%d, path="%s" %s ...' % (i, oTest.sPath, oTest.__class__.__name__));
+ fRc = oTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, _ = oTest.createSession('testGuestCtrlFileRemove: Test #%d' % (i,));
+ if fRc is False:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+ fRc = oTest.execute(self) and fRc;
+ fRc = oTest.closeSession() and fRc;
+
+ if fRc is True:
+ oCurTest = tdTestDirRead();
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if fRc:
+ fRc, oCurGuestSession = oCurTest.createSession('remove final');
+ if fRc is True:
+
+ #
+ # Delete all the files in the many subdir of the test set.
+ #
+ reporter.log('Deleting the file in "%s" ...' % (self.oTestFiles.oManyDir.sPath,));
+ for oFile in self.oTestFiles.oManyDir.aoChildren:
+ reporter.log2('"%s"' % (limitString(oFile.sPath),));
+ try:
+ if self.oTstDrv.fpApiVer >= 5.0:
+ oCurGuestSession.fsObjRemove(oFile.sPath);
+ else:
+ oCurGuestSession.fileRemove(oFile.sPath);
+ except:
+ fRc = reporter.errorXcpt('Removing "%s" failed' % (oFile.sPath,));
+
+ # Remove the directory itself to verify that we've removed all the files in it:
+ reporter.log('Removing the directory "%s" ...' % (self.oTestFiles.oManyDir.sPath,));
+ try:
+ oCurGuestSession.directoryRemove(self.oTestFiles.oManyDir.sPath);
+ except:
+ fRc = reporter.errorXcpt('Removing directory "%s" failed' % (self.oTestFiles.oManyDir.sPath,));
+
+ #
+ # Recursively delete the entire test file tree from the root up.
+ #
+ # Note! On unix we cannot delete the root dir itself since it is residing
+ # in /var/tmp where only the owner may delete it. Root is the owner.
+ #
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ afFlags = [vboxcon.DirectoryRemoveRecFlag_ContentAndDir,];
+ else:
+ afFlags = [vboxcon.DirectoryRemoveRecFlag_ContentOnly,];
+ try:
+ oProgress = oCurGuestSession.directoryRemoveRecursive(self.oTestFiles.oRoot.sPath, afFlags);
+ except:
+ fRc = reporter.errorXcpt('Removing tree "%s" failed' % (self.oTestFiles.oRoot.sPath,));
+ else:
+ oWrappedProgress = vboxwrappers.ProgressWrapper(oProgress, self.oTstDrv.oVBoxMgr, self.oTstDrv,
+ "remove-tree-root: %s" % (self.oTestFiles.oRoot.sPath,));
+ reporter.log2('waiting ...')
+ oWrappedProgress.wait();
+ reporter.log2('isSuccess=%s' % (oWrappedProgress.isSuccess(),));
+ if not oWrappedProgress.isSuccess():
+ fRc = oWrappedProgress.logResult();
+
+ fRc = oCurTest.closeSession() and fRc;
+
+ return (fRc, oTxsSession);
+
+
+ def testGuestCtrlFileStat(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests querying file information through stat.
+ """
+
+ # Basic stuff, existing stuff.
+ aoTests = [
+ tdTestSessionEx([
+ tdStepStatDir('.'),
+ tdStepStatDir('..'),
+ tdStepStatDir(self.oTstDrv.getGuestTempDir(oTestVm)),
+ tdStepStatDir(self.oTstDrv.getGuestSystemDir(oTestVm)),
+ tdStepStatDirEx(self.oTestFiles.oRoot),
+ tdStepStatDirEx(self.oTestFiles.oEmptyDir),
+ tdStepStatDirEx(self.oTestFiles.oTreeDir),
+ tdStepStatDirEx(self.oTestFiles.chooseRandomDirFromTree()),
+ tdStepStatDirEx(self.oTestFiles.chooseRandomDirFromTree()),
+ tdStepStatDirEx(self.oTestFiles.chooseRandomDirFromTree()),
+ tdStepStatDirEx(self.oTestFiles.chooseRandomDirFromTree()),
+ tdStepStatDirEx(self.oTestFiles.chooseRandomDirFromTree()),
+ tdStepStatDirEx(self.oTestFiles.chooseRandomDirFromTree()),
+ tdStepStatFile(self.oTstDrv.getGuestSystemFileForReading(oTestVm)),
+ tdStepStatFile(self.oTstDrv.getGuestSystemShell(oTestVm)),
+ tdStepStatFileEx(self.oTestFiles.chooseRandomFile()),
+ tdStepStatFileEx(self.oTestFiles.chooseRandomFile()),
+ tdStepStatFileEx(self.oTestFiles.chooseRandomFile()),
+ tdStepStatFileEx(self.oTestFiles.chooseRandomFile()),
+ tdStepStatFileEx(self.oTestFiles.chooseRandomFile()),
+ tdStepStatFileEx(self.oTestFiles.chooseRandomFile()),
+ ]),
+ ];
+
+ # None existing stuff.
+ sSysDir = self.oTstDrv.getGuestSystemDir(oTestVm);
+ sSep = oTestVm.pathSep();
+ aoTests += [
+ tdTestSessionEx([
+ tdStepStatFileNotFound(oTestVm.pathJoin(sSysDir, 'NoSuchFileOrDirectory')),
+ tdStepStatPathNotFound(oTestVm.pathJoin(sSysDir, 'NoSuchFileOrDirectory') + sSep),
+ tdStepStatPathNotFound(oTestVm.pathJoin(sSysDir, 'NoSuchFileOrDirectory', '.')),
+ tdStepStatPathNotFound(oTestVm.pathJoin(sSysDir, 'NoSuchFileOrDirectory', 'NoSuchFileOrSubDirectory')),
+ tdStepStatPathNotFound(oTestVm.pathJoin(sSysDir, 'NoSuchFileOrDirectory', 'NoSuchFileOrSubDirectory') + sSep),
+ tdStepStatPathNotFound(oTestVm.pathJoin(sSysDir, 'NoSuchFileOrDirectory', 'NoSuchFileOrSubDirectory', '.')),
+ #tdStepStatPathNotFound('N:\\'), # ASSUMES nothing mounted on N:!
+ #tdStepStatPathNotFound('\\\\NoSuchUncServerName\\NoSuchShare'),
+ ]),
+ ];
+ # Invalid parameter check.
+ aoTests += [ tdTestSessionEx([ tdStepStat('', vbox.ComError.E_INVALIDARG), ]), ];
+
+ #
+ # Execute the tests.
+ #
+ fRc, oTxsSession = tdTestSessionEx.executeListTestSessions(aoTests, self.oTstDrv, oSession, oTxsSession,
+ oTestVm, 'FsStat');
+ #
+ # Test the full test file set.
+ #
+ if self.oTstDrv.fpApiVer < 5.0:
+ return (fRc, oTxsSession);
+
+ oTest = tdTestGuestCtrlBase();
+ fRc = oTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ return (False, oTxsSession);
+ fRc2, oGuestSession = oTest.createSession('FsStat on TestFileSet');
+ if fRc2 is not True:
+ return (False, oTxsSession);
+
+ for oFsObj in self.oTestFiles.dPaths.values():
+ reporter.log2('testGuestCtrlFileStat: %s sPath=%s'
+ % ('file' if isinstance(oFsObj, testfileset.TestFile) else 'dir ', limitString(oFsObj.sPath),));
+
+ # Query the information:
+ try:
+ oFsInfo = oGuestSession.fsObjQueryInfo(oFsObj.sPath, False);
+ except:
+ fRc = reporter.errorXcpt('sPath=%s type=%s: fsObjQueryInfo trouble!' % (oFsObj.sPath, type(oFsObj),));
+ continue;
+ if oFsInfo is None:
+ fRc = reporter.error('sPath=%s type=%s: No info object returned!' % (oFsObj.sPath, type(oFsObj),));
+ continue;
+
+ # Check attributes:
+ try:
+ eType = oFsInfo.type;
+ cbObject = oFsInfo.objectSize;
+ except:
+ fRc = reporter.errorXcpt('sPath=%s type=%s: attribute access trouble!' % (oFsObj.sPath, type(oFsObj),));
+ continue;
+
+ if isinstance(oFsObj, testfileset.TestFile):
+ if eType != vboxcon.FsObjType_File:
+ fRc = reporter.error('sPath=%s type=file: eType=%s, expected %s!'
+ % (oFsObj.sPath, eType, vboxcon.FsObjType_File));
+ if cbObject != oFsObj.cbContent:
+ fRc = reporter.error('sPath=%s type=file: cbObject=%s, expected %s!'
+ % (oFsObj.sPath, cbObject, oFsObj.cbContent));
+ fFileExists = True;
+ fDirExists = False;
+ elif isinstance(oFsObj, testfileset.TestDir):
+ if eType != vboxcon.FsObjType_Directory:
+ fRc = reporter.error('sPath=%s type=dir: eType=%s, expected %s!'
+ % (oFsObj.sPath, eType, vboxcon.FsObjType_Directory));
+ fFileExists = False;
+ fDirExists = True;
+ else:
+ fRc = reporter.error('sPath=%s type=%s: Unexpected oFsObj type!' % (oFsObj.sPath, type(oFsObj),));
+ continue;
+
+ # Check the directoryExists and fileExists results too.
+ try:
+ fExistsResult = oGuestSession.fileExists(oFsObj.sPath, False);
+ except:
+ fRc = reporter.errorXcpt('sPath=%s type=%s: fileExists trouble!' % (oFsObj.sPath, type(oFsObj),));
+ else:
+ if fExistsResult != fFileExists:
+ fRc = reporter.error('sPath=%s type=%s: fileExists returned %s, expected %s!'
+ % (oFsObj.sPath, type(oFsObj), fExistsResult, fFileExists));
+ try:
+ fExistsResult = oGuestSession.directoryExists(oFsObj.sPath, False);
+ except:
+ fRc = reporter.errorXcpt('sPath=%s type=%s: directoryExists trouble!' % (oFsObj.sPath, type(oFsObj),));
+ else:
+ if fExistsResult != fDirExists:
+ fRc = reporter.error('sPath=%s type=%s: directoryExists returned %s, expected %s!'
+ % (oFsObj.sPath, type(oFsObj), fExistsResult, fDirExists));
+
+ fRc = oTest.closeSession() and fRc;
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlFileOpen(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests opening guest files.
+ """
+ if self.oTstDrv.fpApiVer < 5.0:
+ reporter.log('Skipping because of pre 5.0 API');
+ return None;
+
+ #
+ # Paths.
+ #
+ sTempDir = self.oTstDrv.getGuestTempDir(oTestVm);
+ sFileForReading = self.oTstDrv.getGuestSystemFileForReading(oTestVm);
+ asFiles = [
+ oTestVm.pathJoin(sTempDir, 'file-open-0'),
+ oTestVm.pathJoin(sTempDir, 'file-open-1'),
+ oTestVm.pathJoin(sTempDir, 'file-open-2'),
+ oTestVm.pathJoin(sTempDir, 'file-open-3'),
+ oTestVm.pathJoin(sTempDir, 'file-open-4'),
+ ];
+ asNonEmptyFiles = [
+ oTestVm.pathJoin(sTempDir, 'file-open-10'),
+ oTestVm.pathJoin(sTempDir, 'file-open-11'),
+ oTestVm.pathJoin(sTempDir, 'file-open-12'),
+ oTestVm.pathJoin(sTempDir, 'file-open-13'),
+ ];
+ sContent = 'abcdefghijklmnopqrstuvwxyz0123456789';
+ for sFile in asNonEmptyFiles:
+ if oTxsSession.syncUploadString(sContent, sFile, 0o666) is not True:
+ return reporter.error('Failed to create "%s" via TXS' % (sFile,));
+
+ #
+ # The tests.
+ #
+ atTests = [
+ # Invalid stuff.
+ [ tdTestFileOpen(sFile = ''), tdTestResultFailure() ],
+ # Wrong open mode.
+ [ tdTestFileOpen(sFile = sFileForReading, eAccessMode = -1), tdTestResultFailure() ],
+ # Wrong disposition.
+ [ tdTestFileOpen(sFile = sFileForReading, eAction = -1), tdTestResultFailure() ],
+ # Non-existing file or path.
+ [ tdTestFileOpen(sFile = oTestVm.pathJoin(sTempDir, 'no-such-file-or-dir')), tdTestResultFailure() ],
+ [ tdTestFileOpen(sFile = oTestVm.pathJoin(sTempDir, 'no-such-file-or-dir'),
+ eAction = vboxcon.FileOpenAction_OpenExistingTruncated), tdTestResultFailure() ],
+ [ tdTestFileOpen(sFile = oTestVm.pathJoin(sTempDir, 'no-such-file-or-dir'),
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly,
+ eAction = vboxcon.FileOpenAction_OpenExistingTruncated), tdTestResultFailure() ],
+ [ tdTestFileOpen(sFile = oTestVm.pathJoin(sTempDir, 'no-such-file-or-dir'),
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite,
+ eAction = vboxcon.FileOpenAction_OpenExistingTruncated), tdTestResultFailure() ],
+ [ tdTestFileOpen(sFile = oTestVm.pathJoin(sTempDir, 'no-such-dir', 'no-such-file')), tdTestResultFailure() ],
+ ];
+ if self.oTstDrv.fpApiVer > 5.2: # Fixed since 6.0.
+ atTests.extend([
+ # Wrong type:
+ [ tdTestFileOpen(sFile = self.oTstDrv.getGuestTempDir(oTestVm)), tdTestResultFailure() ],
+ [ tdTestFileOpen(sFile = self.oTstDrv.getGuestSystemDir(oTestVm)), tdTestResultFailure() ],
+ ]);
+ atTests.extend([
+ # O_EXCL and such:
+ [ tdTestFileOpen(sFile = sFileForReading, eAction = vboxcon.FileOpenAction_CreateNew,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultFailure() ],
+ [ tdTestFileOpen(sFile = sFileForReading, eAction = vboxcon.FileOpenAction_CreateNew), tdTestResultFailure() ],
+ # Open a file.
+ [ tdTestFileOpen(sFile = sFileForReading), tdTestResultSuccess() ],
+ [ tdTestFileOpen(sFile = sFileForReading,
+ eAction = vboxcon.FileOpenAction_OpenOrCreate), tdTestResultSuccess() ],
+ # Create a new file.
+ [ tdTestFileOpenCheckSize(sFile = asFiles[0], eAction = vboxcon.FileOpenAction_CreateNew,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asFiles[0], eAction = vboxcon.FileOpenAction_CreateNew,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultFailure() ],
+ [ tdTestFileOpenCheckSize(sFile = asFiles[0], eAction = vboxcon.FileOpenAction_OpenExisting,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asFiles[0], eAction = vboxcon.FileOpenAction_CreateOrReplace,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asFiles[0], eAction = vboxcon.FileOpenAction_OpenOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asFiles[0], eAction = vboxcon.FileOpenAction_OpenExistingTruncated,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asFiles[0], eAction = vboxcon.FileOpenAction_AppendOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ # Open or create a new file.
+ [ tdTestFileOpenCheckSize(sFile = asFiles[1], eAction = vboxcon.FileOpenAction_OpenOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ # Create or replace a new file.
+ [ tdTestFileOpenCheckSize(sFile = asFiles[2], eAction = vboxcon.FileOpenAction_CreateOrReplace,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ # Create and append to file (weird stuff).
+ [ tdTestFileOpenCheckSize(sFile = asFiles[3], eAction = vboxcon.FileOpenAction_AppendOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asFiles[4], eAction = vboxcon.FileOpenAction_AppendOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly), tdTestResultSuccess() ],
+ # Open the non-empty files in non-destructive modes.
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[0], cbOpenExpected = len(sContent)), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[1], cbOpenExpected = len(sContent),
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[2], cbOpenExpected = len(sContent),
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly), tdTestResultSuccess() ],
+
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[0], cbOpenExpected = len(sContent),
+ eAction = vboxcon.FileOpenAction_OpenOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[1], cbOpenExpected = len(sContent),
+ eAction = vboxcon.FileOpenAction_OpenOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[2], cbOpenExpected = len(sContent),
+ eAction = vboxcon.FileOpenAction_OpenOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly), tdTestResultSuccess() ],
+
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[0], cbOpenExpected = len(sContent),
+ eAction = vboxcon.FileOpenAction_AppendOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_ReadWrite), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[1], cbOpenExpected = len(sContent),
+ eAction = vboxcon.FileOpenAction_AppendOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[2], cbOpenExpected = len(sContent),
+ eAction = vboxcon.FileOpenAction_AppendOrCreate,
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly), tdTestResultSuccess() ],
+
+ # Now the destructive stuff:
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[0], eAccessMode = vboxcon.FileAccessMode_WriteOnly,
+ eAction = vboxcon.FileOpenAction_OpenExistingTruncated), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[1], eAccessMode = vboxcon.FileAccessMode_WriteOnly,
+ eAction = vboxcon.FileOpenAction_CreateOrReplace), tdTestResultSuccess() ],
+ [ tdTestFileOpenCheckSize(sFile = asNonEmptyFiles[2], eAction = vboxcon.FileOpenAction_CreateOrReplace,
+ eAccessMode = vboxcon.FileAccessMode_WriteOnly), tdTestResultSuccess() ],
+ ]);
+
+ #
+ # Do the testing.
+ #
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestFileOpen
+ oCurRes = tTest[1] # type: tdTestResult
+
+ reporter.log('Testing #%d: %s - sFile="%s", eAccessMode=%d, eAction=%d, (%s, %s, %s) ...'
+ % (i, oCurTest.__class__.__name__, oCurTest.sFile, oCurTest.eAccessMode, oCurTest.eAction,
+ oCurTest.eSharing, oCurTest.fCreationMode, oCurTest.afOpenFlags,));
+
+ oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, _ = oCurTest.createSession('testGuestCtrlFileOpen: Test #%d' % (i,));
+ if fRc is not True:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ fRc2 = oCurTest.doSteps(oCurRes.fRc, self);
+ if fRc2 != oCurRes.fRc:
+ fRc = reporter.error('Test #%d result mismatch: Got %s, expected %s' % (i, fRc2, oCurRes.fRc,));
+
+ fRc = oCurTest.closeSession() and fRc;
+
+ return (fRc, oTxsSession);
+
+
+ def testGuestCtrlFileRead(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-branches,too-many-statements
+ """
+ Tests reading from guest files.
+ """
+ if self.oTstDrv.fpApiVer < 5.0:
+ reporter.log('Skipping because of pre 5.0 API');
+ return None;
+
+ #
+ # Do everything in one session.
+ #
+ oTest = tdTestGuestCtrlBase();
+ fRc = oTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ return (False, oTxsSession);
+ fRc2, oGuestSession = oTest.createSession('FsStat on TestFileSet');
+ if fRc2 is not True:
+ return (False, oTxsSession);
+
+ #
+ # Create a really big zero filled, up to 1 GiB, adding it to the list of
+ # files from the set.
+ #
+ # Note! This code sucks a bit because we don't have a working setSize nor
+ # any way to figure out how much free space there is in the guest.
+ #
+ aoExtraFiles = [];
+ sBigName = self.oTestFiles.generateFilenameEx();
+ sBigPath = oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, sBigName);
+ fRc = True;
+ try:
+ oFile = oGuestSession.fileOpenEx(sBigPath, vboxcon.FileAccessMode_ReadWrite, vboxcon.FileOpenAction_CreateOrReplace,
+ vboxcon.FileSharingMode_All, 0, []);
+ except:
+ fRc = reporter.errorXcpt('sBigName=%s' % (sBigPath,));
+ else:
+ # Does setSize work now?
+ fUseFallback = True;
+ try:
+ oFile.setSize(0);
+ oFile.setSize(64);
+ fUseFallback = False;
+ except:
+ reporter.logXcpt();
+
+ # Grow the file till we hit trouble, typical VERR_DISK_FULL, then
+ # reduce the file size if we have a working setSize.
+ cbBigFile = 0;
+ while cbBigFile < (1024 + 32)*1024*1024:
+ if not fUseFallback:
+ cbBigFile += 16*1024*1024;
+ try:
+ oFile.setSize(cbBigFile);
+ except Exception:
+ reporter.logXcpt('cbBigFile=%s' % (sBigPath,));
+ try:
+ cbBigFile -= 16*1024*1024;
+ oFile.setSize(cbBigFile);
+ except:
+ reporter.logXcpt('cbBigFile=%s' % (sBigPath,));
+ break;
+ else:
+ cbBigFile += 32*1024*1024;
+ try:
+ oFile.seek(cbBigFile, vboxcon.FileSeekOrigin_Begin);
+ oFile.write(bytearray(1), 60*1000);
+ except:
+ reporter.logXcpt('cbBigFile=%s' % (sBigPath,));
+ break;
+ try:
+ cbBigFile = oFile.seek(0, vboxcon.FileSeekOrigin_End);
+ except:
+ fRc = reporter.errorXcpt('sBigName=%s' % (sBigPath,));
+ try:
+ oFile.close();
+ except:
+ fRc = reporter.errorXcpt('sBigName=%s' % (sBigPath,));
+ if fRc is True:
+ reporter.log('Big file: %s bytes: %s' % (cbBigFile, sBigPath,));
+ aoExtraFiles.append(testfileset.TestFileZeroFilled(None, sBigPath, cbBigFile));
+ else:
+ try:
+ oGuestSession.fsObjRemove(sBigPath);
+ except:
+ reporter.errorXcpt('fsObjRemove(sBigName=%s)' % (sBigPath,));
+
+ #
+ # Open and read all the files in the test file set.
+ #
+ for oTestFile in aoExtraFiles + self.oTestFiles.aoFiles: # type: testfileset.TestFile
+ reporter.log2('Test file: %s bytes, "%s" ...' % (oTestFile.cbContent, limitString(oTestFile.sPath),));
+
+ #
+ # Open it:
+ #
+ try:
+ oFile = oGuestSession.fileOpenEx(oTestFile.sPath, vboxcon.FileAccessMode_ReadOnly,
+ vboxcon.FileOpenAction_OpenExisting, vboxcon.FileSharingMode_All, 0, []);
+ except:
+ fRc = reporter.errorXcpt('sPath=%s' % (oTestFile.sPath, ));
+ continue;
+
+ #
+ # Read the file in different sized chunks:
+ #
+ if oTestFile.cbContent < 128:
+ acbChunks = xrange(1,128);
+ elif oTestFile.cbContent < 1024:
+ acbChunks = (2048, 127, 63, 32, 29, 17, 16, 15, 9);
+ elif oTestFile.cbContent < 8*1024*1024:
+ acbChunks = (128*1024, 32*1024, 8191, 255);
+ else:
+ acbChunks = (768*1024, 128*1024);
+
+ reporter.log2('Chunked reads');
+
+ for cbChunk in acbChunks:
+ # Read the whole file straight thru:
+ #if oTestFile.cbContent >= 1024*1024: reporter.log2('... cbChunk=%s' % (cbChunk,));
+ offFile = 0;
+ cReads = 0;
+ while offFile <= oTestFile.cbContent:
+ try:
+ abRead = oFile.read(cbChunk, 30*1000);
+ except:
+ fRc = reporter.errorXcpt('%s: offFile=%s cbChunk=%s cbContent=%s'
+ % (oTestFile.sPath, offFile, cbChunk, oTestFile.cbContent));
+ break;
+ cbRead = len(abRead);
+ if cbRead == 0 and offFile == oTestFile.cbContent:
+ break;
+ if cbRead <= 0:
+ fRc = reporter.error('%s @%s: cbRead=%s, cbContent=%s'
+ % (oTestFile.sPath, offFile, cbRead, oTestFile.cbContent));
+ break;
+ if not oTestFile.equalMemory(abRead, offFile):
+ fRc = reporter.error('%s: read mismatch @ %s LB %s' % (oTestFile.sPath, offFile, cbRead));
+ break;
+ offFile += cbRead;
+ cReads += 1;
+ if cReads > 8192:
+ break;
+
+ # Seek to start of file.
+ try:
+ offFile = oFile.seek(0, vboxcon.FileSeekOrigin_Begin);
+ except:
+ fRc = reporter.errorXcpt('%s: error seeking to start of file' % (oTestFile.sPath,));
+ break;
+ if offFile != 0:
+ fRc = reporter.error('%s: seek to start of file returned %u, expected 0' % (oTestFile.sPath, offFile));
+ break;
+
+ #
+ # Random reads.
+ #
+ reporter.log2('Random reads (seek)');
+ for _ in xrange(8):
+ offFile = self.oTestFiles.oRandom.randrange(0, oTestFile.cbContent + 1024);
+ cbToRead = self.oTestFiles.oRandom.randrange(1, min(oTestFile.cbContent + 256, 768*1024));
+ #if oTestFile.cbContent >= 1024*1024: reporter.log2('... %s LB %s' % (offFile, cbToRead,));
+
+ try:
+ offActual = oFile.seek(offFile, vboxcon.FileSeekOrigin_Begin);
+ except:
+ fRc = reporter.errorXcpt('%s: error seeking to %s' % (oTestFile.sPath, offFile));
+ break;
+ if offActual != offFile:
+ fRc = reporter.error('%s: seek(%s,Begin) -> %s, expected %s'
+ % (oTestFile.sPath, offFile, offActual, offFile));
+ break;
+
+ try:
+ abRead = oFile.read(cbToRead, 30*1000);
+ except:
+ fRc = reporter.errorXcpt('%s: offFile=%s cbToRead=%s cbContent=%s'
+ % (oTestFile.sPath, offFile, cbToRead, oTestFile.cbContent));
+ cbRead = 0;
+ else:
+ cbRead = len(abRead);
+ if not oTestFile.equalMemory(abRead, offFile):
+ fRc = reporter.error('%s: random read mismatch @ %s LB %s' % (oTestFile.sPath, offFile, cbRead,));
+
+ try:
+ offActual = oFile.offset;
+ except:
+ fRc = reporter.errorXcpt('%s: offFile=%s cbToRead=%s cbContent=%s (#1)'
+ % (oTestFile.sPath, offFile, cbToRead, oTestFile.cbContent));
+ else:
+ if offActual != offFile + cbRead:
+ fRc = reporter.error('%s: IFile.offset is %s, expected %s (offFile=%s cbToRead=%s cbRead=%s) (#1)'
+ % (oTestFile.sPath, offActual, offFile + cbRead, offFile, cbToRead, cbRead));
+ try:
+ offActual = oFile.seek(0, vboxcon.FileSeekOrigin_Current);
+ except:
+ fRc = reporter.errorXcpt('%s: offFile=%s cbToRead=%s cbContent=%s (#1)'
+ % (oTestFile.sPath, offFile, cbToRead, oTestFile.cbContent));
+ else:
+ if offActual != offFile + cbRead:
+ fRc = reporter.error('%s: seek(0,cur) -> %s, expected %s (offFile=%s cbToRead=%s cbRead=%s) (#1)'
+ % (oTestFile.sPath, offActual, offFile + cbRead, offFile, cbToRead, cbRead));
+
+ #
+ # Random reads using readAt.
+ #
+ reporter.log2('Random reads (readAt)');
+ for _ in xrange(12):
+ offFile = self.oTestFiles.oRandom.randrange(0, oTestFile.cbContent + 1024);
+ cbToRead = self.oTestFiles.oRandom.randrange(1, min(oTestFile.cbContent + 256, 768*1024));
+ #if oTestFile.cbContent >= 1024*1024: reporter.log2('... %s LB %s (readAt)' % (offFile, cbToRead,));
+
+ try:
+ abRead = oFile.readAt(offFile, cbToRead, 30*1000);
+ except:
+ fRc = reporter.errorXcpt('%s: offFile=%s cbToRead=%s cbContent=%s'
+ % (oTestFile.sPath, offFile, cbToRead, oTestFile.cbContent));
+ cbRead = 0;
+ else:
+ cbRead = len(abRead);
+ if not oTestFile.equalMemory(abRead, offFile):
+ fRc = reporter.error('%s: random readAt mismatch @ %s LB %s' % (oTestFile.sPath, offFile, cbRead,));
+
+ try:
+ offActual = oFile.offset;
+ except:
+ fRc = reporter.errorXcpt('%s: offFile=%s cbToRead=%s cbContent=%s (#2)'
+ % (oTestFile.sPath, offFile, cbToRead, oTestFile.cbContent));
+ else:
+ if offActual != offFile + cbRead:
+ fRc = reporter.error('%s: IFile.offset is %s, expected %s (offFile=%s cbToRead=%s cbRead=%s) (#2)'
+ % (oTestFile.sPath, offActual, offFile + cbRead, offFile, cbToRead, cbRead));
+
+ try:
+ offActual = oFile.seek(0, vboxcon.FileSeekOrigin_Current);
+ except:
+ fRc = reporter.errorXcpt('%s: offFile=%s cbToRead=%s cbContent=%s (#2)'
+ % (oTestFile.sPath, offFile, cbToRead, oTestFile.cbContent));
+ else:
+ if offActual != offFile + cbRead:
+ fRc = reporter.error('%s: seek(0,cur) -> %s, expected %s (offFile=%s cbToRead=%s cbRead=%s) (#2)'
+ % (oTestFile.sPath, offActual, offFile + cbRead, offFile, cbToRead, cbRead));
+
+ #
+ # A few negative things.
+ #
+
+ # Zero byte reads -> E_INVALIDARG.
+ reporter.log2('Zero byte reads');
+ try:
+ abRead = oFile.read(0, 30*1000);
+ except Exception as oXcpt:
+ if vbox.ComError.notEqual(oXcpt, vbox.ComError.E_INVALIDARG):
+ fRc = reporter.errorXcpt('read(0,30s) did not raise E_INVALIDARG as expected!');
+ else:
+ fRc = reporter.error('read(0,30s) did not fail!');
+
+ try:
+ abRead = oFile.readAt(0, 0, 30*1000);
+ except Exception as oXcpt:
+ if vbox.ComError.notEqual(oXcpt, vbox.ComError.E_INVALIDARG):
+ fRc = reporter.errorXcpt('readAt(0,0,30s) did not raise E_INVALIDARG as expected!');
+ else:
+ fRc = reporter.error('readAt(0,0,30s) did not fail!');
+
+ # See what happens when we read 1GiB. We should get a max of 1MiB back.
+ ## @todo Document this behaviour in VirtualBox.xidl.
+ reporter.log2('1GB reads');
+ try:
+ oFile.seek(0, vboxcon.FileSeekOrigin_Begin);
+ except:
+ fRc = reporter.error('seek(0)');
+ try:
+ abRead = oFile.read(1024*1024*1024, 30*1000);
+ except:
+ fRc = reporter.errorXcpt('read(1GiB,30s)');
+ else:
+ if len(abRead) != min(oTestFile.cbContent, 1024*1024):
+ fRc = reporter.error('Expected read(1GiB,30s) to return %s bytes, got %s bytes instead'
+ % (min(oTestFile.cbContent, 1024*1024), len(abRead),));
+
+ try:
+ abRead = oFile.readAt(0, 1024*1024*1024, 30*1000);
+ except:
+ fRc = reporter.errorXcpt('readAt(0,1GiB,30s)');
+ else:
+ if len(abRead) != min(oTestFile.cbContent, 1024*1024):
+ reporter.error('Expected readAt(0, 1GiB,30s) to return %s bytes, got %s bytes instead'
+ % (min(oTestFile.cbContent, 1024*1024), len(abRead),));
+
+ #
+ # Check stat info on the file as well as querySize.
+ #
+ if self.oTstDrv.fpApiVer > 5.2:
+ try:
+ oFsObjInfo = oFile.queryInfo();
+ except:
+ fRc = reporter.errorXcpt('%s: queryInfo()' % (oTestFile.sPath,));
+ else:
+ if oFsObjInfo is None:
+ fRc = reporter.error('IGuestFile::queryInfo returned None');
+ else:
+ try:
+ cbFile = oFsObjInfo.objectSize;
+ except:
+ fRc = reporter.errorXcpt();
+ else:
+ if cbFile != oTestFile.cbContent:
+ fRc = reporter.error('%s: queryInfo returned incorrect file size: %s, expected %s'
+ % (oTestFile.sPath, cbFile, oTestFile.cbContent));
+
+ try:
+ cbFile = oFile.querySize();
+ except:
+ fRc = reporter.errorXcpt('%s: querySize()' % (oTestFile.sPath,));
+ else:
+ if cbFile != oTestFile.cbContent:
+ fRc = reporter.error('%s: querySize returned incorrect file size: %s, expected %s'
+ % (oTestFile.sPath, cbFile, oTestFile.cbContent));
+
+ #
+ # Use seek to test the file size and do a few other end-relative seeks.
+ #
+ try:
+ cbFile = oFile.seek(0, vboxcon.FileSeekOrigin_End);
+ except:
+ fRc = reporter.errorXcpt('%s: seek(0,End)' % (oTestFile.sPath,));
+ else:
+ if cbFile != oTestFile.cbContent:
+ fRc = reporter.error('%s: seek(0,End) returned incorrect file size: %s, expected %s'
+ % (oTestFile.sPath, cbFile, oTestFile.cbContent));
+ if oTestFile.cbContent > 0:
+ for _ in xrange(5):
+ offSeek = self.oTestFiles.oRandom.randrange(oTestFile.cbContent + 1);
+ try:
+ offFile = oFile.seek(-offSeek, vboxcon.FileSeekOrigin_End);
+ except:
+ fRc = reporter.errorXcpt('%s: seek(%s,End)' % (oTestFile.sPath, -offSeek,));
+ else:
+ if offFile != oTestFile.cbContent - offSeek:
+ fRc = reporter.error('%s: seek(%s,End) returned incorrect offset: %s, expected %s (cbContent=%s)'
+ % (oTestFile.sPath, -offSeek, offSeek, oTestFile.cbContent - offSeek,
+ oTestFile.cbContent,));
+
+ #
+ # Close it and we're done with this file.
+ #
+ try:
+ oFile.close();
+ except:
+ fRc = reporter.errorXcpt('%s: error closing the file' % (oTestFile.sPath,));
+
+ #
+ # Clean up.
+ #
+ for oTestFile in aoExtraFiles:
+ try:
+ oGuestSession.fsObjRemove(sBigPath);
+ except:
+ fRc = reporter.errorXcpt('fsObjRemove(%s)' % (sBigPath,));
+
+ fRc = oTest.closeSession() and fRc;
+
+ return (fRc, oTxsSession);
+
+
+ def testGuestCtrlFileWrite(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests writing to guest files.
+ """
+ if self.oTstDrv.fpApiVer < 5.0:
+ reporter.log('Skipping because of pre 5.0 API');
+ return None;
+
+ #
+ # The test file and its content.
+ #
+ sFile = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), 'gctrl-write-1');
+ abContent = bytearray(0);
+
+ #
+ # The tests.
+ #
+ def randBytes(cbHowMany):
+ """ Returns an bytearray of random bytes. """
+ return bytearray(self.oTestFiles.oRandom.getrandbits(8) for _ in xrange(cbHowMany));
+
+ aoTests = [
+ # Write at end:
+ tdTestFileOpenAndWrite(sFile = sFile, eAction = vboxcon.FileOpenAction_CreateNew, abContent = abContent,
+ atChunks = [(None, randBytes(1)), (None, randBytes(77)), (None, randBytes(98)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 1+77+98), # 176
+ # Appending:
+ tdTestFileOpenAndWrite(sFile = sFile, eAction = vboxcon.FileOpenAction_AppendOrCreate, abContent = abContent,
+ atChunks = [(None, randBytes(255)), (None, randBytes(33)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 176 + 255+33), # 464
+ tdTestFileOpenAndWrite(sFile = sFile, eAction = vboxcon.FileOpenAction_AppendOrCreate, abContent = abContent,
+ atChunks = [(10, randBytes(44)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 464 + 44), # 508
+ # Write within existing:
+ tdTestFileOpenAndWrite(sFile = sFile, eAction = vboxcon.FileOpenAction_OpenExisting, abContent = abContent,
+ atChunks = [(0, randBytes(1)), (50, randBytes(77)), (255, randBytes(199)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 508),
+ # Writing around and over the end:
+ tdTestFileOpenAndWrite(sFile = sFile, abContent = abContent,
+ atChunks = [(500, randBytes(9)), (508, randBytes(15)), (512, randBytes(12)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 512+12),
+
+ # writeAt appending:
+ tdTestFileOpenAndWrite(sFile = sFile, abContent = abContent, fUseAtApi = True,
+ atChunks = [(0, randBytes(23)), (6, randBytes(1018)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 6+1018), # 1024
+ # writeAt within existing:
+ tdTestFileOpenAndWrite(sFile = sFile, abContent = abContent, fUseAtApi = True,
+ atChunks = [(1000, randBytes(23)), (1, randBytes(990)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 1024),
+ # writeAt around and over the end:
+ tdTestFileOpenAndWrite(sFile = sFile, abContent = abContent, fUseAtApi = True,
+ atChunks = [(1024, randBytes(63)), (1080, randBytes(968)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 1080+968), # 2048
+
+ # writeAt beyond the end (gap is filled with zeros):
+ tdTestFileOpenAndWrite(sFile = sFile, abContent = abContent, fUseAtApi = True, atChunks = [(3070, randBytes(2)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 3072),
+ # write beyond the end (gap is filled with zeros):
+ tdTestFileOpenAndWrite(sFile = sFile, abContent = abContent, atChunks = [(4090, randBytes(6)),]),
+ tdTestFileOpenAndCheckContent(sFile = sFile, abContent = abContent, cbContentExpected = 4096),
+ ];
+
+ for (i, oCurTest) in enumerate(aoTests):
+ reporter.log('Testing #%d: %s ...' % (i, oCurTest.toString(),));
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, _ = oCurTest.createSession('testGuestCtrlFileWrite: Test #%d' % (i,));
+ if fRc is not True:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ fRc2 = oCurTest.doSteps(True, self);
+ if fRc2 is not True:
+ fRc = reporter.error('Test #%d failed!' % (i,));
+
+ fRc = oCurTest.closeSession() and fRc;
+
+ #
+ # Cleanup
+ #
+ if oTxsSession.syncRmFile(sFile) is not True:
+ fRc = reporter.error('Failed to remove write-test file: %s' % (sFile, ));
+
+ return (fRc, oTxsSession);
+
+ @staticmethod
+ def __generateFile(sName, cbFile):
+ """ Helper for generating a file with a given size. """
+ with open(sName, 'wb') as oFile:
+ while cbFile > 0:
+ cb = cbFile if cbFile < 256*1024 else 256*1024;
+ oFile.write(bytearray(random.getrandbits(8) for _ in xrange(cb)));
+ cbFile -= cb;
+ return True;
+
+ def testGuestCtrlCopyTo(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests copying files from host to the guest.
+ """
+
+ #
+ # Paths and test files.
+ #
+ sScratchHst = os.path.join(self.oTstDrv.sScratchPath, 'copyto');
+ sScratchTestFilesHst = os.path.join(sScratchHst, self.oTestFiles.sSubDir);
+ sScratchEmptyDirHst = os.path.join(sScratchTestFilesHst, self.oTestFiles.oEmptyDir.sName);
+ sScratchNonEmptyDirHst = self.oTestFiles.chooseRandomDirFromTree().buildPath(sScratchHst, os.path.sep);
+ sScratchTreeDirHst = os.path.join(sScratchTestFilesHst, self.oTestFiles.oTreeDir.sName);
+
+ sScratchGst = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), 'copyto');
+ sScratchDstDir1Gst = oTestVm.pathJoin(sScratchGst, 'dstdir1');
+ sScratchDstDir2Gst = oTestVm.pathJoin(sScratchGst, 'dstdir2');
+ sScratchDstDir3Gst = oTestVm.pathJoin(sScratchGst, 'dstdir3');
+ sScratchDstDir4Gst = oTestVm.pathJoin(sScratchGst, 'dstdir4');
+ sScratchDotDotDirGst = oTestVm.pathJoin(sScratchGst, '..');
+ #sScratchGstNotExist = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), 'no-such-file-or-directory');
+ sScratchHstNotExist = os.path.join(self.oTstDrv.sScratchPath, 'no-such-file-or-directory');
+ sScratchGstPathNotFound = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), 'no-such-directory', 'or-file');
+ #sScratchHstPathNotFound = os.path.join(self.oTstDrv.sScratchPath, 'no-such-directory', 'or-file');
+
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ sScratchGstInvalid = "?*|<invalid-name>";
+ else:
+ sScratchGstInvalid = None;
+ if utils.getHostOs() in ('win', 'os2'):
+ sScratchHstInvalid = "?*|<invalid-name>";
+ else:
+ sScratchHstInvalid = None;
+
+ for sDir in (sScratchGst, sScratchDstDir1Gst, sScratchDstDir2Gst, sScratchDstDir3Gst, sScratchDstDir4Gst):
+ if oTxsSession.syncMkDir(sDir, 0o777) is not True:
+ return reporter.error('TXS failed to create directory "%s"!' % (sDir,));
+
+ # Put the test file set under sScratchHst.
+ if os.path.exists(sScratchHst):
+ if base.wipeDirectory(sScratchHst) != 0:
+ return reporter.error('Failed to wipe "%s"' % (sScratchHst,));
+ else:
+ try:
+ os.mkdir(sScratchHst);
+ except:
+ return reporter.errorXcpt('os.mkdir(%s)' % (sScratchHst, ));
+ if self.oTestFiles.writeToDisk(sScratchHst) is not True:
+ return reporter.error('Filed to write test files to "%s" on the host!' % (sScratchHst,));
+
+ # If for whatever reason the directory tree does not exist on the host, let us know.
+ # Copying an non-existing tree *will* fail the tests which otherwise should succeed!
+ assert os.path.exists(sScratchTreeDirHst);
+
+ # Generate a test file in 32MB to 64 MB range.
+ sBigFileHst = os.path.join(self.oTstDrv.sScratchPath, 'gctrl-random.data');
+ cbBigFileHst = random.randrange(32*1024*1024, 64*1024*1024);
+ reporter.log('cbBigFileHst=%s' % (cbBigFileHst,));
+ cbLeft = cbBigFileHst;
+ try:
+ self.__generateFile(sBigFileHst, cbBigFileHst);
+ except:
+ return reporter.errorXcpt('sBigFileHst=%s cbBigFileHst=%s cbLeft=%s' % (sBigFileHst, cbBigFileHst, cbLeft,));
+ reporter.log('cbBigFileHst=%s' % (cbBigFileHst,));
+
+ # Generate an empty file on the host that we can use to save space in the guest.
+ sEmptyFileHst = os.path.join(self.oTstDrv.sScratchPath, 'gctrl-empty.data');
+ try:
+ open(sEmptyFileHst, "wb").close(); # pylint: disable=consider-using-with
+ except:
+ return reporter.errorXcpt('sEmptyFileHst=%s' % (sEmptyFileHst,));
+
+ # os.path.join() is too clever for "..", so we just build up the path here ourselves.
+ sScratchDotDotFileHst = sScratchHst + os.path.sep + '..' + os.path.sep + 'gctrl-empty.data';
+
+ #
+ # Tests.
+ #
+ atTests = [
+ # Nothing given:
+ [ tdTestCopyToFile(), tdTestResultFailure() ],
+ [ tdTestCopyToDir(), tdTestResultFailure() ],
+ # Only source given:
+ [ tdTestCopyToFile(sSrc = sBigFileHst), tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = sScratchEmptyDirHst), tdTestResultFailure() ],
+ # Only destination given:
+ [ tdTestCopyToFile(sDst = oTestVm.pathJoin(sScratchGst, 'dstfile')), tdTestResultFailure() ],
+ [ tdTestCopyToDir( sDst = sScratchGst), tdTestResultFailure() ],
+ # Both given, but invalid flags.
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = sScratchGst, afFlags = [ 0x40000000, ] ), tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = sScratchEmptyDirHst, sDst = sScratchGst, afFlags = [ 0x40000000, ] ),
+ tdTestResultFailure() ],
+ ];
+ atTests.extend([
+ # Non-existing source, but no destination:
+ [ tdTestCopyToFile(sSrc = sScratchHstNotExist), tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = sScratchHstNotExist), tdTestResultFailure() ],
+ # Valid sources, but destination path not found:
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = sScratchGstPathNotFound), tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = sScratchEmptyDirHst, sDst = sScratchGstPathNotFound), tdTestResultFailure() ],
+ # Valid destination, but source file/dir not found:
+ [ tdTestCopyToFile(sSrc = sScratchHstNotExist, sDst = oTestVm.pathJoin(sScratchGst, 'dstfile')),
+ tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = sScratchHstNotExist, sDst = sScratchGst), tdTestResultFailure() ],
+ # Wrong type:
+ [ tdTestCopyToFile(sSrc = sScratchEmptyDirHst, sDst = oTestVm.pathJoin(sScratchGst, 'dstfile')),
+ tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = sBigFileHst, sDst = sScratchGst), tdTestResultFailure() ],
+ ]);
+ # Invalid characters in destination or source path:
+ if sScratchGstInvalid is not None:
+ atTests.extend([
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = oTestVm.pathJoin(sScratchGst, sScratchGstInvalid)),
+ tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = sScratchEmptyDirHst, sDst = oTestVm.pathJoin(sScratchGst, sScratchGstInvalid)),
+ tdTestResultFailure() ],
+ ]);
+ if sScratchHstInvalid is not None:
+ atTests.extend([
+ [ tdTestCopyToFile(sSrc = os.path.join(self.oTstDrv.sScratchPath, sScratchHstInvalid), sDst = sScratchGst),
+ tdTestResultFailure() ],
+ [ tdTestCopyToDir( sSrc = os.path.join(self.oTstDrv.sScratchPath, sScratchHstInvalid), sDst = sScratchGst),
+ tdTestResultFailure() ],
+ ]);
+
+ #
+ # Single file handling.
+ #
+ atTests.extend([
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = oTestVm.pathJoin(sScratchGst, 'HostGABig.dat')),
+ tdTestResultSuccess() ],
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = oTestVm.pathJoin(sScratchGst, 'HostGABig.dat')), # Overwrite
+ tdTestResultSuccess() ],
+ [ tdTestCopyToFile(sSrc = sEmptyFileHst, sDst = oTestVm.pathJoin(sScratchGst, 'HostGABig.dat')), # Overwrite
+ tdTestResultSuccess() ],
+ ]);
+ if self.oTstDrv.fpApiVer > 5.2: # Copying files into directories via Main is supported only 6.0 and later.
+ atTests.extend([
+ # Should succeed, as the file isn't there yet on the destination.
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = sScratchGst + oTestVm.pathSep()), tdTestResultSuccess() ],
+ # Overwrite the existing file.
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = sScratchGst + oTestVm.pathSep()), tdTestResultSuccess() ],
+ # Same file, but with a different name on the destination.
+ [ tdTestCopyToFile(sSrc = sEmptyFileHst, sDst = oTestVm.pathJoin(sScratchGst, os.path.split(sBigFileHst)[1])),
+ tdTestResultSuccess() ], # Overwrite
+ ]);
+
+ if oTestVm.isWindows():
+ # Copy to a Windows alternative data stream (ADS).
+ atTests.extend([
+ [ tdTestCopyToFile(sSrc = sBigFileHst, sDst = oTestVm.pathJoin(sScratchGst, 'HostGABig.dat:ADS-Test')),
+ tdTestResultSuccess() ],
+ [ tdTestCopyToFile(sSrc = sEmptyFileHst, sDst = oTestVm.pathJoin(sScratchGst, 'HostGABig.dat:ADS-Test')),
+ tdTestResultSuccess() ],
+ ]);
+
+ #
+ # Directory handling.
+ #
+ if self.oTstDrv.fpApiVer > 5.2: # Copying directories via Main is supported only in versions > 5.2.
+ atTests.extend([
+ # Without a trailing slash added to the destination this should fail,
+ # as the destination directory already exists.
+ [ tdTestCopyToDir(sSrc = sScratchEmptyDirHst, sDst = sScratchDstDir1Gst), tdTestResultFailure() ],
+ # Same existing host directory, but this time with DirectoryCopyFlag_CopyIntoExisting set.
+ # This should copy the contents of oEmptyDirGst to sScratchDstDir1Gst (empty, but anyway).
+ [ tdTestCopyToDir(sSrc = sScratchEmptyDirHst, sDst = sScratchDstDir1Gst,
+ afFlags = [vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ # Try again.
+ [ tdTestCopyToDir(sSrc = sScratchEmptyDirHst, sDst = sScratchDstDir1Gst,
+ afFlags = [vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ # With a trailing slash added to the destination, copy the empty guest directory
+ # (should end up as sScratchDstDir2Gst/empty):
+ [ tdTestCopyToDir(sSrc = sScratchEmptyDirHst, sDst = sScratchDstDir2Gst + oTestVm.pathSep()),
+ tdTestResultSuccess() ],
+ # Repeat -- this time it should fail, as the destination directory already exists (and
+ # DirectoryCopyFlag_CopyIntoExisting is not specified):
+ [ tdTestCopyToDir(sSrc = sScratchEmptyDirHst, sDst = sScratchDstDir2Gst + oTestVm.pathSep()),
+ tdTestResultFailure() ],
+ # Add the DirectoryCopyFlag_CopyIntoExisting flag being set and it should work (again).
+ [ tdTestCopyToDir(sSrc = sScratchEmptyDirHst, sDst = sScratchDstDir2Gst + oTestVm.pathSep(),
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ # Copy with a different destination name just for the heck of it:
+ [ tdTestCopyToDir(sSrc = sScratchEmptyDirHst, sDst = oTestVm.pathJoin(sScratchDstDir2Gst, 'empty2')),
+ tdTestResultSuccess() ],
+ ]);
+ atTests.extend([
+ # Now the same using a directory with files in it:
+ [ tdTestCopyToDir(sSrc = sScratchNonEmptyDirHst, sDst = sScratchDstDir3Gst,
+ afFlags = [vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ # Again.
+ [ tdTestCopyToDir(sSrc = sScratchNonEmptyDirHst, sDst = sScratchDstDir3Gst,
+ afFlags = [vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ ]);
+ atTests.extend([
+ # Copy the entire test tree:
+ [ tdTestCopyToDir(sSrc = sScratchTreeDirHst, sDst = sScratchDstDir4Gst + oTestVm.pathSep()),
+ tdTestResultSuccess() ],
+ # Again, should fail this time.
+ [ tdTestCopyToDir(sSrc = sScratchTreeDirHst, sDst = sScratchDstDir4Gst + oTestVm.pathSep()),
+ tdTestResultFailure() ],
+ # Works again, as DirectoryCopyFlag_CopyIntoExisting is specified.
+ [ tdTestCopyToDir(sSrc = sScratchTreeDirHst, sDst = sScratchDstDir4Gst + oTestVm.pathSep(),
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ ]);
+ #
+ # Dotdot path handling.
+ #
+ if self.oTstDrv.fpApiVer >= 6.1:
+ atTests.extend([
+ # Test if copying stuff from a host dotdot ".." directory works.
+ [ tdTestCopyToFile(sSrc = sScratchDotDotFileHst, sDst = sScratchDstDir1Gst + oTestVm.pathSep()),
+ tdTestResultSuccess() ],
+ # Test if copying stuff from the host to a guest's dotdot ".." directory works.
+ # That should fail on destinations.
+ [ tdTestCopyToFile(sSrc = sEmptyFileHst, sDst = sScratchDotDotDirGst), tdTestResultFailure() ],
+ ]);
+
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0]; # tdTestCopyTo
+ oCurRes = tTest[1]; # tdTestResult
+ reporter.log('Testing #%d, sSrc=%s, sDst=%s, afFlags=%s ...'
+ % (i, limitString(oCurTest.sSrc), limitString(oCurTest.sDst), oCurTest.afFlags));
+
+ oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, oCurGuestSession = oCurTest.createSession('testGuestCtrlCopyTo: Test #%d' % (i,));
+ if fRc is not True:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ fRc2 = False;
+ if isinstance(oCurTest, tdTestCopyToFile):
+ fRc2 = self.gctrlCopyFileTo(oCurGuestSession, oCurTest.sSrc, oCurTest.sDst, oCurTest.afFlags, oCurRes.fRc);
+ else:
+ fRc2 = self.gctrlCopyDirTo(oCurGuestSession, oCurTest.sSrc, oCurTest.sDst, oCurTest.afFlags, oCurRes.fRc);
+ if fRc2 is not oCurRes.fRc:
+ fRc = reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc2, oCurRes.fRc));
+
+ fRc = oCurTest.closeSession() and fRc;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlCopyFrom(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests copying files from guest to the host.
+ """
+
+ reporter.log2('Entered');
+
+ #
+ # Paths.
+ #
+ sScratchHst = os.path.join(self.oTstDrv.sScratchPath, "testGctrlCopyFrom");
+ sScratchDstDir1Hst = os.path.join(sScratchHst, "dstdir1");
+ sScratchDstDir2Hst = os.path.join(sScratchHst, "dstdir2");
+ sScratchDstDir3Hst = os.path.join(sScratchHst, "dstdir3");
+ sScratchDstDir4Hst = os.path.join(sScratchHst, "dstdir4");
+ # os.path.join() is too clever for "..", so we just build up the path here ourselves.
+ sScratchDotDotDirHst = sScratchHst + os.path.sep + '..' + os.path.sep;
+ oExistingFileGst = self.oTestFiles.chooseRandomFile();
+ oNonEmptyDirGst = self.oTestFiles.chooseRandomDirFromTree(fNonEmpty = True);
+ oTreeDirGst = self.oTestFiles.oTreeDir;
+ oEmptyDirGst = self.oTestFiles.oEmptyDir;
+
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ sScratchGstInvalid = "?*|<invalid-name>";
+ else:
+ sScratchGstInvalid = None;
+ if utils.getHostOs() in ('win', 'os2'):
+ sScratchHstInvalid = "?*|<invalid-name>";
+ else:
+ sScratchHstInvalid = None;
+
+ sScratchDotDotDirGst = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), '..');
+
+ if os.path.exists(sScratchHst):
+ if base.wipeDirectory(sScratchHst) != 0:
+ return reporter.error('Failed to wipe "%s"' % (sScratchHst,));
+ else:
+ try:
+ os.mkdir(sScratchHst);
+ except:
+ return reporter.errorXcpt('os.mkdir(%s)' % (sScratchHst, ));
+
+ reporter.log2('Creating host sub dirs ...');
+
+ for sSubDir in (sScratchDstDir1Hst, sScratchDstDir2Hst, sScratchDstDir3Hst, sScratchDstDir4Hst):
+ try:
+ os.mkdir(sSubDir);
+ except:
+ return reporter.errorXcpt('os.mkdir(%s)' % (sSubDir, ));
+
+ reporter.log2('Defining tests ...');
+
+ #
+ # Bad parameter tests.
+ #
+ atTests = [
+ # Missing both source and destination:
+ [ tdTestCopyFromFile(), tdTestResultFailure() ],
+ [ tdTestCopyFromDir(), tdTestResultFailure() ],
+ # Missing source.
+ [ tdTestCopyFromFile(sDst = os.path.join(sScratchHst, 'somefile')), tdTestResultFailure() ],
+ [ tdTestCopyFromDir( sDst = sScratchHst), tdTestResultFailure() ],
+ # Missing destination.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst), tdTestResultFailure() ],
+ [ tdTestCopyFromDir( sSrc = self.oTestFiles.oManyDir.sPath), tdTestResultFailure() ],
+ # Invalid flags:
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = os.path.join(sScratchHst, 'somefile'), afFlags = [0x40000000]),
+ tdTestResultFailure() ],
+ [ tdTestCopyFromDir( oSrc = oEmptyDirGst, sDst = os.path.join(sScratchHst, 'somedir'), afFlags = [ 0x40000000] ),
+ tdTestResultFailure() ],
+ # Non-existing sources:
+ [ tdTestCopyFromFile(sSrc = oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'no-such-file-or-directory'),
+ sDst = os.path.join(sScratchHst, 'somefile')), tdTestResultFailure() ],
+ [ tdTestCopyFromDir( sSrc = oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'no-such-file-or-directory'),
+ sDst = os.path.join(sScratchHst, 'somedir')), tdTestResultFailure() ],
+ [ tdTestCopyFromFile(sSrc = oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'no-such-directory', 'no-such-file'),
+ sDst = os.path.join(sScratchHst, 'somefile')), tdTestResultFailure() ],
+ [ tdTestCopyFromDir( sSrc = oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, 'no-such-directory', 'no-such-subdir'),
+ sDst = os.path.join(sScratchHst, 'somedir')), tdTestResultFailure() ],
+ # Non-existing destinations:
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst,
+ sDst = os.path.join(sScratchHst, 'no-such-directory', 'somefile') ), tdTestResultFailure() ],
+ [ tdTestCopyFromDir( oSrc = oEmptyDirGst, sDst = os.path.join(sScratchHst, 'no-such-directory', 'somedir') ),
+ tdTestResultFailure() ],
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst,
+ sDst = os.path.join(sScratchHst, 'no-such-directory-slash' + os.path.sep)),
+ tdTestResultFailure() ],
+ # Wrong source type:
+ [ tdTestCopyFromFile(oSrc = oNonEmptyDirGst, sDst = os.path.join(sScratchHst, 'somefile') ), tdTestResultFailure() ],
+ [ tdTestCopyFromDir(oSrc = oExistingFileGst, sDst = os.path.join(sScratchHst, 'somedir') ), tdTestResultFailure() ],
+ ];
+ # Bogus names:
+ if sScratchHstInvalid:
+ atTests.extend([
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = os.path.join(sScratchHst, sScratchHstInvalid)),
+ tdTestResultFailure() ],
+ [ tdTestCopyFromDir( sSrc = self.oTestFiles.oManyDir.sPath, sDst = os.path.join(sScratchHst, sScratchHstInvalid)),
+ tdTestResultFailure() ],
+ ]);
+ if sScratchGstInvalid:
+ atTests.extend([
+ [ tdTestCopyFromFile(sSrc = oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, sScratchGstInvalid),
+ sDst = os.path.join(sScratchHst, 'somefile')), tdTestResultFailure() ],
+ [ tdTestCopyFromDir( sSrc = oTestVm.pathJoin(self.oTestFiles.oRoot.sPath, sScratchGstInvalid),
+ sDst = os.path.join(sScratchHst, 'somedir')), tdTestResultFailure() ],
+ ]);
+
+ #
+ # Single file copying.
+ #
+ atTests.extend([
+ # Should succeed, as the file isn't there yet on the destination.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = os.path.join(sScratchHst, 'copyfile1')), tdTestResultSuccess() ],
+ # Overwrite the existing file.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = os.path.join(sScratchHst, 'copyfile1')), tdTestResultSuccess() ],
+ # Same file, but with a different name on the destination.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = os.path.join(sScratchHst, 'copyfile2')), tdTestResultSuccess() ],
+ ]);
+
+ if self.oTstDrv.fpApiVer > 5.2: # Copying files into directories via Main is supported only 6.0 and later.
+ # Copy into a directory.
+ atTests.extend([
+ # This should fail, as sScratchHst exists and is a directory.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = sScratchHst), tdTestResultFailure() ],
+ # Same existing host directory, but this time with a trailing slash.
+ # This should succeed, as the file isn't there yet on the destination.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = sScratchHst + os.path.sep), tdTestResultSuccess() ],
+ # Overwrite the existing file.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = sScratchHst + os.path.sep), tdTestResultSuccess() ],
+ ]);
+
+ #
+ # Directory handling.
+ #
+ if self.oTstDrv.fpApiVer > 5.2: # Copying directories via Main is supported only in versions > 5.2.
+ atTests.extend([
+ # Without a trailing slash added to the destination this should fail,
+ # as the destination directory already exist.
+ [ tdTestCopyFromDir(sSrc = oEmptyDirGst.sPath, sDst = sScratchDstDir1Hst), tdTestResultFailure() ],
+ # Same existing host directory, but this time with DirectoryCopyFlag_CopyIntoExisting set.
+ # This should copy the contents of oEmptyDirGst to sScratchDstDir1Hst (empty, but anyway).
+ [ tdTestCopyFromDir(sSrc = oEmptyDirGst.sPath, sDst = sScratchDstDir1Hst,
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ # Try again.
+ [ tdTestCopyFromDir(sSrc = oEmptyDirGst.sPath, sDst = sScratchDstDir1Hst,
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ # With a trailing slash added to the destination, copy the empty guest directory
+ # (should end up as sScratchHst/empty):
+ [ tdTestCopyFromDir(oSrc = oEmptyDirGst, sDst = sScratchDstDir2Hst + os.path.sep), tdTestResultSuccess() ],
+ # Repeat -- this time it should fail, as the destination directory already exists (and
+ # DirectoryCopyFlag_CopyIntoExisting is not specified):
+ [ tdTestCopyFromDir(oSrc = oEmptyDirGst, sDst = sScratchDstDir2Hst + os.path.sep), tdTestResultFailure() ],
+ # Add the DirectoryCopyFlag_CopyIntoExisting flag being set and it should work (again).
+ [ tdTestCopyFromDir(oSrc = oEmptyDirGst, sDst = sScratchDstDir2Hst + os.path.sep,
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ # Copy with a different destination name just for the heck of it:
+ [ tdTestCopyFromDir(sSrc = oEmptyDirGst.sPath, sDst = os.path.join(sScratchDstDir2Hst, 'empty2'),
+ fIntoDst = True),
+ tdTestResultSuccess() ],
+ ]);
+ atTests.extend([
+ # Now the same using a directory with files in it:
+ [ tdTestCopyFromDir(oSrc = oNonEmptyDirGst, sDst = sScratchDstDir3Hst + os.path.sep), tdTestResultSuccess() ],
+ # Again.
+ [ tdTestCopyFromDir(oSrc = oNonEmptyDirGst, sDst = sScratchDstDir3Hst, fIntoDst = True,
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ ]);
+ atTests.extend([
+ # Copy the entire test tree:
+ [ tdTestCopyFromDir(oSrc = oTreeDirGst, sDst = sScratchDstDir4Hst + os.path.sep), tdTestResultSuccess() ],
+ # Again, should fail this time.
+ [ tdTestCopyFromDir(oSrc = oTreeDirGst, sDst = sScratchDstDir4Hst + os.path.sep), tdTestResultFailure() ],
+ # Works again, as DirectoryCopyFlag_CopyIntoExisting is specified.
+ [ tdTestCopyFromDir(oSrc = oTreeDirGst, sDst = sScratchDstDir4Hst + os.path.sep,
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]), tdTestResultSuccess() ],
+ ]);
+ #
+ # Dotdot path handling.
+ #
+ if self.oTstDrv.fpApiVer >= 6.1:
+ atTests.extend([
+ # Test if copying stuff from a guest dotdot ".." directory works.
+ [ tdTestCopyFromDir(sSrc = sScratchDotDotDirGst, sDst = sScratchDstDir1Hst + os.path.sep,
+ afFlags = [ vboxcon.DirectoryCopyFlag_CopyIntoExisting, ]),
+ tdTestResultFailure() ],
+ # Test if copying stuff from the guest to a host's dotdot ".." directory works.
+ # That should fail on destinations.
+ [ tdTestCopyFromFile(oSrc = oExistingFileGst, sDst = sScratchDotDotDirHst), tdTestResultFailure() ],
+ ]);
+
+ reporter.log2('Executing tests ...');
+
+ #
+ # Execute the tests.
+ #
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0]
+ oCurRes = tTest[1] # type: tdTestResult
+ if isinstance(oCurTest, tdTestCopyFrom):
+ reporter.log('Testing #%d, %s: sSrc="%s", sDst="%s", afFlags="%s" ...'
+ % (i, "directory" if isinstance(oCurTest, tdTestCopyFromDir) else "file",
+ limitString(oCurTest.sSrc), limitString(oCurTest.sDst), oCurTest.afFlags,));
+ else:
+ reporter.log('Testing #%d, tdTestRemoveHostDir "%s" ...' % (i, oCurTest.sDir,));
+ if isinstance(oCurTest, tdTestCopyFromDir) and self.oTstDrv.fpApiVer < 6.0:
+ reporter.log('Skipping directoryCopyFromGuest test, not implemented in %s' % (self.oTstDrv.fpApiVer,));
+ continue;
+
+ if isinstance(oCurTest, tdTestRemoveHostDir):
+ fRc = oCurTest.execute(self.oTstDrv, oSession, oTxsSession, oTestVm, 'testing #%d' % (i,));
+ else:
+ fRc = oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc2, oCurGuestSession = oCurTest.createSession('testGuestCtrlCopyFrom: Test #%d' % (i,));
+ if fRc2 is not True:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ if isinstance(oCurTest, tdTestCopyFromFile):
+ fRc2 = self.gctrlCopyFileFrom(oCurGuestSession, oCurTest, oCurRes.fRc);
+ else:
+ fRc2 = self.gctrlCopyDirFrom(oCurGuestSession, oCurTest, oCurRes.fRc);
+
+ if fRc2 != oCurRes.fRc:
+ fRc = reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc2, oCurRes.fRc));
+
+ fRc = oCurTest.closeSession() and fRc;
+
+ return (fRc, oTxsSession);
+
+ def testGuestCtrlUpdateAdditions(self, oSession, oTxsSession, oTestVm): # pylint: disable=too-many-locals
+ """
+ Tests updating the Guest Additions inside the guest.
+
+ """
+
+ ## @todo currently disabled everywhere.
+ if self.oTstDrv.fpApiVer < 100.0:
+ reporter.log("Skipping updating GAs everywhere for now...");
+ return None;
+
+ # Skip test for updating Guest Additions if we run on a too old (Windows) guest.
+ ##
+ ## @todo make it work everywhere!
+ ##
+ if oTestVm.sKind in ('WindowsNT4', 'Windows2000', 'WindowsXP', 'Windows2003'):
+ reporter.log("Skipping updating GAs on old windows vm (sKind=%s)" % (oTestVm.sKind,));
+ return (None, oTxsSession);
+ if oTestVm.isOS2():
+ reporter.log("Skipping updating GAs on OS/2 guest");
+ return (None, oTxsSession);
+
+ sVBoxValidationKitIso = self.oTstDrv.sVBoxValidationKitIso;
+ if not os.path.isfile(sVBoxValidationKitIso):
+ return reporter.log('Validation Kit .ISO not found at "%s"' % (sVBoxValidationKitIso,));
+
+ sScratch = os.path.join(self.oTstDrv.sScratchPath, "testGctrlUpdateAdditions");
+ try:
+ os.makedirs(sScratch);
+ except OSError as e:
+ if e.errno != errno.EEXIST:
+ return reporter.error('Failed: Unable to create scratch directory \"%s\"' % (sScratch,));
+ reporter.log('Scratch path is: %s' % (sScratch,));
+
+ atTests = [];
+ if oTestVm.isWindows():
+ atTests.extend([
+ # Source is missing.
+ [ tdTestUpdateAdditions(sSrc = ''), tdTestResultFailure() ],
+
+ # Wrong flags.
+ [ tdTestUpdateAdditions(sSrc = self.oTstDrv.getGuestAdditionsIso(),
+ afFlags = [ 1234 ]), tdTestResultFailure() ],
+
+ # Non-existing .ISO.
+ [ tdTestUpdateAdditions(sSrc = "non-existing.iso"), tdTestResultFailure() ],
+
+ # Wrong .ISO.
+ [ tdTestUpdateAdditions(sSrc = sVBoxValidationKitIso), tdTestResultFailure() ],
+
+ # The real thing.
+ [ tdTestUpdateAdditions(sSrc = self.oTstDrv.getGuestAdditionsIso()),
+ tdTestResultSuccess() ],
+ # Test the (optional) installer arguments. This will extract the
+ # installer into our guest's scratch directory.
+ [ tdTestUpdateAdditions(sSrc = self.oTstDrv.getGuestAdditionsIso(),
+ asArgs = [ '/extract', '/D=' + sScratch ]),
+ tdTestResultSuccess() ]
+ # Some debg ISO. Only enable locally.
+ #[ tdTestUpdateAdditions(
+ # sSrc = "V:\\Downloads\\VBoxGuestAdditions-r80354.iso"),
+ # tdTestResultSuccess() ]
+ ]);
+ else:
+ reporter.log('No OS-specific tests for non-Windows yet!');
+
+ fRc = True;
+ for (i, tTest) in enumerate(atTests):
+ oCurTest = tTest[0] # type: tdTestUpdateAdditions
+ oCurRes = tTest[1] # type: tdTestResult
+ reporter.log('Testing #%d, sSrc="%s", afFlags="%s" ...' % (i, oCurTest.sSrc, oCurTest.afFlags,));
+
+ oCurTest.setEnvironment(oSession, oTxsSession, oTestVm);
+ if not fRc:
+ break;
+ fRc, _ = oCurTest.createSession('Test #%d' % (i,));
+ if fRc is not True:
+ fRc = reporter.error('Test #%d failed: Could not create session' % (i,));
+ break;
+
+ try:
+ oCurProgress = oCurTest.oGuest.updateGuestAdditions(oCurTest.sSrc, oCurTest.asArgs, oCurTest.afFlags);
+ except:
+ reporter.maybeErrXcpt(oCurRes.fRc, 'Updating Guest Additions exception for sSrc="%s", afFlags="%s":'
+ % (oCurTest.sSrc, oCurTest.afFlags,));
+ fRc = False;
+ else:
+ if oCurProgress is not None:
+ oWrapperProgress = vboxwrappers.ProgressWrapper(oCurProgress, self.oTstDrv.oVBoxMgr,
+ self.oTstDrv, "gctrlUpGA");
+ oWrapperProgress.wait();
+ if not oWrapperProgress.isSuccess():
+ oWrapperProgress.logResult(fIgnoreErrors = not oCurRes.fRc);
+ fRc = False;
+ else:
+ fRc = reporter.error('No progress object returned');
+
+ oCurTest.closeSession();
+ if fRc is oCurRes.fRc:
+ if fRc:
+ ## @todo Verify if Guest Additions were really updated (build, revision, ...).
+ ## @todo r=bird: Not possible since you're installing the same GAs as before...
+ ## Maybe check creation dates on certain .sys/.dll/.exe files?
+ pass;
+ else:
+ fRc = reporter.error('Test #%d failed: Got %s, expected %s' % (i, fRc, oCurRes.fRc));
+ break;
+
+ return (fRc, oTxsSession);
+
+
+
+class tdAddGuestCtrl(vbox.TestDriver): # pylint: disable=too-many-instance-attributes,too-many-public-methods
+ """
+ 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=too-many-branches,too-many-statements
+ """
+ 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=too-many-statements
+ """
+ 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:
+ fRc, oTxsSession = self.aoSubTstDrvs[0].testIt(oTestVm, oSession, oTxsSession);
+ self.terminateVmBySession(oSession);
+ else:
+ fRc = False;
+ return fRc;
+
+ def onExit(self, iRc):
+ return vbox.TestDriver.onExit(self, iRc);
+
+ 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 == 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=too-many-locals,too-many-statements,unused-argument,unused-variable
+ """
+ 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 = self.getGuestSystemShell(oTestVm);
+ asArgs = [ sCmd, '/C', 'dir', '/S', 'c:\\windows' ];
+ aEnv = [];
+ afFlags = [];
+
+ for _ in xrange(100):
+ oProc = oGuestSession.processCreate(sCmd, asArgs if self.fpApiVer >= 5.0 else asArgs[1:],
+ aEnv, afFlags, 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));
diff --git a/src/VBox/ValidationKit/tests/additions/tdAddSharedFolders1.py b/src/VBox/ValidationKit/tests/additions/tdAddSharedFolders1.py
new file mode 100755
index 00000000..c50ee4d3
--- /dev/null
+++ b/src/VBox/ValidationKit/tests/additions/tdAddSharedFolders1.py
@@ -0,0 +1,361 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+VirtualBox Validation Kit - Shared Folders #1.
+"""
+
+__copyright__ = \
+"""
+Copyright (C) 2010-2023 Oracle and/or its affiliates.
+
+This file is part of VirtualBox base platform packages, as
+available from https://www.virtualbox.org.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation, in version 3 of the
+License.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, see <https://www.gnu.org/licenses>.
+
+The contents of this file may alternatively be used under the terms
+of the Common Development and Distribution License Version 1.0
+(CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+in the VirtualBox 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.
+
+SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+"""
+__version__ = "$Revision: 155244 $"
+
+# Standard Python imports.
+import os
+import shutil
+import sys
+
+# Only the main script needs to modify the path.
+try: __file__
+except: __file__ = sys.argv[0];
+g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))));
+sys.path.append(g_ksValidationKitDir);
+
+# Validation Kit imports.
+from testdriver import reporter;
+from testdriver import base;
+from common import utils;
+
+
+class SubTstDrvAddSharedFolders1(base.SubTestDriverBase):
+ """
+ Sub-test driver for executing shared folders tests.
+ """
+
+ def __init__(self, oTstDrv):
+ base.SubTestDriverBase.__init__(self, oTstDrv, 'add-shared-folders', 'Shared Folders');
+
+ self.asTestsDef = [ 'fsperf', ];
+ self.asTests = self.asTestsDef;
+ self.asExtraArgs = [];
+ self.asGstFsPerfPaths = [
+ '${CDROM}/vboxvalidationkit/${OS/ARCH}/FsPerf${EXESUFF}',
+ '${CDROM}/${OS/ARCH}/FsPerf${EXESUFF}',
+ '${TXSDIR}/${OS/ARCH}/FsPerf${EXESUFF}',
+ '${TXSDIR}/FsPerf${EXESUFF}',
+ 'E:/vboxvalidationkit/${OS/ARCH}/FsPerf${EXESUFF}',
+ ];
+ self.sGuestSlash = '';
+
+ def parseOption(self, asArgs, iArg):
+ if asArgs[iArg] == '--add-shared-folders-tests': # 'add' as in 'additions', not the verb.
+ iArg += 1;
+ iNext = self.oTstDrv.requireMoreArgs(1, asArgs, iArg);
+ if asArgs[iArg] == 'all':
+ self.asTests = self.asTestsDef;
+ else:
+ self.asTests = asArgs[iArg].split(':');
+ for s in self.asTests:
+ if s not in self.asTestsDef:
+ raise base.InvalidOption('The "--add-shared-folders-tests" value "%s" is not valid; valid values are: %s'
+ % (s, ' '.join(self.asTestsDef)));
+ return iNext;
+ if asArgs[iArg] == '--add-shared-folders-extra-arg':
+ iArg += 1;
+ iNext = self.oTstDrv.requireMoreArgs(1, asArgs, iArg);
+ self.asExtraArgs.append(asArgs[iArg]);
+ return iNext;
+ return iArg;
+
+ def showUsage(self):
+ base.SubTestDriverBase.showUsage(self);
+ reporter.log(' --add-shared-folders-tests <t1[:t2[:]]>');
+ reporter.log(' Default: all (%s)' % (':'.join(self.asTestsDef)));
+ reporter.log(' --add-shared-folders-extra-arg <fsperf-arg>');
+ reporter.log(' Adds an extra FsPerf argument. Can be repeated.');
+
+ return True;
+
+ def mountShareEx(self, oSession, oTxsSession, sShareName, sHostPath, sGuestMountPoint, fMustSucceed):
+ """
+ Automount a shared folder in the guest, extended version.
+
+ Returns success status, based on fMustSucceed.
+ """
+ reporter.testStart('Automounting "%s"' % (sShareName,));
+
+ reporter.log2('Creating shared folder "%s" at "%s" ...' % (sShareName, sGuestMountPoint));
+ try:
+ oConsole = oSession.o.console;
+ oConsole.createSharedFolder(sShareName, sHostPath, True, True, sGuestMountPoint);
+ except:
+ if fMustSucceed:
+ reporter.errorXcpt('createSharedFolder(%s,%s,True,True,%s)' % (sShareName, sHostPath, sGuestMountPoint));
+ else:
+ reporter.log('createSharedFolder(%s,%s,True,True,%s) failed, good' % (sShareName, sHostPath, sGuestMountPoint));
+ reporter.testDone();
+ return False is fMustSucceed;
+
+ # Check whether we can see the shared folder now. Retry for 30 seconds.
+ msStart = base.timestampMilli();
+ while True:
+ fRc = oTxsSession.syncIsDir(sGuestMountPoint + self.sGuestSlash + 'candle.dir');
+ reporter.log2('candle.dir check -> %s' % (fRc,));
+ if fRc is fMustSucceed:
+ break;
+ if base.timestampMilli() - msStart > 30000:
+ reporter.error('Shared folder mounting timed out!');
+ break;
+ self.oTstDrv.sleep(1);
+
+ reporter.testDone();
+
+ return fRc == fMustSucceed;
+
+ def mountShare(self, oSession, oTxsSession, sShareName, sHostPath, sGuestMountPoint):
+ """
+ Automount a shared folder in the guest.
+
+ Returns success status.
+ """
+ return self.mountShareEx(oSession, oTxsSession, sShareName, sHostPath, sGuestMountPoint, fMustSucceed = True);
+
+ def unmountShareEx(self, oSession, oTxsSession, sShareName, sGuestMountPoint, fMustSucceed):
+ """
+ Unmounts a shared folder in the guest.
+
+ Returns success status, based on fMustSucceed.
+ """
+ reporter.log2('Autounmount');
+ try:
+ oConsole = oSession.o.console;
+ oConsole.removeSharedFolder(sShareName);
+ except:
+ if fMustSucceed:
+ reporter.errorXcpt('removeSharedFolder(%s)' % (sShareName,));
+ else:
+ reporter.log('removeSharedFolder(%s)' % (sShareName,));
+ reporter.testDone();
+ return False is fMustSucceed;
+
+ # Check whether the shared folder is gone on the guest now. Retry for 30 seconds.
+ msStart = base.timestampMilli();
+ while True:
+ fRc = oTxsSession.syncIsDir(sGuestMountPoint + self.sGuestSlash + 'candle.dir');
+ reporter.log2('candle.dir check -> %s' % (fRc,));
+ if fRc is not fMustSucceed:
+ break;
+ if base.timestampMilli() - msStart > 30000:
+ reporter.error('Shared folder unmounting timed out!');
+ fRc = False;
+ break;
+ self.oTstDrv.sleep(1);
+
+ reporter.testDone();
+
+ return fRc is not fMustSucceed;
+
+ def unmountShare(self, oSession, oTxsSession, sShareName, sGuestMountPoint):
+ """
+ Unmounts a shared folder in the guest, extended version.
+
+ Returns success status, based on fMustSucceed.
+ """
+ return self.unmountShareEx(oSession, oTxsSession, sShareName, sGuestMountPoint, fMustSucceed = 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,));
+
+ #
+ # Skip the test if before 6.0
+ #
+ if self.oTstDrv.fpApiVer < 6.0:
+ reporter.log('Requires 6.0 or later (for now)');
+ return (None, oTxsSession);
+
+ # Guess a free mount point inside the guest.
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ self.sGuestSlash = '\\';
+ else:
+ self.sGuestSlash = '/';
+
+ #
+ # Create the host directory to share. Empty except for a 'candle.dir' subdir
+ # that we use to check that it mounted correctly.
+ #
+ sShareName1 = 'shfl1';
+ sShareHostPath1 = os.path.join(self.oTstDrv.sScratchPath, sShareName1);
+ reporter.log2('Creating shared host folder "%s"...' % (sShareHostPath1,));
+ if os.path.exists(sShareHostPath1):
+ try: shutil.rmtree(sShareHostPath1);
+ except: return (reporter.errorXcpt('shutil.rmtree(%s)' % (sShareHostPath1,)), oTxsSession);
+ try: os.mkdir(sShareHostPath1);
+ except: return (reporter.errorXcpt('os.mkdir(%s)' % (sShareHostPath1,)), oTxsSession);
+ try: os.mkdir(os.path.join(sShareHostPath1, 'candle.dir'));
+ except: return (reporter.errorXcpt('os.mkdir(%s)' % (sShareHostPath1,)), oTxsSession);
+
+ # Guess a free mount point inside the guest.
+ if oTestVm.isWindows() or oTestVm.isOS2():
+ sMountPoint1 = 'V:';
+ else:
+ sMountPoint1 = '/mnt/' + sShareName1;
+
+ fRc = self.mountShare(oSession, oTxsSession, sShareName1, sShareHostPath1, sMountPoint1);
+ if fRc is not True:
+ return (False, oTxsSession); # skip the remainder if we cannot auto mount the folder.
+
+ #
+ # Run FsPerf inside the guest.
+ #
+ fSkip = 'fsperf' not in self.asTests;
+ if fSkip is False:
+ cMbFree = utils.getDiskUsage(sShareHostPath1);
+ if cMbFree >= 16:
+ reporter.log2('Free space: %u MBs' % (cMbFree,));
+ else:
+ reporter.log('Skipping FsPerf because only %u MB free on %s' % (cMbFree, sShareHostPath1,));
+ fSkip = True;
+ if fSkip is False:
+ # Common arguments:
+ asArgs = ['FsPerf', '-d', sMountPoint1 + self.sGuestSlash + 'fstestdir-1', '-s8'];
+
+ # Skip part of mmap on older windows systems without CcCoherencyFlushAndPurgeCache (>= w7).
+ reporter.log2('oTestVm.sGuestOsType=%s' % (oTestVm.sGuestOsType,));
+ if oTestVm.getNonCanonicalGuestOsType() \
+ in [ 'WindowsNT3x', 'WindowsNT4', 'Windows2000', 'WindowsXP', 'WindowsXP_64', 'Windows2003',
+ 'Windows2003_64', 'WindowsVista', 'WindowsVista_64', 'Windows2008', 'Windows2008_64']:
+ asArgs.append('--no-mmap-coherency');
+
+ # Configure I/O block sizes according to guest memory size:
+ cbMbRam = 128;
+ try: cbMbRam = oSession.o.machine.memorySize;
+ except: reporter.errorXcpt();
+ reporter.log2('cbMbRam=%s' % (cbMbRam,));
+ asArgs.append('--set-block-size=1');
+ asArgs.append('--add-block-size=512');
+ asArgs.append('--add-block-size=4096');
+ asArgs.append('--add-block-size=16384');
+ asArgs.append('--add-block-size=65536');
+ asArgs.append('--add-block-size=1048576'); # 1 MiB
+ if cbMbRam >= 512:
+ asArgs.append('--add-block-size=33554432'); # 32 MiB
+ if cbMbRam >= 768:
+ asArgs.append('--add-block-size=134217728'); # 128 MiB
+
+ # Putting lots (10000) of files in a single directory causes issues on OS X
+ # (HFS+ presumably, though could be slow disks) and some linuxes (slow disks,
+ # maybe ext2/3?). So, generally reduce the file count to 4096 everywhere
+ # since we're not here to test the host file systems, and 3072 on macs.
+ if utils.getHostOs() in [ 'darwin', ]:
+ asArgs.append('--many-files=3072');
+ elif utils.getHostOs() in [ 'linux', ]:
+ asArgs.append('--many-files=4096');
+
+ # Add the extra arguments from the command line and kick it off:
+ asArgs.extend(self.asExtraArgs);
+
+ # Run FsPerf:
+ reporter.log2('Starting guest FsPerf (%s)...' % (asArgs,));
+ sFsPerfPath = self._locateGstFsPerf(oTxsSession);
+
+ ## @todo For some odd reason the combined GA/VaKit .ISO (by IPRT/fs/isomakercmd)
+ # sometimes (?) contains FsPerf as non-executable (-r--r--r-- 1 root root) on Linux.
+ #
+ # So work around this for now by copying the desired FsPerf binary to the temp directory,
+ # make it executable and execute it from there.
+ fISOMakerCmdIsBuggy = oTestVm.isLinux();
+ if fISOMakerCmdIsBuggy:
+ sFsPerfPathTemp = oTestVm.pathJoin(self.oTstDrv.getGuestTempDir(oTestVm), 'FsPerf${EXESUFF}');
+ if oTestVm.isWindows() \
+ or oTestVm.isOS2():
+ sCopy = self.oTstDrv.getGuestSystemShell();
+ sCopyArgs = ( sCopy, "/C", "copy", "/Y", sFsPerfPath, sFsPerfPathTemp );
+ else:
+ sCopy = oTestVm.pathJoin(self.oTstDrv.getGuestSystemDir(oTestVm), 'cp');
+ sCopyArgs = ( sCopy, "-a", "-v", sFsPerfPath, sFsPerfPathTemp );
+ fRc = self.oTstDrv.txsRunTest(oTxsSession, 'Copying FsPerf', 60 * 1000,
+ sCopy, sCopyArgs, fCheckSessionStatus = True);
+ fRc = fRc and oTxsSession.syncChMod(sFsPerfPathTemp, 0o755);
+ if fRc:
+ sFsPerfPath = sFsPerfPathTemp;
+
+ fRc = self.oTstDrv.txsRunTest(oTxsSession, 'Running FsPerf', 90 * 60 * 1000, sFsPerfPath, asArgs,
+ fCheckSessionStatus = True);
+ reporter.log2('FsPerf -> %s' % (fRc,));
+ if fRc:
+ # Do a bit of diagnosis to find out why this failed.
+ if not oTestVm.isWindows() \
+ and not oTestVm.isOS2():
+ sCmdLs = oTestVm.pathJoin(self.oTstDrv.getGuestSystemDir(oTestVm), 'ls');
+ oTxsSession.syncExec(sCmdLs, (sCmdLs, "-al", sFsPerfPath), fIgnoreErrors = True);
+ oTxsSession.syncExec(sCmdLs, (sCmdLs, "-al", "-R", "/opt"), fIgnoreErrors = True);
+ oTxsSession.syncExec(sCmdLs, (sCmdLs, "-al", "-R", "/media/cdrom"), fIgnoreErrors = True);
+
+ sTestDir = os.path.join(sShareHostPath1, 'fstestdir-1');
+ if os.path.exists(sTestDir):
+ fRc = reporter.errorXcpt('test directory lingers: %s' % (sTestDir,));
+ try: shutil.rmtree(sTestDir);
+ except: fRc = reporter.errorXcpt('shutil.rmtree(%s)' % (sTestDir,));
+ else:
+ reporter.testStart('FsPerf');
+ reporter.testDone(fSkip or fRc is None);
+
+ #
+ # Check if auto-unmounting works.
+ #
+ if fRc is True:
+ fRc = self.unmountShare(oSession, oTxsSession, sShareName1, sMountPoint1);
+
+ ## @todo Add tests for multiple automount shares, random unmounting, reboot test.
+
+ return (fRc, oTxsSession);
+
+ def _locateGstFsPerf(self, oTxsSession):
+ """
+ Returns guest side path to FsPerf.
+ """
+ for sFsPerfPath in self.asGstFsPerfPaths:
+ if oTxsSession.syncIsFile(sFsPerfPath):
+ reporter.log('Using FsPerf at "%s"' % (sFsPerfPath,));
+ return sFsPerfPath;
+ reporter.log('Unable to find guest FsPerf in any of these places: %s' % ('\n '.join(self.asGstFsPerfPaths),));
+ return self.asGstFsPerfPaths[0];
+
+
+
+if __name__ == '__main__':
+ reporter.error('Cannot run standalone, use tdAddBasic1.py');
+ sys.exit(1);