feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
271405e08ebc7bb9d4d2cfcbf0b6c0cb656d2e60
qt-creator/tests/auto/utils/process/tst_process.cpp

1541 lines
56 KiB
C++
Raw Normal View History

Use SPDX license identifiers Replace the current license disclaimer in files by a SPDX-License-Identifier. Task-number: QTBUG-67283 Change-Id: I708fd1f9f2b73d60f57cc3568646929117825813 Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-08-19 15:59:36 +02:00
// Copyright (C) 2016 The Qt Company Ltd.
Remove GPL-3.0+ from license identifiers Since we also license under GPL-3.0 WITH Qt-GPL-exception-1.0, this applies only to a hypothetical newer version of GPL, that doesn't exist yet. If such a version emerges, we can still decide to relicense... While at it, replace (deprecated) GPL-3.0 with more explicit GPL-3.0-only Change was done by running find . -type f -exec perl -pi -e "s/LicenseRef-Qt-Commercial OR GPL-3.0\+ OR GPL-3.0 WITH Qt-GPL-exception-1.0/LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0/g" {} \; Change-Id: I5097e6ce8d10233993ee30d7e25120e2659eb10b Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-12-21 10:12:09 +01:00
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
#include "processtestapp/processtestapp.h"
Fix a path to process launcher in tst_qtcprocess Change-Id: I1de71ff51ffdcc02a2ec8dd117a26625514cd309 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:13:10 +01:00
#include <app/app_version.h>
Utils: Merge QtcProcess line reading functions - Pass everything through the codec. - Always emit even incomplete last lines when the process finishes. - Don't store raw output when line-wise processing is requested. Change-Id: I5cc30ad0d7ab79387bfb00b48ff957468a1bd004 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-14 15:09:11 +02:00
#include <utils/environment.h>
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
#include <utils/hostosinfo.h>
Start and stop the process launcher in tst_qtcprocess Change-Id: Ib28450d10c699abe3964f8bef2ff24baae0074f7 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-13 13:30:43 +02:00
#include <utils/launcherinterface.h>
Utils: Rename qtcprocess.{cpp,h} -> process.{cpp,h} Follows QtcProcess -> Process rename. Change-Id: I97235a9a40cb7fd52944515b7ab878d96528f919 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2023-05-03 17:05:35 +02:00
#include <utils/process.h>
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
#include <utils/processinfo.h>
tst_QtcProcess: Test all waitFor...() methods Test all waitFor...() methods when trying to run a non-existing executable. Change-Id: I958e1dd5ac1731788b6d0e94d9eb277c9e15c4e4 Reviewed-by: hjk <hjk@qt.io>
2022-06-29 18:41:50 +02:00
#include <utils/processinterface.h>
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
#include <utils/qtcassert.h>
Introduce Utils::Singleton Introduce Utils::Singleton class and Utils::SingletonWithOptionalDependencies class template that helps implementing singletons that depend on other singletons. It's guaranteed that whenever singleton B depends on singleton A, than A is always created before B is being created, and that the order of destruction is always opposite to the order of creation. Dependencies of singleton are listed as template arguments for SingletonWithOptionalDependencies class template. The first argument of SingletonWithOptionalDependencies class template is always a singleton class itself. Prepare a common interface for all singleton subclasses: SingletonSubClass *SingletonWithOptionalDependencies::instance(); Make instantiating singletons and its dependencies thread-safe. Create singletons on demand (only if some code needs them). It's not needed anymore to explicitly instantiate all required singletons in tests. Make it possible (and thread-safe) to instantiate ProcessReaper and LauncherInterface singletons in non-main threads. Make the following dependencies between existing singletons: SshConnectionManager depends on: -> LauncherInterface depends on: -> ProcessReaper Change-Id: Iefaacab561c2b3dcf07e7fafbb87339ea6a15278 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-17 16:32:50 +02:00
#include <utils/singleton.h>
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
#include <utils/stringutils.h>
Fix a path to process launcher in tst_qtcprocess Change-Id: I1de71ff51ffdcc02a2ec8dd117a26625514cd309 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:13:10 +01:00
#include <utils/temporarydirectory.h>
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
#include <QElapsedTimer>
Utils: Merge QtcProcess line reading functions - Pass everything through the codec. - Always emit even incomplete last lines when the process finishes. - Don't store raw output when line-wise processing is requested. Change-Id: I5cc30ad0d7ab79387bfb00b48ff957468a1bd004 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-14 15:09:11 +02:00
#include <QRegularExpression>
Removed module names from #include directives. Getting the #include directives ready for Qt5. This includes the new-project wizards. Change-Id: Ia9261f1e8faec06b9285b694d2b7e9a095978d2b Reviewed-by: Eike Ziller <eike.ziller@nokia.com>
2012-02-15 10:42:41 +01:00
#include <QtTest>
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
#include <iostream>
Utils: Merge QtcProcess line reading functions - Pass everything through the codec. - Always emit even incomplete last lines when the process finishes. - Don't store raw output when line-wise processing is requested. Change-Id: I5cc30ad0d7ab79387bfb00b48ff957468a1bd004 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-14 15:09:11 +02:00
#include <fstream>
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
using namespace Utils;
Ensure we never encounter the message about destroying QProcess Until we remove the process launcher / process reaper. Change-Id: I9c68c40c3c856c0a515277b69fc3084ba2addbee Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-21 18:02:53 +01:00
// This handler is inspired by the one used in qtbase/tests/auto/corelib/io/qfile/tst_qfile.cpp
class MessageHandler {
public:
MessageHandler(QtMessageHandler messageHandler = handler)
{
s_oldMessageHandler = qInstallMessageHandler(messageHandler);
}
~MessageHandler()
{
qInstallMessageHandler(s_oldMessageHandler);
}
static int destroyCount()
{
return s_destroyCount;
}
protected:
static void handler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
if (msg.contains("QProcess: Destroyed while process")
&& msg.contains("is still running.")) {
++s_destroyCount;
}
// Defer to old message handler.
if (s_oldMessageHandler)
s_oldMessageHandler(type, context, msg);
}
static QtMessageHandler s_oldMessageHandler;
static int s_destroyCount;
};
int MessageHandler::s_destroyCount = 0;
QtMessageHandler MessageHandler::s_oldMessageHandler = 0;
Fix tests build Change-Id: Ia3b9c3e30b7d5e62413d1f8c477e5a68b9c90e50 Reviewed-by: hjk <hjk121@nokiamail.com>
2014-06-26 15:03:22 +04:00
class MacroMapExpander : public AbstractMacroExpander {
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
public:
Tests: Fix compile Broke with 4e96f2ce. Change-Id: I7c467cc92cc8444bd3b1ef41eebff089668a0f31 Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
2017-06-21 07:34:46 +02:00
virtual bool resolveMacro(const QString &name, QString *ret, QSet<AbstractMacroExpander*> &seen)
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
Tests: Fix compile Broke with 4e96f2ce. Change-Id: I7c467cc92cc8444bd3b1ef41eebff089668a0f31 Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
2017-06-21 07:34:46 +02:00
// loop prevention
const int count = seen.count();
seen.insert(this);
if (seen.count() == count)
return false;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QHash<QString, QString>::const_iterator it = m_map.constFind(name);
if (it != m_map.constEnd()) {
*ret = it.value();
return true;
}
return false;
}
void insert(const QString &key, const QString &value) { m_map.insert(key, value); }
private:
QHash<QString, QString> m_map;
};
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
static constexpr char s_skipTerminateOnWindows[] =
"Windows implementation of this test is lacking handling of WM_CLOSE message.";
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
class tst_Process : public QObject
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
Q_OBJECT
private slots:
void initTestCase();
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
Utils: Test QtcProcess default environment Change-Id: I62f56bd070ec531462ad3dd4e39cf6708115c7ba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2023-03-20 11:30:07 +01:00
void testEnv()
{
if (HostOsInfo::isWindowsHost())
QSKIP("Skipping env test on Windows");
QProcess qproc;
FilePath envPath = Environment::systemEnvironment().searchInPath("env");
qproc.setProgram(envPath.nativePath());
qproc.start();
qproc.waitForFinished();
QByteArray qoutput = qproc.readAllStandardOutput() + qproc.readAllStandardError();
qDebug() << "QProcess output:" << qoutput;
QCOMPARE(qproc.exitCode(), 0);
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
Process proc;
proc.setCommand({envPath, {}});
proc.runBlocking();
QCOMPARE(proc.exitCode(), 0);
const QByteArray output = proc.readAllRawStandardOutput() + proc.readAllRawStandardError();
qDebug() << "Process output:" << output;
Utils: Test QtcProcess default environment Change-Id: I62f56bd070ec531462ad3dd4e39cf6708115c7ba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2023-03-20 11:30:07 +01:00
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
QCOMPARE(output.size() > 0, qoutput.size() > 0);
Utils: Test QtcProcess default environment Change-Id: I62f56bd070ec531462ad3dd4e39cf6708115c7ba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2023-03-20 11:30:07 +01:00
}
Deviceshell: Base64 not found fallback If no base64 is installed on the target, the shell script cannot work. Previously this would lead to the shell functions being unavailable. This change adds a fallback path. In case no base64 is found, the shell will create a process for each run request instead. This is much slower than the shell script, but acceptable as a fallback. Change-Id: I70591d7e610c4e1c3c258a8e4bef354221d05cb9 Reviewed-by: hjk <hjk@qt.io>
2022-08-10 14:38:06 +02:00
void multiRead();
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
void splitArgs_data();
void splitArgs();
void prepareArgs_data();
void prepareArgs();
void prepareArgsEnv_data();
void prepareArgsEnv();
void expandMacros_data();
void expandMacros();
void iterations_data();
void iterations();
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
void iteratorEditsWindows();
void iteratorEditsLinux();
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
void exitCode_data();
void exitCode();
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
void runBlockingStdOut_data();
void runBlockingStdOut();
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
void runBlockingSignal_data();
void runBlockingSignal();
Utils: Fix splitting in ChannelBuffer::takeFirstLine() Escape the '\r' Change-Id: I8cee40dc4a65f893f1a11c7cf066777498c37339 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-09 01:00:19 +02:00
void lineCallback();
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
void lineSignal();
Utils: fix QProcess backend on Windows Do not return false from QtcProces::waitForStarted if the process is already running. This causes mayor issues on windows since QProcess directly emits started and therefore switches to the running state after calling QProcess::start. Change-Id: I4604b08a59918d3df11c8a174b57e1e483e78a0d Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
2022-04-25 07:18:00 +02:00
void waitForStartedAfterStarted();
void waitForStartedAfterStarted2();
Rename test case, use both verbs in passive voice waitForStartAndFinished -> waitForStartedAndFinished. Change-Id: I44440a21cd91105b84227e13d1ea3d5b9490148f Reviewed-by: Artem Sokolovskii <artem.sokolovskii@qt.io> Reviewed-by: hjk <hjk@qt.io>
2021-08-25 09:32:00 +02:00
void waitForStartedAndFinished();
tst_QtcProcess: Test all waitFor...() methods Test all waitFor...() methods when trying to run a non-existing executable. Change-Id: I958e1dd5ac1731788b6d0e94d9eb277c9e15c4e4 Reviewed-by: hjk <hjk@qt.io>
2022-06-29 18:41:50 +02:00
void notRunningAfterStartingNonExistingProgram_data();
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
void notRunningAfterStartingNonExistingProgram();
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
void channelForwarding_data();
void channelForwarding();
void mergedChannels_data();
void mergedChannels();
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
void destroyBlockingProcess_data();
void destroyBlockingProcess();
Flush finished() signal when waitForReadyRead() was called Apparently the QProcess behaves like that. Change-Id: Idb1993b8abccbd7943582d41bd456eacc9a1c185 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2021-11-04 10:27:08 +01:00
void flushFinishedWhileWaitingForReadyRead();
tst_QtcProcess: Don't use errorOccurred() in tests Change-Id: I71657e111ab09b599480874ed22e714142697c19 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: David Schulz <david.schulz@qt.io>
2022-06-22 15:17:25 +02:00
void crash();
QtcProcess: Add a test for crashing app Ensure that when waitForFinished() didn't timeout but the process has terminated, it returns true, like QProcess does, in contrary to what QProcess' documentation says. Change-Id: I6af5034f4df7fc2e14a83bab74334a8abefe7a0f Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-03-21 16:24:22 +01:00
void crashAfterOneSecond();
tst_QtcProcess: Add a test that invokes a process recursively After the required depth of recursion is met, the most nested process waits for one seconds and crashes. Change-Id: I8d9b359459fc7aa1983734685e5c5f19eb49ee94 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 15:02:23 +02:00
void recursiveCrashingProcess();
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
void recursiveBlockingProcess();
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
void quitBlockingProcess_data();
void quitBlockingProcess();
tst_qtcprocess: Add testPipe Change-Id: I5b54231d201960eb6909780e4a2c5b9860b7e523 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Marcus Tillmanns <marcus.tillmanns@qt.io>
2023-01-23 13:14:35 +01:00
void tarPipe();
Tests: Add a test to feed shells via stdin Change-Id: I7e19537d0a3015aeb329849758cc92da17a67606 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2023-04-14 10:00:08 +02:00
void stdinToShell();
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Start and stop the process launcher in tst_qtcprocess Change-Id: Ib28450d10c699abe3964f8bef2ff24baae0074f7 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-13 13:30:43 +02:00
void cleanupTestCase();
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
private:
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
void iteratorEditsHelper(OsType osType);
Environment envWindows;
Environment envLinux;
MacroMapExpander mxWin;
MacroMapExpander mxUnix;
support tilde expansion under unix Task-number: QTCREATORBUG-4239
2011-03-28 14:50:32 +02:00
QString homeStr;
QString home;
Ensure we never encounter the message about destroying QProcess Until we remove the process launcher / process reaper. Change-Id: I9c68c40c3c856c0a515277b69fc3084ba2addbee Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-21 18:02:53 +01:00
MessageHandler *msgHandler = nullptr;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
};
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::initTestCase()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
Ensure we never encounter the message about destroying QProcess Until we remove the process launcher / process reaper. Change-Id: I9c68c40c3c856c0a515277b69fc3084ba2addbee Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-21 18:02:53 +01:00
msgHandler = new MessageHandler;
Fix a path to process launcher in tst_qtcprocess Change-Id: I1de71ff51ffdcc02a2ec8dd117a26625514cd309 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:13:10 +01:00
Utils::TemporaryDirectory::setMasterTemporaryDirectory(QDir::tempPath() + "/"
+ Core::Constants::IDE_CASED_ID + "-XXXXXX");
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
const QString libExecPath(qApp->applicationDirPath() + '/'
+ QLatin1String(TEST_RELATIVE_LIBEXEC_PATH));
LauncherInterface::setPathToLauncher(libExecPath);
SubProcessConfig::setPathToProcessTestApp(QLatin1String(PROCESS_TESTAPP));
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
support tilde expansion under unix Task-number: QTCREATORBUG-4239
2011-03-28 14:50:32 +02:00
homeStr = QLatin1String("@HOME@");
home = QDir::homePath();
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QStringList env;
env << "empty=" << "word=hi" << "words=hi ho" << "spacedwords= hi ho sucker ";
envWindows = Environment(env, OsTypeWindows);
envLinux = Environment(env, OsTypeLinux);
mxWin.insert("a", "hi");
mxWin.insert("aa", "hi ho");
mxWin.insert("b", "h\\i");
mxWin.insert("c", "\\hi");
mxWin.insert("d", "hi\\");
mxWin.insert("ba", "h\\i ho");
mxWin.insert("ca", "\\hi ho");
mxWin.insert("da", "hi ho\\");
mxWin.insert("e", "h\"i");
mxWin.insert("f", "\"hi");
mxWin.insert("g", "hi\"");
mxWin.insert("h", "h\\\"i");
mxWin.insert("i", "\\\"hi");
mxWin.insert("j", "hi\\\"");
mxWin.insert("k", "&special;");
mxWin.insert("x", "\\");
mxWin.insert("y", "\"");
mxWin.insert("z", "");
mxUnix.insert("a", "hi");
mxUnix.insert("b", "hi ho");
mxUnix.insert("c", "&special;");
mxUnix.insert("d", "h\\i");
mxUnix.insert("e", "h\"i");
mxUnix.insert("f", "h'i");
mxUnix.insert("z", "");
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::cleanupTestCase()
Start and stop the process launcher in tst_qtcprocess Change-Id: Ib28450d10c699abe3964f8bef2ff24baae0074f7 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-13 13:30:43 +02:00
{
Introduce Utils::Singleton Introduce Utils::Singleton class and Utils::SingletonWithOptionalDependencies class template that helps implementing singletons that depend on other singletons. It's guaranteed that whenever singleton B depends on singleton A, than A is always created before B is being created, and that the order of destruction is always opposite to the order of creation. Dependencies of singleton are listed as template arguments for SingletonWithOptionalDependencies class template. The first argument of SingletonWithOptionalDependencies class template is always a singleton class itself. Prepare a common interface for all singleton subclasses: SingletonSubClass *SingletonWithOptionalDependencies::instance(); Make instantiating singletons and its dependencies thread-safe. Create singletons on demand (only if some code needs them). It's not needed anymore to explicitly instantiate all required singletons in tests. Make it possible (and thread-safe) to instantiate ProcessReaper and LauncherInterface singletons in non-main threads. Make the following dependencies between existing singletons: SshConnectionManager depends on: -> LauncherInterface depends on: -> ProcessReaper Change-Id: Iefaacab561c2b3dcf07e7fafbb87339ea6a15278 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-17 16:32:50 +02:00
Utils::Singleton::deleteAll();
Ensure we never encounter the message about destroying QProcess Until we remove the process launcher / process reaper. Change-Id: I9c68c40c3c856c0a515277b69fc3084ba2addbee Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-21 18:02:53 +01:00
const int destroyCount = msgHandler->destroyCount();
delete msgHandler;
if (destroyCount)
qDebug() << "Received" << destroyCount << "messages about destroying running QProcess!";
QCOMPARE(destroyCount, 0);
Start and stop the process launcher in tst_qtcprocess Change-Id: Ib28450d10c699abe3964f8bef2ff24baae0074f7 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-13 13:30:43 +02:00
}
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
Q_DECLARE_METATYPE(ProcessArgs::SplitError)
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
Q_DECLARE_METATYPE(Utils::OsType)
Compile fix Amends cfe8b7ad88ca57a76fd00f7757ccf10d1322ddd2 Change-Id: I4a570c481cf631ee6650a5c9d3b0f0540df88671 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2022-03-14 10:31:34 +01:00
Q_DECLARE_METATYPE(Utils::ProcessResult)
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::multiRead()
Deviceshell: Base64 not found fallback If no base64 is installed on the target, the shell script cannot work. Previously this would lead to the shell functions being unavailable. This change adds a fallback path. In case no base64 is found, the shell will create a process for each run request instead. This is much slower than the shell script, but acceptable as a fallback. Change-Id: I70591d7e610c4e1c3c258a8e4bef354221d05cb9 Reviewed-by: hjk <hjk@qt.io>
2022-08-10 14:38:06 +02:00
{
Process Test: Skip unix only test on windows Change-Id: Ie019af53a6b41784275d4b64b57a9c3bd493a24c Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-09-06 15:47:30 +02:00
if (HostOsInfo::isWindowsHost())
QSKIP("This test uses /bin/sh.");
Deviceshell: Base64 not found fallback If no base64 is installed on the target, the shell script cannot work. Previously this would lead to the shell functions being unavailable. This change adds a fallback path. In case no base64 is found, the shell will create a process for each run request instead. This is much slower than the shell script, but acceptable as a fallback. Change-Id: I70591d7e610c4e1c3c258a8e4bef354221d05cb9 Reviewed-by: hjk <hjk@qt.io>
2022-08-10 14:38:06 +02:00
QByteArray buffer;
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Deviceshell: Base64 not found fallback If no base64 is installed on the target, the shell script cannot work. Previously this would lead to the shell functions being unavailable. This change adds a fallback path. In case no base64 is found, the shell will create a process for each run request instead. This is much slower than the shell script, but acceptable as a fallback. Change-Id: I70591d7e610c4e1c3c258a8e4bef354221d05cb9 Reviewed-by: hjk <hjk@qt.io>
2022-08-10 14:38:06 +02:00
process.setCommand({"/bin/sh", {}});
process.setProcessChannelMode(QProcess::SeparateChannels);
process.setProcessMode(Utils::ProcessMode::Writer);
process.start();
QVERIFY(process.waitForStarted());
process.writeRaw("echo hi\n");
QVERIFY(process.waitForReadyRead(1000));
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
buffer = process.readAllRawStandardOutput();
Deviceshell: Base64 not found fallback If no base64 is installed on the target, the shell script cannot work. Previously this would lead to the shell functions being unavailable. This change adds a fallback path. In case no base64 is found, the shell will create a process for each run request instead. This is much slower than the shell script, but acceptable as a fallback. Change-Id: I70591d7e610c4e1c3c258a8e4bef354221d05cb9 Reviewed-by: hjk <hjk@qt.io>
2022-08-10 14:38:06 +02:00
QCOMPARE(buffer, QByteArray("hi\n"));
process.writeRaw("echo you\n");
QVERIFY(process.waitForReadyRead(1000));
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
buffer = process.readAllRawStandardOutput();
Deviceshell: Base64 not found fallback If no base64 is installed on the target, the shell script cannot work. Previously this would lead to the shell functions being unavailable. This change adds a fallback path. In case no base64 is found, the shell will create a process for each run request instead. This is much slower than the shell script, but acceptable as a fallback. Change-Id: I70591d7e610c4e1c3c258a8e4bef354221d05cb9 Reviewed-by: hjk <hjk@qt.io>
2022-08-10 14:38:06 +02:00
QCOMPARE(buffer, QByteArray("you\n"));
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::splitArgs_data()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QTest::addColumn<QString>("in");
QTest::addColumn<QString>("out");
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
QTest::addColumn<ProcessArgs::SplitError>("err");
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QTest::addColumn<Utils::OsType>("os");
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
static const struct {
const char * const in;
const char * const out;
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
const ProcessArgs::SplitError err;
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
const OsType os;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
} vals[] = {
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
{"", "", ProcessArgs::SplitOk, OsTypeWindows},
{" ", "", ProcessArgs::SplitOk, OsTypeWindows},
{"hi", "hi", ProcessArgs::SplitOk, OsTypeWindows},
{"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
{" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
{"\"hi ho\" \"hi\" ho ", "\"hi ho\" hi ho", ProcessArgs::SplitOk, OsTypeWindows},
{"\\", "\\", ProcessArgs::SplitOk, OsTypeWindows},
{"\\\"", "\"\"\\^\"\"\"", ProcessArgs::SplitOk, OsTypeWindows},
{"\"hi\"\"\"ho\"", "\"hi\"\\^\"\"ho\"", ProcessArgs::SplitOk, OsTypeWindows},
{"\\\\\\\"", "\"\"\\\\\\^\"\"\"", ProcessArgs::SplitOk, OsTypeWindows},
{" ^^ ", "\"^^\"", ProcessArgs::SplitOk, OsTypeWindows},
{"hi\"", "", ProcessArgs::BadQuoting, OsTypeWindows},
{"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeWindows},
{"%var%", "%var%", ProcessArgs::SplitOk, OsTypeWindows},
{"", "", ProcessArgs::SplitOk, OsTypeLinux},
{" ", "", ProcessArgs::SplitOk, OsTypeLinux},
{"hi", "hi", ProcessArgs::SplitOk, OsTypeLinux},
{"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{"'hi ho' \"hi\" ho ", "'hi ho' hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{" \\ ", "' '", ProcessArgs::SplitOk, OsTypeLinux},
{" \\\" ", "'\"'", ProcessArgs::SplitOk, OsTypeLinux},
{" '\"' ", "'\"'", ProcessArgs::SplitOk, OsTypeLinux},
{" \"\\\"\" ", "'\"'", ProcessArgs::SplitOk, OsTypeLinux},
{"hi'", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"$var", "'$var'", ProcessArgs::SplitOk, OsTypeLinux},
{"~", "@HOME@", ProcessArgs::SplitOk, OsTypeLinux},
{"~ foo", "@HOME@ foo", ProcessArgs::SplitOk, OsTypeLinux},
{"foo ~", "foo @HOME@", ProcessArgs::SplitOk, OsTypeLinux},
{"~/foo", "@HOME@/foo", ProcessArgs::SplitOk, OsTypeLinux},
{"~foo", "'~foo'", ProcessArgs::SplitOk, OsTypeLinux}
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
};
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
QString out = QString::fromLatin1(vals[i].out);
if (vals[i].os == OsTypeLinux)
out.replace(homeStr, home);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
<< out << vals[i].err << vals[i].os;
}
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::splitArgs()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QFETCH(QString, in);
QFETCH(QString, out);
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
QFETCH(ProcessArgs::SplitError, err);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QFETCH(Utils::OsType, os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::SplitError outerr;
QString outstr = ProcessArgs::joinArgs(ProcessArgs::splitArgs(in, os, false, &outerr), os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(outerr, err);
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
if (err == ProcessArgs::SplitOk)
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(outstr, out);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::prepareArgs_data()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QTest::addColumn<QString>("in");
QTest::addColumn<QString>("out");
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
QTest::addColumn<ProcessArgs::SplitError>("err");
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QTest::addColumn<OsType>("os");
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
static const struct {
const char * const in;
const char * const out;
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
const ProcessArgs::SplitError err;
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
const OsType os;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
} vals[] = {
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
{" ", " ", ProcessArgs::SplitOk, OsTypeWindows},
{"", "", ProcessArgs::SplitOk, OsTypeWindows},
{"hi", "hi", ProcessArgs::SplitOk, OsTypeWindows},
{"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
{" hi ho ", " hi ho ", ProcessArgs::SplitOk, OsTypeWindows},
{"\"hi ho\" \"hi\" ho ", "\"hi ho\" \"hi\" ho ", ProcessArgs::SplitOk, OsTypeWindows},
{"\\", "\\", ProcessArgs::SplitOk, OsTypeWindows},
{"\\\"", "\\\"", ProcessArgs::SplitOk, OsTypeWindows},
{"\"hi\"\"ho\"", "\"hi\"\"ho\"", ProcessArgs::SplitOk, OsTypeWindows},
{"\\\\\\\"", "\\\\\\\"", ProcessArgs::SplitOk, OsTypeWindows},
{"^^", "^", ProcessArgs::SplitOk, OsTypeWindows},
{"hi\"", "hi\"", ProcessArgs::SplitOk, OsTypeWindows},
{"hi\"dood", "hi\"dood", ProcessArgs::SplitOk, OsTypeWindows},
{"%var%", "", ProcessArgs::FoundMeta, OsTypeWindows},
{"echo hi > file", "", ProcessArgs::FoundMeta, OsTypeWindows},
{"", "", ProcessArgs::SplitOk, OsTypeLinux},
{" ", "", ProcessArgs::SplitOk, OsTypeLinux},
{"hi", "hi", ProcessArgs::SplitOk, OsTypeLinux},
{"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{"'hi ho' \"hi\" ho ", "'hi ho' hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{" \\ ", "' '", ProcessArgs::SplitOk, OsTypeLinux},
{"hi'", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"$var", "", ProcessArgs::FoundMeta, OsTypeLinux},
{"~", "@HOME@", ProcessArgs::SplitOk, OsTypeLinux},
{"~ foo", "@HOME@ foo", ProcessArgs::SplitOk, OsTypeLinux},
{"~/foo", "@HOME@/foo", ProcessArgs::SplitOk, OsTypeLinux},
{"~foo", "", ProcessArgs::FoundMeta, OsTypeLinux}
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
};
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
QString out = QString::fromLatin1(vals[i].out);
if (vals[i].os == OsTypeLinux)
out.replace(homeStr, home);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
<< out << vals[i].err << vals[i].os;
}
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::prepareArgs()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QFETCH(QString, in);
QFETCH(QString, out);
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
QFETCH(ProcessArgs::SplitError, err);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QFETCH(OsType, os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::SplitError outerr;
ProcessArgs args = ProcessArgs::prepareArgs(in, &outerr, os);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QString outstr = args.toString();
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(outerr, err);
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
if (err == ProcessArgs::SplitOk)
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(outstr, out);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::prepareArgsEnv_data()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QTest::addColumn<QString>("in");
QTest::addColumn<QString>("out");
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
QTest::addColumn<ProcessArgs::SplitError>("err");
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QTest::addColumn<OsType>("os");
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
static const struct {
const char * const in;
const char * const out;
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
const ProcessArgs::SplitError err;
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
const OsType os;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
} vals[] = {
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
{" ", " ", ProcessArgs::SplitOk, OsTypeWindows},
{"", "", ProcessArgs::SplitOk, OsTypeWindows},
{"hi", "hi", ProcessArgs::SplitOk, OsTypeWindows},
{"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
{" hi ho ", " hi ho ", ProcessArgs::SplitOk, OsTypeWindows},
{"\"hi ho\" \"hi\" ho ", "\"hi ho\" \"hi\" ho ", ProcessArgs::SplitOk, OsTypeWindows},
{"\\", "\\", ProcessArgs::SplitOk, OsTypeWindows},
{"\\\"", "\\\"", ProcessArgs::SplitOk, OsTypeWindows},
{"\"hi\"\"ho\"", "\"hi\"\"ho\"", ProcessArgs::SplitOk, OsTypeWindows},
{"\\\\\\\"", "\\\\\\\"", ProcessArgs::SplitOk, OsTypeWindows},
{"^^", "^", ProcessArgs::SplitOk, OsTypeWindows},
{"hi\"", "hi\"", ProcessArgs::SplitOk, OsTypeWindows},
{"hi\"dood", "hi\"dood", ProcessArgs::SplitOk, OsTypeWindows},
{"%empty%", "%empty%", ProcessArgs::SplitOk, OsTypeWindows}, // Yep, no empty variables on Windows.
{"%word%", "hi", ProcessArgs::SplitOk, OsTypeWindows},
{" %word% ", " hi ", ProcessArgs::SplitOk, OsTypeWindows},
{"%words%", "hi ho", ProcessArgs::SplitOk, OsTypeWindows},
{"%nonsense%words%", "%nonsensehi ho", ProcessArgs::SplitOk, OsTypeWindows},
{"fail%nonsense%words%", "fail%nonsensehi ho", ProcessArgs::SplitOk, OsTypeWindows},
{"%words%words%", "hi howords%", ProcessArgs::SplitOk, OsTypeWindows},
{"%words%%words%", "hi hohi ho", ProcessArgs::SplitOk, OsTypeWindows},
{"echo hi > file", "", ProcessArgs::FoundMeta, OsTypeWindows},
{"", "", ProcessArgs::SplitOk, OsTypeLinux},
{" ", "", ProcessArgs::SplitOk, OsTypeLinux},
{"hi", "hi", ProcessArgs::SplitOk, OsTypeLinux},
{"hi ho", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{" hi ho ", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{"'hi ho' \"hi\" ho ", "'hi ho' hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{" \\ ", "' '", ProcessArgs::SplitOk, OsTypeLinux},
{"hi'", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"hi\"dood", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"$empty", "", ProcessArgs::SplitOk, OsTypeLinux},
{"$word", "hi", ProcessArgs::SplitOk, OsTypeLinux},
{" $word ", "hi", ProcessArgs::SplitOk, OsTypeLinux},
{"${word}", "hi", ProcessArgs::SplitOk, OsTypeLinux},
{" ${word} ", "hi", ProcessArgs::SplitOk, OsTypeLinux},
{"$words", "hi ho", ProcessArgs::SplitOk, OsTypeLinux},
{"$spacedwords", "hi ho sucker", ProcessArgs::SplitOk, OsTypeLinux},
{"hi${empty}ho", "hiho", ProcessArgs::SplitOk, OsTypeLinux},
{"hi${words}ho", "hihi hoho", ProcessArgs::SplitOk, OsTypeLinux},
{"hi${spacedwords}ho", "hi hi ho sucker ho", ProcessArgs::SplitOk, OsTypeLinux},
{"${", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"${var", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"${var ", "", ProcessArgs::FoundMeta, OsTypeLinux},
{"\"hi${words}ho\"", "'hihi hoho'", ProcessArgs::SplitOk, OsTypeLinux},
{"\"hi${spacedwords}ho\"", "'hi hi ho sucker ho'", ProcessArgs::SplitOk, OsTypeLinux},
{"\"${", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"\"${var", "", ProcessArgs::BadQuoting, OsTypeLinux},
{"\"${var ", "", ProcessArgs::FoundMeta, OsTypeLinux},
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
};
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
QString out = QString::fromLatin1(vals[i].out);
if (vals[i].os == OsTypeLinux)
out.replace(homeStr, home);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
<< out << vals[i].err << vals[i].os;
}
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::prepareArgsEnv()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QFETCH(QString, in);
QFETCH(QString, out);
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
QFETCH(ProcessArgs::SplitError, err);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QFETCH(OsType, os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::SplitError outerr;
ProcessArgs args = ProcessArgs::prepareArgs(in, &outerr, os, os == OsTypeLinux ? &envLinux : &envWindows);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QString outstr = args.toString();
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(outerr, err);
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
if (err == ProcessArgs::SplitOk)
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(outstr, out);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::expandMacros_data()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QTest::addColumn<QString>("in");
QTest::addColumn<QString>("out");
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QTest::addColumn<OsType>("os");
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QChar sp(QLatin1Char(' '));
static const struct {
const char * const in;
const char * const out;
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
OsType os;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
} vals[] = {
Remove spaces in initializer lists Format initializer lists code style like. Change-Id: Ib82c235e4ba7dc75ee96a7abc0c47eff7b0a9013 Reviewed-by: hjk <hjk@qt.io>
2017-02-22 15:09:35 +01:00
{"plain", 0, OsTypeWindows},
{"%{a}", "hi", OsTypeWindows},
{"%{aa}", "\"hi ho\"", OsTypeWindows},
{"%{b}", "h\\i", OsTypeWindows},
{"%{c}", "\\hi", OsTypeWindows},
{"%{d}", "hi\\", OsTypeWindows},
{"%{ba}", "\"h\\i ho\"", OsTypeWindows},
{"%{ca}", "\"\\hi ho\"", OsTypeWindows},
{"%{da}", "\"hi ho\\\\\"", OsTypeWindows}, // or "\"hi ho\"\\"
{"%{e}", "\"h\"\\^\"\"i\"", OsTypeWindows},
{"%{f}", "\"\"\\^\"\"hi\"", OsTypeWindows},
{"%{g}", "\"hi\"\\^\"\"\"", OsTypeWindows},
{"%{h}", "\"h\\\\\"\\^\"\"i\"", OsTypeWindows},
{"%{i}", "\"\\\\\"\\^\"\"hi\"", OsTypeWindows},
{"%{j}", "\"hi\\\\\"\\^\"\"\"", OsTypeWindows},
{"%{k}", "\"&special;\"", OsTypeWindows},
{"%{x}", "\\", OsTypeWindows},
{"%{y}", "\"\"\\^\"\"\"", OsTypeWindows},
{"%{z}", "\"\"", OsTypeWindows},
{"^%{z}%{z}", "^%{z}%{z}", OsTypeWindows}, // stupid user check
{"quoted", 0, OsTypeWindows},
{"\"%{a}\"", "\"hi\"", OsTypeWindows},
{"\"%{aa}\"", "\"hi ho\"", OsTypeWindows},
{"\"%{b}\"", "\"h\\i\"", OsTypeWindows},
{"\"%{c}\"", "\"\\hi\"", OsTypeWindows},
{"\"%{d}\"", "\"hi\\\\\"", OsTypeWindows},
{"\"%{ba}\"", "\"h\\i ho\"", OsTypeWindows},
{"\"%{ca}\"", "\"\\hi ho\"", OsTypeWindows},
{"\"%{da}\"", "\"hi ho\\\\\"", OsTypeWindows},
{"\"%{e}\"", "\"h\"\\^\"\"i\"", OsTypeWindows},
{"\"%{f}\"", "\"\"\\^\"\"hi\"", OsTypeWindows},
{"\"%{g}\"", "\"hi\"\\^\"\"\"", OsTypeWindows},
{"\"%{h}\"", "\"h\\\\\"\\^\"\"i\"", OsTypeWindows},
{"\"%{i}\"", "\"\\\\\"\\^\"\"hi\"", OsTypeWindows},
{"\"%{j}\"", "\"hi\\\\\"\\^\"\"\"", OsTypeWindows},
{"\"%{k}\"", "\"&special;\"", OsTypeWindows},
{"\"%{x}\"", "\"\\\\\"", OsTypeWindows},
{"\"%{y}\"", "\"\"\\^\"\"\"", OsTypeWindows},
{"\"%{z}\"", "\"\"", OsTypeWindows},
{"leading bs", 0, OsTypeWindows},
{"\\%{a}", "\\hi", OsTypeWindows},
{"\\%{aa}", "\\\\\"hi ho\"", OsTypeWindows},
{"\\%{b}", "\\h\\i", OsTypeWindows},
{"\\%{c}", "\\\\hi", OsTypeWindows},
{"\\%{d}", "\\hi\\", OsTypeWindows},
{"\\%{ba}", "\\\\\"h\\i ho\"", OsTypeWindows},
{"\\%{ca}", "\\\\\"\\hi ho\"", OsTypeWindows},
{"\\%{da}", "\\\\\"hi ho\\\\\"", OsTypeWindows},
{"\\%{e}", "\\\\\"h\"\\^\"\"i\"", OsTypeWindows},
{"\\%{f}", "\\\\\"\"\\^\"\"hi\"", OsTypeWindows},
{"\\%{g}", "\\\\\"hi\"\\^\"\"\"", OsTypeWindows},
{"\\%{h}", "\\\\\"h\\\\\"\\^\"\"i\"", OsTypeWindows},
{"\\%{i}", "\\\\\"\\\\\"\\^\"\"hi\"", OsTypeWindows},
{"\\%{j}", "\\\\\"hi\\\\\"\\^\"\"\"", OsTypeWindows},
{"\\%{x}", "\\\\", OsTypeWindows},
{"\\%{y}", "\\\\\"\"\\^\"\"\"", OsTypeWindows},
{"\\%{z}", "\\", OsTypeWindows},
{"trailing bs", 0, OsTypeWindows},
{"%{a}\\", "hi\\", OsTypeWindows},
{"%{aa}\\", "\"hi ho\"\\", OsTypeWindows},
{"%{b}\\", "h\\i\\", OsTypeWindows},
{"%{c}\\", "\\hi\\", OsTypeWindows},
{"%{d}\\", "hi\\\\", OsTypeWindows},
{"%{ba}\\", "\"h\\i ho\"\\", OsTypeWindows},
{"%{ca}\\", "\"\\hi ho\"\\", OsTypeWindows},
{"%{da}\\", "\"hi ho\\\\\"\\", OsTypeWindows},
{"%{e}\\", "\"h\"\\^\"\"i\"\\", OsTypeWindows},
{"%{f}\\", "\"\"\\^\"\"hi\"\\", OsTypeWindows},
{"%{g}\\", "\"hi\"\\^\"\"\"\\", OsTypeWindows},
{"%{h}\\", "\"h\\\\\"\\^\"\"i\"\\", OsTypeWindows},
{"%{i}\\", "\"\\\\\"\\^\"\"hi\"\\", OsTypeWindows},
{"%{j}\\", "\"hi\\\\\"\\^\"\"\"\\", OsTypeWindows},
{"%{x}\\", "\\\\", OsTypeWindows},
{"%{y}\\", "\"\"\\^\"\"\"\\", OsTypeWindows},
{"%{z}\\", "\\", OsTypeWindows},
{"bs-enclosed", 0, OsTypeWindows},
{"\\%{a}\\", "\\hi\\", OsTypeWindows},
{"\\%{aa}\\", "\\\\\"hi ho\"\\", OsTypeWindows},
{"\\%{b}\\", "\\h\\i\\", OsTypeWindows},
{"\\%{c}\\", "\\\\hi\\", OsTypeWindows},
{"\\%{d}\\", "\\hi\\\\", OsTypeWindows},
{"\\%{ba}\\", "\\\\\"h\\i ho\"\\", OsTypeWindows},
{"\\%{ca}\\", "\\\\\"\\hi ho\"\\", OsTypeWindows},
{"\\%{da}\\", "\\\\\"hi ho\\\\\"\\", OsTypeWindows},
{"\\%{e}\\", "\\\\\"h\"\\^\"\"i\"\\", OsTypeWindows},
{"\\%{f}\\", "\\\\\"\"\\^\"\"hi\"\\", OsTypeWindows},
{"\\%{g}\\", "\\\\\"hi\"\\^\"\"\"\\", OsTypeWindows},
{"\\%{h}\\", "\\\\\"h\\\\\"\\^\"\"i\"\\", OsTypeWindows},
{"\\%{i}\\", "\\\\\"\\\\\"\\^\"\"hi\"\\", OsTypeWindows},
{"\\%{j}\\", "\\\\\"hi\\\\\"\\^\"\"\"\\", OsTypeWindows},
{"\\%{x}\\", "\\\\\\", OsTypeWindows},
{"\\%{y}\\", "\\\\\"\"\\^\"\"\"\\", OsTypeWindows},
{"\\%{z}\\", "\\\\", OsTypeWindows},
{"bs-enclosed and trailing literal quote", 0, OsTypeWindows},
{"\\%{a}\\\\\\^\"", "\\hi\\\\\\^\"", OsTypeWindows},
{"\\%{aa}\\\\\\^\"", "\\\\\"hi ho\"\\\\\\^\"", OsTypeWindows},
{"\\%{b}\\\\\\^\"", "\\h\\i\\\\\\^\"", OsTypeWindows},
{"\\%{c}\\\\\\^\"", "\\\\hi\\\\\\^\"", OsTypeWindows},
{"\\%{d}\\\\\\^\"", "\\hi\\\\\\\\\\^\"", OsTypeWindows},
{"\\%{ba}\\\\\\^\"", "\\\\\"h\\i ho\"\\\\\\^\"", OsTypeWindows},
{"\\%{ca}\\\\\\^\"", "\\\\\"\\hi ho\"\\\\\\^\"", OsTypeWindows},
{"\\%{da}\\\\\\^\"", "\\\\\"hi ho\\\\\"\\\\\\^\"", OsTypeWindows},
{"\\%{e}\\\\\\^\"", "\\\\\"h\"\\^\"\"i\"\\\\\\^\"", OsTypeWindows},
{"\\%{f}\\\\\\^\"", "\\\\\"\"\\^\"\"hi\"\\\\\\^\"", OsTypeWindows},
{"\\%{g}\\\\\\^\"", "\\\\\"hi\"\\^\"\"\"\\\\\\^\"", OsTypeWindows},
{"\\%{h}\\\\\\^\"", "\\\\\"h\\\\\"\\^\"\"i\"\\\\\\^\"", OsTypeWindows},
{"\\%{i}\\\\\\^\"", "\\\\\"\\\\\"\\^\"\"hi\"\\\\\\^\"", OsTypeWindows},
{"\\%{j}\\\\\\^\"", "\\\\\"hi\\\\\"\\^\"\"\"\\\\\\^\"", OsTypeWindows},
{"\\%{x}\\\\\\^\"", "\\\\\\\\\\\\\\^\"", OsTypeWindows},
{"\\%{y}\\\\\\^\"", "\\\\\"\"\\^\"\"\"\\\\\\^\"", OsTypeWindows},
{"\\%{z}\\\\\\^\"", "\\\\\\\\\\^\"", OsTypeWindows},
{"bs-enclosed and trailing unclosed quote", 0, OsTypeWindows},
{"\\%{a}\\\\\"", "\\hi\\\\\"", OsTypeWindows},
{"\\%{aa}\\\\\"", "\\\\\"hi ho\"\\\\\"", OsTypeWindows},
{"\\%{b}\\\\\"", "\\h\\i\\\\\"", OsTypeWindows},
{"\\%{c}\\\\\"", "\\\\hi\\\\\"", OsTypeWindows},
{"\\%{d}\\\\\"", "\\hi\\\\\\\\\"", OsTypeWindows},
{"\\%{ba}\\\\\"", "\\\\\"h\\i ho\"\\\\\"", OsTypeWindows},
{"\\%{ca}\\\\\"", "\\\\\"\\hi ho\"\\\\\"", OsTypeWindows},
{"\\%{da}\\\\\"", "\\\\\"hi ho\\\\\"\\\\\"", OsTypeWindows},
{"\\%{e}\\\\\"", "\\\\\"h\"\\^\"\"i\"\\\\\"", OsTypeWindows},
{"\\%{f}\\\\\"", "\\\\\"\"\\^\"\"hi\"\\\\\"", OsTypeWindows},
{"\\%{g}\\\\\"", "\\\\\"hi\"\\^\"\"\"\\\\\"", OsTypeWindows},
{"\\%{h}\\\\\"", "\\\\\"h\\\\\"\\^\"\"i\"\\\\\"", OsTypeWindows},
{"\\%{i}\\\\\"", "\\\\\"\\\\\"\\^\"\"hi\"\\\\\"", OsTypeWindows},
{"\\%{j}\\\\\"", "\\\\\"hi\\\\\"\\^\"\"\"\\\\\"", OsTypeWindows},
{"\\%{x}\\\\\"", "\\\\\\\\\\\\\"", OsTypeWindows},
{"\\%{y}\\\\\"", "\\\\\"\"\\^\"\"\"\\\\\"", OsTypeWindows},
{"\\%{z}\\\\\"", "\\\\\\\\\"", OsTypeWindows},
{"multi-var", 0, OsTypeWindows},
{"%{x}%{y}%{z}", "\\\\\"\"\\^\"\"\"", OsTypeWindows},
{"%{x}%{z}%{y}%{z}", "\\\\\"\"\\^\"\"\"", OsTypeWindows},
{"%{x}%{z}%{y}", "\\\\\"\"\\^\"\"\"", OsTypeWindows},
{"%{x}\\^\"%{z}", "\\\\\\^\"", OsTypeWindows},
{"%{x}%{z}\\^\"%{z}", "\\\\\\^\"", OsTypeWindows},
{"%{x}%{z}\\^\"", "\\\\\\^\"", OsTypeWindows},
{"%{x}\\%{z}", "\\\\", OsTypeWindows},
{"%{x}%{z}\\%{z}", "\\\\", OsTypeWindows},
{"%{x}%{z}\\", "\\\\", OsTypeWindows},
{"%{aa}%{a}", "\"hi hohi\"", OsTypeWindows},
{"%{aa}%{aa}", "\"hi hohi ho\"", OsTypeWindows},
{"%{aa}:%{aa}", "\"hi ho\":\"hi ho\"", OsTypeWindows},
{"hallo ^|%{aa}^|", "hallo ^|\"hi ho\"^|", OsTypeWindows},
{"quoted multi-var", 0, OsTypeWindows},
{"\"%{x}%{y}%{z}\"", "\"\\\\\"\\^\"\"\"", OsTypeWindows},
{"\"%{x}%{z}%{y}%{z}\"", "\"\\\\\"\\^\"\"\"", OsTypeWindows},
{"\"%{x}%{z}%{y}\"", "\"\\\\\"\\^\"\"\"", OsTypeWindows},
{"\"%{x}\"^\"\"%{z}\"", "\"\\\\\"^\"\"\"", OsTypeWindows},
{"\"%{x}%{z}\"^\"\"%{z}\"", "\"\\\\\"^\"\"\"", OsTypeWindows},
{"\"%{x}%{z}\"^\"\"\"", "\"\\\\\"^\"\"\"", OsTypeWindows},
{"\"%{x}\\%{z}\"", "\"\\\\\\\\\"", OsTypeWindows},
{"\"%{x}%{z}\\%{z}\"", "\"\\\\\\\\\"", OsTypeWindows},
{"\"%{x}%{z}\\\\\"", "\"\\\\\\\\\"", OsTypeWindows},
{"\"%{aa}%{a}\"", "\"hi hohi\"", OsTypeWindows},
{"\"%{aa}%{aa}\"", "\"hi hohi ho\"", OsTypeWindows},
{"\"%{aa}:%{aa}\"", "\"hi ho:hi ho\"", OsTypeWindows},
{"plain", 0, OsTypeLinux},
{"%{a}", "hi", OsTypeLinux},
{"%{b}", "'hi ho'", OsTypeLinux},
{"%{c}", "'&special;'", OsTypeLinux},
{"%{d}", "'h\\i'", OsTypeLinux},
{"%{e}", "'h\"i'", OsTypeLinux},
{"%{f}", "'h'\\''i'", OsTypeLinux},
{"%{z}", "''", OsTypeLinux},
{"\\%{z}%{z}", "\\%{z}%{z}", OsTypeLinux}, // stupid user check
{"single-quoted", 0, OsTypeLinux},
{"'%{a}'", "'hi'", OsTypeLinux},
{"'%{b}'", "'hi ho'", OsTypeLinux},
{"'%{c}'", "'&special;'", OsTypeLinux},
{"'%{d}'", "'h\\i'", OsTypeLinux},
{"'%{e}'", "'h\"i'", OsTypeLinux},
{"'%{f}'", "'h'\\''i'", OsTypeLinux},
{"'%{z}'", "''", OsTypeLinux},
{"double-quoted", 0, OsTypeLinux},
{"\"%{a}\"", "\"hi\"", OsTypeLinux},
{"\"%{b}\"", "\"hi ho\"", OsTypeLinux},
{"\"%{c}\"", "\"&special;\"", OsTypeLinux},
{"\"%{d}\"", "\"h\\\\i\"", OsTypeLinux},
{"\"%{e}\"", "\"h\\\"i\"", OsTypeLinux},
{"\"%{f}\"", "\"h'i\"", OsTypeLinux},
{"\"%{z}\"", "\"\"", OsTypeLinux},
{"complex", 0, OsTypeLinux},
{"echo \"$(echo %{a})\"", "echo \"$(echo hi)\"", OsTypeLinux},
{"echo \"$(echo %{b})\"", "echo \"$(echo 'hi ho')\"", OsTypeLinux},
{"echo \"$(echo \"%{a}\")\"", "echo \"$(echo \"hi\")\"", OsTypeLinux},
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
// These make no sense shell-wise, but they test expando nesting
Remove spaces in initializer lists Format initializer lists code style like. Change-Id: Ib82c235e4ba7dc75ee96a7abc0c47eff7b0a9013 Reviewed-by: hjk <hjk@qt.io>
2017-02-22 15:09:35 +01:00
{"echo \"%{echo %{a}}\"", "echo \"%{echo hi}\"", OsTypeLinux},
{"echo \"%{echo %{b}}\"", "echo \"%{echo hi ho}\"", OsTypeLinux},
{"echo \"%{echo \"%{a}\"}\"", "echo \"%{echo \"hi\"}\"", OsTypeLinux },
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
};
const char *title = 0;
for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
if (!vals[i].out) {
title = vals[i].in;
} else {
char buf[80];
tst_QtcProcess: Use snprintf instead of sprintf This fixes the following warning: warning: 'sprintf' is deprecated: This function is provided for compatibility reasons only. Due to security concerns inherent in the design of sprintf(3), it is highly recommended that you use snprintf(3) instead. Change-Id: Ic8eac91b02cb60122f603506e083dbdf9eca8712 Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2023-03-06 13:11:15 +01:00
snprintf(buf, 80, "%s: %s", title, vals[i].in);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QTest::newRow(buf) << QString::fromLatin1(vals[i].in)
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
<< QString::fromLatin1(vals[i].out)
<< vals[i].os;
tst_QtcProcess: Use snprintf instead of sprintf This fixes the following warning: warning: 'sprintf' is deprecated: This function is provided for compatibility reasons only. Due to security concerns inherent in the design of sprintf(3), it is highly recommended that you use snprintf(3) instead. Change-Id: Ic8eac91b02cb60122f603506e083dbdf9eca8712 Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2023-03-06 13:11:15 +01:00
snprintf(buf, 80, "padded %s: %s", title, vals[i].in);
Make tst_qtcprocess.cpp compilable with default restrictions Enabling use of QT_USE_FAST_CONCATENATION QT_USE_FAST_OPERATOR_PLUS QT_NO_CAST_TO_ASCII QT_RESTRICTED_CAST_FROM_ASCII is straightforward nowadays. Change-Id: Ie4928b514049388401493de46e418790bb928a54 Reviewed-by: Christian Stenger <christian.stenger@theqtcompany.com>
2016-03-18 08:41:30 +01:00
QTest::newRow(buf) << QString(sp + QString::fromLatin1(vals[i].in) + sp)
<< QString(sp + QString::fromLatin1(vals[i].out) + sp)
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
<< vals[i].os;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
}
}
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::expandMacros()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QFETCH(QString, in);
QFETCH(QString, out);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QFETCH(OsType, os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
if (os == OsTypeWindows)
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::expandMacros(&in, &mxWin, os);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
else
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::expandMacros(&in, &mxUnix, os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(in, out);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::iterations_data()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QTest::addColumn<QString>("in");
QTest::addColumn<QString>("out");
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QTest::addColumn<OsType>("os");
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
static const struct {
const char * const in;
const char * const out;
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
OsType os;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
} vals[] = {
Remove spaces in initializer lists Format initializer lists code style like. Change-Id: Ib82c235e4ba7dc75ee96a7abc0c47eff7b0a9013 Reviewed-by: hjk <hjk@qt.io>
2017-02-22 15:09:35 +01:00
{"", "", OsTypeWindows},
{"hi", "hi", OsTypeWindows},
{" hi ", "hi", OsTypeWindows},
{"hi ho", "hi ho", OsTypeWindows},
{"\"hi ho\" sucker", "\"hi ho\" sucker", OsTypeWindows},
{"\"hi\"^\"\"ho\" sucker", "\"hi\"\\^\"\"ho\" sucker", OsTypeWindows},
{"\"hi\"\\^\"\"ho\" sucker", "\"hi\"\\^\"\"ho\" sucker", OsTypeWindows},
{"hi^|ho", "\"hi|ho\"", OsTypeWindows},
{"c:\\", "c:\\", OsTypeWindows},
{"\"c:\\\\\"", "c:\\", OsTypeWindows},
{"\\hi\\ho", "\\hi\\ho", OsTypeWindows},
{"hi null%", "hi null%", OsTypeWindows},
{"hi null% ho", "hi null% ho", OsTypeWindows},
{"hi null%here ho", "hi null%here ho", OsTypeWindows},
{"hi null%here%too ho", "hi {} ho", OsTypeWindows},
{"echo hello | more", "echo hello", OsTypeWindows},
{"echo hello| more", "echo hello", OsTypeWindows},
{"", "", OsTypeLinux},
{" ", "", OsTypeLinux},
{"hi", "hi", OsTypeLinux},
{" hi ", "hi", OsTypeLinux},
{"'hi'", "hi", OsTypeLinux},
{"hi ho", "hi ho", OsTypeLinux},
{"\"hi ho\" sucker", "'hi ho' sucker", OsTypeLinux},
{"\"hi\\\"ho\" sucker", "'hi\"ho' sucker", OsTypeLinux},
{"\"hi'ho\" sucker", "'hi'\\''ho' sucker", OsTypeLinux},
{"'hi ho' sucker", "'hi ho' sucker", OsTypeLinux},
{"\\\\", "'\\'", OsTypeLinux},
{"'\\'", "'\\'", OsTypeLinux},
{"hi 'null${here}too' ho", "hi 'null${here}too' ho", OsTypeLinux},
{"hi null${here}too ho", "hi {} ho", OsTypeLinux},
{"hi $(echo $dollar cent) ho", "hi {} ho", OsTypeLinux},
{"hi `echo $dollar \\`echo cent\\` | cat` ho", "hi {} ho", OsTypeLinux},
{"echo hello | more", "echo hello", OsTypeLinux},
{"echo hello| more", "echo hello", OsTypeLinux},
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
};
for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++)
QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
<< QString::fromLatin1(vals[i].out)
<< vals[i].os;
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::iterations()
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QFETCH(QString, in);
QFETCH(QString, out);
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
QFETCH(OsType, os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QString outstr;
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
for (ProcessArgs::ArgIterator ait(&in, os); ait.next(); ) {
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
if (ait.isSimple())
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::addArg(&outstr, ait.value(), os);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
else
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::addArgs(&outstr, "{}");
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
}
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QCOMPARE(outstr, out);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::iteratorEditsHelper(OsType osType)
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
{
QString in1 = "one two three", in2 = in1, in3 = in1, in4 = in1, in5 = in1;
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::ArgIterator ait1(&in1, osType);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QVERIFY(ait1.next());
ait1.deleteArg();
QVERIFY(ait1.next());
QVERIFY(ait1.next());
QVERIFY(!ait1.next());
QCOMPARE(in1, QString::fromLatin1("two three"));
ait1.appendArg("four");
QCOMPARE(in1, QString::fromLatin1("two three four"));
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::ArgIterator ait2(&in2, osType);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QVERIFY(ait2.next());
QVERIFY(ait2.next());
ait2.deleteArg();
QVERIFY(ait2.next());
ait2.appendArg("four");
QVERIFY(!ait2.next());
QCOMPARE(in2, QString::fromLatin1("one three four"));
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::ArgIterator ait3(&in3, osType);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QVERIFY(ait3.next());
ait3.appendArg("one-b");
QVERIFY(ait3.next());
QVERIFY(ait3.next());
ait3.deleteArg();
QVERIFY(!ait3.next());
QCOMPARE(in3, QString::fromLatin1("one one-b two"));
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::ArgIterator ait4(&in4, osType);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
ait4.appendArg("pre-one");
QVERIFY(ait4.next());
QVERIFY(ait4.next());
QVERIFY(ait4.next());
ait4.deleteArg();
QVERIFY(!ait4.next());
QCOMPARE(in4, QString::fromLatin1("pre-one one two"));
Utils: Move process arguments class out of QtcProcess The main QtcProcess interface is nowadays a CommandLine, with no explicit references left to QtcProcess::Arguments and related static helper functions, so it only clutters the QtcProcess class interface So move these items out of QtcProcess, later potentially to a separate file pair. Change-Id: I45c300b656f5b30e2e2717232c855fdd97c2d1d7 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-05-06 13:07:36 +02:00
ProcessArgs::ArgIterator ait5(&in5, osType);
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
QVERIFY(ait5.next());
QVERIFY(ait5.next());
QVERIFY(ait5.next());
QVERIFY(!ait5.next());
ait5.deleteArg();
QVERIFY(!ait5.next());
QCOMPARE(in5, QString::fromLatin1("one two"));
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::iteratorEditsWindows()
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
{
iteratorEditsHelper(OsTypeWindows);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::iteratorEditsLinux()
QtcProcess: Introduce a QtcProcess::Arguments class This is used to get a platform-agnostic handle on "command line arguments". It essentially wraps a single QString on Windows, and a QStringList everywhere else. As a consequence, several occurrences of #ifdef Q_OS_* can be removed from the codebase. Change-Id: Ic93118c1bd0bce0ebb58f416d395dbaebb861772 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
2014-02-05 10:43:21 +01:00
{
iteratorEditsHelper(OsTypeLinux);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::exitCode_data()
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
{
QTest::addColumn<int>("exitCode");
static const auto exitCodes = {
#ifdef Q_OS_WIN
"99999999", "-255", "-1",
#endif // Q_OS_WIN
"0", "1", "255"
};
for (auto exitCode : exitCodes)
QTest::newRow(exitCode) << QString::fromLatin1(exitCode).toInt();
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::exitCode()
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
{
QFETCH(int, exitCode);
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::ExitCode::envVar(), QString::number(exitCode));
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
{
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
subConfig.setupSubProcess(&process);
process.start();
const bool finished = process.waitForFinished();
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
QVERIFY(finished);
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
QCOMPARE(process.exitCode(), exitCode);
QCOMPARE(process.exitCode() == 0, process.result() == ProcessResult::FinishedWithSuccess);
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
}
{
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
subConfig.setupSubProcess(&process);
process.runBlocking();
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
QCOMPARE(process.exitCode(), exitCode);
QCOMPARE(process.exitCode() == 0, process.result() == ProcessResult::FinishedWithSuccess);
Utils: Add an auto test for QtcProcess::exitCode() Exit code handling can break during refactorings. This addition to tst_QtcProcess tests negative, zero and positive exit codes of sub prcesses that are launched asynchronously and synchronously. Change-Id: Icbcc036d3fda7fa681958b57fd0a6f67d3a90352 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 18:45:49 +02:00
}
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::runBlockingStdOut_data()
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
{
QTest::addColumn<bool>("withEndl");
QTest::addColumn<int>("timeOutS");
Fix handling of unfinished lines by QtcProcess callbacks Don't detect a call to QtcProcess::kill() from inside the QtcProcess callback while awaiting inside QtcProcess::waitFor...(). That's not needed, since a call to kill() sends a stop message to the process launcher, so we wait for confirmation from process launcher instead. This may bring e.g. new read data from the running process. Fix a runBlockingStdOut() test so that when we write to the stdOut from the running process we flush the unfinished line so that it's not buffered inside the process. Change-Id: I7944ac214d8cb9e10a71715a7ef8bfacab6df7c9 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-07 18:20:02 +01:00
QTest::addColumn<ProcessResult>("expectedResult");
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
Fix handling of unfinished lines by QtcProcess callbacks Don't detect a call to QtcProcess::kill() from inside the QtcProcess callback while awaiting inside QtcProcess::waitFor...(). That's not needed, since a call to kill() sends a stop message to the process launcher, so we wait for confirmation from process launcher instead. This may bring e.g. new read data from the running process. Fix a runBlockingStdOut() test so that when we write to the stdOut from the running process we flush the unfinished line so that it's not buffered inside the process. Change-Id: I7944ac214d8cb9e10a71715a7ef8bfacab6df7c9 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-07 18:20:02 +01:00
// TerminatedAbnormally, since it didn't time out and callback stopped the process forcefully.
QTest::newRow("Short timeout with end of line")
<< true << 2 << ProcessResult::TerminatedAbnormally;
// Hang, since it times out, calls the callback handler and stops the process forcefully.
QTest::newRow("Short timeout without end of line")
<< false << 2 << ProcessResult::Hang;
// FinishedWithSuccess, since it doesn't time out, it finishes process normally,
// calls the callback handler and tries to stop the process forcefully what is no-op
// at this point in time since the process is already finished.
QTest::newRow("Long timeout without end of line")
Compile fix Amends cfe8b7ad88ca57a76fd00f7757ccf10d1322ddd2 Change-Id: I4a570c481cf631ee6650a5c9d3b0f0540df88671 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2022-03-14 10:31:34 +01:00
<< false << 20 << ProcessResult::FinishedWithSuccess;
}
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::runBlockingStdOut()
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
{
QFETCH(bool, withEndl);
QFETCH(int, timeOutS);
Fix handling of unfinished lines by QtcProcess callbacks Don't detect a call to QtcProcess::kill() from inside the QtcProcess callback while awaiting inside QtcProcess::waitFor...(). That's not needed, since a call to kill() sends a stop message to the process launcher, so we wait for confirmation from process launcher instead. This may bring e.g. new read data from the running process. Fix a runBlockingStdOut() test so that when we write to the stdOut from the running process we flush the unfinished line so that it's not buffered inside the process. Change-Id: I7944ac214d8cb9e10a71715a7ef8bfacab6df7c9 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-07 18:20:02 +01:00
QFETCH(ProcessResult, expectedResult);
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::RunBlockingStdOut::envVar(), withEndl ? "true" : "false");
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
subConfig.setupSubProcess(&process);
process.setTimeoutS(timeOutS);
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
bool readLastLine = false;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
process.setStdOutCallback([&readLastLine, &process](const QString &out) {
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
if (out.startsWith(s_runBlockingStdOutSubProcessMagicWord)) {
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
readLastLine = true;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
process.kill();
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
}
});
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
process.runBlocking();
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
// See also QTCREATORBUG-25667 for why it is a bad idea to use Process::runBlocking
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
// with interactive cli tools.
Fix handling of unfinished lines by QtcProcess callbacks Don't detect a call to QtcProcess::kill() from inside the QtcProcess callback while awaiting inside QtcProcess::waitFor...(). That's not needed, since a call to kill() sends a stop message to the process launcher, so we wait for confirmation from process launcher instead. This may bring e.g. new read data from the running process. Fix a runBlockingStdOut() test so that when we write to the stdOut from the running process we flush the unfinished line so that it's not buffered inside the process. Change-Id: I7944ac214d8cb9e10a71715a7ef8bfacab6df7c9 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-07 18:20:02 +01:00
QCOMPARE(process.result(), expectedResult);
Utils: Add auto test for SynchronousProcess::runBlocking QTCREATORBUG-25667 appeared a few Months back in corellation to a seemingly unrelated change, and I was much later scratching my head a day or two. Therefore, it should be fine to have a test for the usage of SynchronousProcess::runBlocking with interactive cli processes. Those cli processes might output lines without terminating \n or \r and thus hang until timeout. We are IMHO lacking process IO tests, anyways. Task-number: QTCREATORBUG-25667 Change-Id: I3b7ea471b2ac9fa4554f0ce51752ce54c4a7d304 Reviewed-by: hjk <hjk@qt.io>
2021-05-26 03:56:03 +02:00
QVERIFY2(readLastLine, "Last line was read.");
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::runBlockingSignal_data()
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
{
runBlockingStdOut_data();
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::runBlockingSignal()
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
{
QFETCH(bool, withEndl);
QFETCH(int, timeOutS);
QFETCH(ProcessResult, expectedResult);
SubProcessConfig subConfig(ProcessTestApp::RunBlockingStdOut::envVar(), withEndl ? "true" : "false");
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
subConfig.setupSubProcess(&process);
process.setTimeoutS(timeOutS);
bool readLastLine = false;
process.setTextChannelMode(Channel::Output, TextChannelMode::MultiLine);
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
connect(&process, &Process::textOnStandardOutput,
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
this, [&readLastLine, &process](const QString &out) {
if (out.startsWith(s_runBlockingStdOutSubProcessMagicWord)) {
readLastLine = true;
process.kill();
}
});
process.runBlocking();
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
// See also QTCREATORBUG-25667 for why it is a bad idea to use Process::runBlocking
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
// with interactive cli tools.
QCOMPARE(process.result(), expectedResult);
QVERIFY2(readLastLine, "Last line was read.");
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::lineCallback()
Utils: Fix splitting in ChannelBuffer::takeFirstLine() Escape the '\r' Change-Id: I8cee40dc4a65f893f1a11c7cf066777498c37339 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-09 01:00:19 +02:00
{
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::LineCallback::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
subConfig.setupSubProcess(&process);
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
const QStringList lines = QString(s_lineCallbackData).split('|');
Utils: Fix splitting in ChannelBuffer::takeFirstLine() Escape the '\r' Change-Id: I8cee40dc4a65f893f1a11c7cf066777498c37339 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-09 01:00:19 +02:00
int lineNumber = 0;
Utils: Merge QtcProcess line reading functions - Pass everything through the codec. - Always emit even incomplete last lines when the process finishes. - Don't store raw output when line-wise processing is requested. Change-Id: I5cc30ad0d7ab79387bfb00b48ff957468a1bd004 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-14 15:09:11 +02:00
process.setStdErrLineCallback([lines, &lineNumber](const QString &actual) {
Fix tst_qtcprocess when Qt is showing warnings on startup In my case Qt is persistently showing the following warning at startup of every application: Warning: Ignoring WAYLAND_DISPLAY on Gnome. Use QT_QPA_PLATFORM=wayland to run on Wayland anyway. There is no easy solution here, as even when I run this test with -platform xcb option, then this test is running another instance of Creator that doesn't have this option passed. Since QTest's internal main function parses the argv options and filters out those recognized by Qt itself, calling QCoreApplication::arguments() doesn't return the originally passed -platform xcb option. The solution here is simple - we ignore initial lines in callback (so we filter out the initial warnings generated by Qt) and wait for first expected line. The final check of parsed line numbers should prevent the case when we have filtered out all the lines. Change-Id: Ideff0dc7c409b6e3ad81ec13577cb67e5211d5df Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:25:51 +01:00
QString expected = lines.at(lineNumber);
Utils: Merge QtcProcess line reading functions - Pass everything through the codec. - Always emit even incomplete last lines when the process finishes. - Don't store raw output when line-wise processing is requested. Change-Id: I5cc30ad0d7ab79387bfb00b48ff957468a1bd004 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-14 15:09:11 +02:00
expected.replace("\r\n", "\n");
Fix tst_qtcprocess when Qt is showing warnings on startup In my case Qt is persistently showing the following warning at startup of every application: Warning: Ignoring WAYLAND_DISPLAY on Gnome. Use QT_QPA_PLATFORM=wayland to run on Wayland anyway. There is no easy solution here, as even when I run this test with -platform xcb option, then this test is running another instance of Creator that doesn't have this option passed. Since QTest's internal main function parses the argv options and filters out those recognized by Qt itself, calling QCoreApplication::arguments() doesn't return the originally passed -platform xcb option. The solution here is simple - we ignore initial lines in callback (so we filter out the initial warnings generated by Qt) and wait for first expected line. The final check of parsed line numbers should prevent the case when we have filtered out all the lines. Change-Id: Ideff0dc7c409b6e3ad81ec13577cb67e5211d5df Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:25:51 +01:00
// Omit some initial lines generated by Qt, e.g.
// Warning: Ignoring WAYLAND_DISPLAY on Gnome. Use QT_QPA_PLATFORM=wayland to run on Wayland anyway.
if (lineNumber == 0 && actual != expected)
return;
++lineNumber;
Utils: Fix splitting in ChannelBuffer::takeFirstLine() Escape the '\r' Change-Id: I8cee40dc4a65f893f1a11c7cf066777498c37339 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-09 01:00:19 +02:00
QCOMPARE(actual, expected);
});
process.start();
process.waitForFinished();
Utils: Merge QtcProcess line reading functions - Pass everything through the codec. - Always emit even incomplete last lines when the process finishes. - Don't store raw output when line-wise processing is requested. Change-Id: I5cc30ad0d7ab79387bfb00b48ff957468a1bd004 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-14 15:09:11 +02:00
QCOMPARE(lineNumber, lines.size());
Utils: Fix splitting in ChannelBuffer::takeFirstLine() Escape the '\r' Change-Id: I8cee40dc4a65f893f1a11c7cf066777498c37339 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-09 01:00:19 +02:00
}
Utils: Merge QtcProcess line reading functions - Pass everything through the codec. - Always emit even incomplete last lines when the process finishes. - Don't store raw output when line-wise processing is requested. Change-Id: I5cc30ad0d7ab79387bfb00b48ff957468a1bd004 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-14 15:09:11 +02:00
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::lineSignal()
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
{
SubProcessConfig subConfig(ProcessTestApp::LineCallback::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
subConfig.setupSubProcess(&process);
const QStringList lines = QString(s_lineCallbackData).split('|');
int lineNumber = 0;
process.setTextChannelMode(Channel::Error, TextChannelMode::SingleLine);
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
connect(&process, &Process::textOnStandardError,
QtcProcess: Introduce TextChannelMode and textOnChannel signals This is alternative to setStd[Out/Err](Line)Callback() methods. In this way there may be many clients connected to textOnStandard[Output/Error]() signals. This should also simplify handling the lifetime of user callback. Change-Id: If82baa1f3f9c432ed431926619b9bbf11d770a84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-10-07 12:05:37 +02:00
this, [lines, &lineNumber](const QString &actual) {
QString expected = lines.at(lineNumber);
expected.replace("\r\n", "\n");
// Omit some initial lines generated by Qt, e.g.
// Warning: Ignoring WAYLAND_DISPLAY on Gnome. Use QT_QPA_PLATFORM=wayland to run on Wayland anyway.
if (lineNumber == 0 && actual != expected)
return;
++lineNumber;
QCOMPARE(actual, expected);
});
process.start();
process.waitForFinished();
QCOMPARE(lineNumber, lines.size());
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::waitForStartedAfterStarted()
Utils: fix QProcess backend on Windows Do not return false from QtcProces::waitForStarted if the process is already running. This causes mayor issues on windows since QProcess directly emits started and therefore switches to the running state after calling QProcess::start. Change-Id: I4604b08a59918d3df11c8a174b57e1e483e78a0d Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
2022-04-25 07:18:00 +02:00
{
SubProcessConfig subConfig(ProcessTestApp::SimpleTest::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Utils: fix QProcess backend on Windows Do not return false from QtcProces::waitForStarted if the process is already running. This causes mayor issues on windows since QProcess directly emits started and therefore switches to the running state after calling QProcess::start. Change-Id: I4604b08a59918d3df11c8a174b57e1e483e78a0d Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
2022-04-25 07:18:00 +02:00
subConfig.setupSubProcess(&process);
bool started = false;
bool waitForStartedResult = false;
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
connect(&process, &Process::started, this, [&] {
Utils: fix QProcess backend on Windows Do not return false from QtcProces::waitForStarted if the process is already running. This causes mayor issues on windows since QProcess directly emits started and therefore switches to the running state after calling QProcess::start. Change-Id: I4604b08a59918d3df11c8a174b57e1e483e78a0d Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
2022-04-25 07:18:00 +02:00
started = true;
waitForStartedResult = process.waitForStarted();
});
process.start();
QVERIFY(process.waitForFinished());
QVERIFY(started);
QVERIFY(waitForStartedResult);
QVERIFY(!process.waitForStarted());
}
// This version is using QProcess
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::waitForStartedAfterStarted2()
Utils: fix QProcess backend on Windows Do not return false from QtcProces::waitForStarted if the process is already running. This causes mayor issues on windows since QProcess directly emits started and therefore switches to the running state after calling QProcess::start. Change-Id: I4604b08a59918d3df11c8a174b57e1e483e78a0d Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
2022-04-25 07:18:00 +02:00
{
SubProcessConfig subConfig(ProcessTestApp::SimpleTest::envVar(), {});
QProcess process;
subConfig.setupSubProcess(&process);
bool started = false;
bool waitForStartedResult = false;
connect(&process, &QProcess::started, this, [&] {
started = true;
waitForStartedResult = process.waitForStarted();
});
process.start();
QVERIFY(process.waitForFinished());
QVERIFY(started);
QVERIFY(waitForStartedResult);
QVERIFY(!process.waitForStarted());
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::waitForStartedAndFinished()
Add a test for waitingForStarted and waitingForFinished Change-Id: I2d38bb2d37a71aad6d762aa68f1f3b329a4fa302 Reviewed-by: hjk <hjk@qt.io>
2021-08-24 18:15:54 +02:00
{
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::SimpleTest::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
subConfig.setupSubProcess(&process);
Add a test for waitingForStarted and waitingForFinished Change-Id: I2d38bb2d37a71aad6d762aa68f1f3b329a4fa302 Reviewed-by: hjk <hjk@qt.io>
2021-08-24 18:15:54 +02:00
process.start();
QThread::msleep(1000); // long enough for process to finish
QVERIFY(process.waitForStarted());
QVERIFY(process.waitForFinished());
QVERIFY(!process.waitForFinished());
QCOMPARE(process.exitCode(), 0);
}
tst_QtcProcess: Test all waitFor...() methods Test all waitFor...() methods when trying to run a non-existing executable. Change-Id: I958e1dd5ac1731788b6d0e94d9eb277c9e15c4e4 Reviewed-by: hjk <hjk@qt.io>
2022-06-29 18:41:50 +02:00
Q_DECLARE_METATYPE(ProcessSignalType)
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::notRunningAfterStartingNonExistingProgram_data()
tst_QtcProcess: Test all waitFor...() methods Test all waitFor...() methods when trying to run a non-existing executable. Change-Id: I958e1dd5ac1731788b6d0e94d9eb277c9e15c4e4 Reviewed-by: hjk <hjk@qt.io>
2022-06-29 18:41:50 +02:00
{
QTest::addColumn<ProcessSignalType>("signalType");
QTest::newRow("Started") << ProcessSignalType::Started;
QTest::newRow("ReadyRead") << ProcessSignalType::ReadyRead;
QTest::newRow("Done") << ProcessSignalType::Done;
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::notRunningAfterStartingNonExistingProgram()
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
{
tst_QtcProcess: Test all waitFor...() methods Test all waitFor...() methods when trying to run a non-existing executable. Change-Id: I958e1dd5ac1731788b6d0e94d9eb277c9e15c4e4 Reviewed-by: hjk <hjk@qt.io>
2022-06-29 18:41:50 +02:00
QFETCH(ProcessSignalType, signalType);
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
process.setCommand({ FilePath::fromString(
"there_is_a_big_chance_that_executable_with_that_name_does_not_exists"), {} });
tst_QtcProcess: Don't use errorOccurred() in tests Change-Id: I71657e111ab09b599480874ed22e714142697c19 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: David Schulz <david.schulz@qt.io>
2022-06-22 15:17:25 +02:00
int doneCount = 0;
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
QObject::connect(&process, &Process::done, [&process, &doneCount]() {
tst_QtcProcess: Don't use errorOccurred() in tests Change-Id: I71657e111ab09b599480874ed22e714142697c19 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: David Schulz <david.schulz@qt.io>
2022-06-22 15:17:25 +02:00
++doneCount;
QCOMPARE(process.error(), QProcess::FailedToStart);
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
});
const int loopCount = 2;
for (int i = 0; i < loopCount; ++i) {
// Work on the same process instance on every iteration
process.start();
QElapsedTimer timer;
timer.start();
const int maxWaitTimeMs = 1000;
tst_QtcProcess: Test all waitFor...() methods Test all waitFor...() methods when trying to run a non-existing executable. Change-Id: I958e1dd5ac1731788b6d0e94d9eb277c9e15c4e4 Reviewed-by: hjk <hjk@qt.io>
2022-06-29 18:41:50 +02:00
switch (signalType) {
case ProcessSignalType::Started: QVERIFY(!process.waitForStarted(maxWaitTimeMs)); break;
case ProcessSignalType::ReadyRead: QVERIFY(!process.waitForReadyRead(maxWaitTimeMs)); break;
case ProcessSignalType::Done: QVERIFY(!process.waitForFinished(maxWaitTimeMs)); break;
}
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
QVERIFY(timer.elapsed() < maxWaitTimeMs); // shouldn't wait, should finish immediately
QCOMPARE(process.state(), QProcess::NotRunning);
Use QProcess' / process lanuncher's exit code Change-Id: I802116c45847daf9a647771ee293aef8463fc3c7 Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-02 16:38:40 +02:00
QCOMPARE(process.exitStatus(), QProcess::NormalExit);
QCOMPARE(process.error(), QProcess::FailedToStart);
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
QVERIFY(process.exitCode() != 0);
QtcProcess: Fix StartFailed result Amends 4ca336762eaff6a4dac30f73803bac20d4aa7898 Change-Id: I3781bec37b17ea3f86eedc51657db0931a456c39 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-14 08:50:16 +02:00
QCOMPARE(process.result(), ProcessResult::StartFailed);
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
}
tst_QtcProcess: Don't use errorOccurred() in tests Change-Id: I71657e111ab09b599480874ed22e714142697c19 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: David Schulz <david.schulz@qt.io>
2022-06-22 15:17:25 +02:00
QCOMPARE(doneCount, loopCount);
Set process state to NotRunning after FailedToStart error Remove the process in process launcher after error has appeared. Remove unneeded stopStopProcedure as we are disconnecting from process' signals inside removeProcess(). In order to behave as much similar to what QProcess does, provide a test that: - ensures the FailedToStart error is synchronously emitted when waitForStarted is being executed - ensures that process state is reset to NotRunning after FailedToStart error - 2nd call to start/waitForStarted doesn't block on waitForStarted Change-Id: I139354421d037739f1cc1a2685b66f1e5b6170c8 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-08-30 16:29:08 +02:00
}
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
// Since we want to test whether the process forwards its channels or not, we can't just create
// a process and start it, because in this case there is no way on how to check whether something
// went into our output channels or not.
tst_QtcProcess: Rename ProcessChannelForwarding into ChannelForwarding Amends 91c11c769f49dd563feb600be5c64eed7102a02b Change-Id: Ib38edca1f720a313c42ee6224cbd9109fb50fa84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-04-01 08:48:00 +02:00
// So we start two processes in chain instead. On the beginning the channelForwarding()
// test starts the ChannelForwarding::main() - this one will start another process
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
// StandardOutputAndErrorWriter::main() with forwarding options.
// The StandardOutputAndErrorWriter::main() is very simple - it just puts something to the output
tst_QtcProcess: Rename ProcessChannelForwarding into ChannelForwarding Amends 91c11c769f49dd563feb600be5c64eed7102a02b Change-Id: Ib38edca1f720a313c42ee6224cbd9109fb50fa84 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-04-01 08:48:00 +02:00
// and the error channels. Then ChannelForwarding::main() either forwards these channels
// or not - we check it in the outer channelForwarding() test.
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::channelForwarding_data()
Implement process channel forwarding in process launcher Change-Id: I9e526eb40ebc46284f773d10ec0e285a009c524d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-02 12:58:33 +02:00
{
QTest::addColumn<QProcess::ProcessChannelMode>("channelMode");
QTest::addColumn<bool>("outputForwarded");
QTest::addColumn<bool>("errorForwarded");
QTest::newRow("SeparateChannels") << QProcess::SeparateChannels << false << false;
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
QTest::newRow("MergedChannels") << QProcess::MergedChannels << false << false;
Implement process channel forwarding in process launcher Change-Id: I9e526eb40ebc46284f773d10ec0e285a009c524d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-02 12:58:33 +02:00
QTest::newRow("ForwardedChannels") << QProcess::ForwardedChannels << true << true;
QTest::newRow("ForwardedOutputChannel") << QProcess::ForwardedOutputChannel << true << false;
QTest::newRow("ForwardedErrorChannel") << QProcess::ForwardedErrorChannel << false << true;
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::channelForwarding()
Implement process channel forwarding in process launcher Change-Id: I9e526eb40ebc46284f773d10ec0e285a009c524d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-02 12:58:33 +02:00
{
QFETCH(QProcess::ProcessChannelMode, channelMode);
QFETCH(bool, outputForwarded);
QFETCH(bool, errorForwarded);
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::ChannelForwarding::envVar(),
QString::number(int(channelMode)));
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
subConfig.setupSubProcess(&process);
Implement process channel forwarding in process launcher Change-Id: I9e526eb40ebc46284f773d10ec0e285a009c524d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-02 12:58:33 +02:00
process.start();
QVERIFY(process.waitForFinished());
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
const QByteArray output = process.readAllRawStandardOutput();
const QByteArray error = process.readAllRawStandardError();
Implement process channel forwarding in process launcher Change-Id: I9e526eb40ebc46284f773d10ec0e285a009c524d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-02 12:58:33 +02:00
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
QCOMPARE(output.contains(QByteArray(s_outputData)), outputForwarded);
QCOMPARE(error.contains(QByteArray(s_errorData)), errorForwarded);
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::mergedChannels_data()
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
{
QTest::addColumn<QProcess::ProcessChannelMode>("channelMode");
QTest::addColumn<bool>("outputOnOutput");
QTest::addColumn<bool>("outputOnError");
QTest::addColumn<bool>("errorOnOutput");
QTest::addColumn<bool>("errorOnError");
QTest::newRow("SeparateChannels") << QProcess::SeparateChannels
<< true << false << false << true;
QTest::newRow("MergedChannels") << QProcess::MergedChannels
<< true << false << true << false;
QTest::newRow("ForwardedChannels") << QProcess::ForwardedChannels
<< false << false << false << false;
QTest::newRow("ForwardedOutputChannel") << QProcess::ForwardedOutputChannel
<< false << false << false << true;
QTest::newRow("ForwardedErrorChannel") << QProcess::ForwardedErrorChannel
<< true << false << false << false;
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::mergedChannels()
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
{
QFETCH(QProcess::ProcessChannelMode, channelMode);
QFETCH(bool, outputOnOutput);
QFETCH(bool, outputOnError);
QFETCH(bool, errorOnOutput);
QFETCH(bool, errorOnError);
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::StandardOutputAndErrorWriter::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
subConfig.setupSubProcess(&process);
process.setProcessChannelMode(channelMode);
process.start();
QVERIFY(process.waitForFinished());
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
const QByteArray output = process.readAllRawStandardOutput();
const QByteArray error = process.readAllRawStandardError();
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
QCOMPARE(output.contains(QByteArray(s_outputData)), outputOnOutput);
QCOMPARE(error.contains(QByteArray(s_outputData)), outputOnError);
QCOMPARE(output.contains(QByteArray(s_errorData)), errorOnOutput);
QCOMPARE(error.contains(QByteArray(s_errorData)), errorOnError);
Implement process channel forwarding in process launcher Change-Id: I9e526eb40ebc46284f773d10ec0e285a009c524d Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2021-09-02 12:58:33 +02:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::destroyBlockingProcess_data()
Add new types of blocking processes Change-Id: I7668d0ac94a4e949f7ea67d8a1c0c144af5bd541 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-08 00:28:34 +01:00
{
QTest::addColumn<BlockType>("blockType");
QTest::newRow("EndlessLoop") << BlockType::EndlessLoop;
QTest::newRow("InfiniteSleep") << BlockType::InfiniteSleep;
QTest::newRow("MutexDeadlock") << BlockType::MutexDeadlock;
QTest::newRow("EventLoop") << BlockType::EventLoop;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::destroyBlockingProcess()
Add a test ensuring we don't receive a warning when killing process Before we were receiving the following warning when detroying the QtcProcess while still running: QProcess: Destroyed while process ("[program_name]") is still running. With the new implementation it won't appear anymore since terminating running QtcProcesses is done internally by the reaper. Change-Id: I14a0de136f463966cb1e4c43c5cb26b4de47e7ce Reviewed-by: hjk <hjk@qt.io>
2021-08-26 16:57:52 +02:00
{
Add new types of blocking processes Change-Id: I7668d0ac94a4e949f7ea67d8a1c0c144af5bd541 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-08 00:28:34 +01:00
QFETCH(BlockType, blockType);
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
SubProcessConfig subConfig(ProcessTestApp::BlockingProcess::envVar(),
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
QString::number(int(blockType)));
Add a test ensuring we don't receive a warning when killing process Before we were receiving the following warning when detroying the QtcProcess while still running: QProcess: Destroyed while process ("[program_name]") is still running. With the new implementation it won't appear anymore since terminating running QtcProcesses is done internally by the reaper. Change-Id: I14a0de136f463966cb1e4c43c5cb26b4de47e7ce Reviewed-by: hjk <hjk@qt.io>
2021-08-26 16:57:52 +02:00
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Ensure we never encounter the message about destroying QProcess Until we remove the process launcher / process reaper. Change-Id: I9c68c40c3c856c0a515277b69fc3084ba2addbee Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-03-21 18:02:53 +01:00
subConfig.setupSubProcess(&process);
process.start();
QVERIFY(process.waitForStarted());
QVERIFY(!process.waitForFinished(1000));
Add a test ensuring we don't receive a warning when killing process Before we were receiving the following warning when detroying the QtcProcess while still running: QProcess: Destroyed while process ("[program_name]") is still running. With the new implementation it won't appear anymore since terminating running QtcProcesses is done internally by the reaper. Change-Id: I14a0de136f463966cb1e4c43c5cb26b4de47e7ce Reviewed-by: hjk <hjk@qt.io>
2021-08-26 16:57:52 +02:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::flushFinishedWhileWaitingForReadyRead()
Flush finished() signal when waitForReadyRead() was called Apparently the QProcess behaves like that. Change-Id: Idb1993b8abccbd7943582d41bd456eacc9a1c185 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2021-11-04 10:27:08 +01:00
{
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::SimpleTest::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
Simplify starting subCreator process Introduce SubCreatorConfig class that helps setting up a Creator subprocess. This limits the code repetition. Introduce SUB_CREATOR_PROCESS(subProcess) macro to easily define environment variables referred to Creator subprocesses. This macro also forward declares the subProcessMain() function. Match names of main subprocess functions with their corresponding environment variables. Group subProcessMain() functions near the corresponding test function for clarity. Change-Id: Ib4365cf18fddc1527ebc99accee1fbb974bbf7a1 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-04 17:14:13 +01:00
subConfig.setupSubProcess(&process);
Flush finished() signal when waitForReadyRead() was called Apparently the QProcess behaves like that. Change-Id: Idb1993b8abccbd7943582d41bd456eacc9a1c185 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2021-11-04 10:27:08 +01:00
process.start();
QVERIFY(process.waitForStarted());
QCOMPARE(process.state(), QProcess::Running);
QDeadlineTimer timer(1000);
QByteArray reply;
while (process.state() == QProcess::Running) {
process.waitForReadyRead(500);
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
reply += process.readAllRawStandardOutput();
Flush finished() signal when waitForReadyRead() was called Apparently the QProcess behaves like that. Change-Id: Idb1993b8abccbd7943582d41bd456eacc9a1c185 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2021-11-04 10:27:08 +01:00
if (timer.hasExpired())
break;
}
QCOMPARE(process.state(), QProcess::NotRunning);
QVERIFY(!timer.hasExpired());
Utils: Add mergedChannels test to tst_QtcProcess Change-Id: Ia6c25004ca37c97c0cfa61bc2eb944493f796217 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-30 11:14:48 +02:00
QVERIFY(reply.contains(s_simpleTestData));
Flush finished() signal when waitForReadyRead() was called Apparently the QProcess behaves like that. Change-Id: Idb1993b8abccbd7943582d41bd456eacc9a1c185 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2021-11-04 10:27:08 +01:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::crash()
ProcessLauncher: Don't emit error twice on process crash Behave the same as QProcess in this circumstances. Change-Id: If8175ccb7102d6a561584ee73c2e5c5844f2770d Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-03-15 14:41:28 +01:00
{
tst_QtcProcess: Don't use errorOccurred() in tests Change-Id: I71657e111ab09b599480874ed22e714142697c19 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: David Schulz <david.schulz@qt.io>
2022-06-22 15:17:25 +02:00
SubProcessConfig subConfig(ProcessTestApp::Crash::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
ProcessLauncher: Don't emit error twice on process crash Behave the same as QProcess in this circumstances. Change-Id: If8175ccb7102d6a561584ee73c2e5c5844f2770d Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-03-15 14:41:28 +01:00
subConfig.setupSubProcess(&process);
process.start();
QVERIFY(process.waitForStarted(1000));
tst_QtcProcess: Don't use errorOccurred() in tests Change-Id: I71657e111ab09b599480874ed22e714142697c19 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: David Schulz <david.schulz@qt.io>
2022-06-22 15:17:25 +02:00
QVERIFY(process.isRunning());
ProcessLauncher: Don't emit error twice on process crash Behave the same as QProcess in this circumstances. Change-Id: If8175ccb7102d6a561584ee73c2e5c5844f2770d Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-03-15 14:41:28 +01:00
QEventLoop loop;
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
connect(&process, &Process::done, &loop, &QEventLoop::quit);
ProcessLauncher: Don't emit error twice on process crash Behave the same as QProcess in this circumstances. Change-Id: If8175ccb7102d6a561584ee73c2e5c5844f2770d Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-03-15 14:41:28 +01:00
loop.exec();
Ensure that after a call to waitForFinished() process is not running Amends 5de5f1cf0a957c3a81bd55d4021c84041250f024 Change-Id: I64db8c6736c6a7cc6805813f852faf1048ebb629 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-22 12:33:03 +01:00
QCOMPARE(process.error(), QProcess::Crashed);
tst_QtcProcess: Don't use errorOccurred() in tests Change-Id: I71657e111ab09b599480874ed22e714142697c19 Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: David Schulz <david.schulz@qt.io>
2022-06-22 15:17:25 +02:00
QCOMPARE(process.exitStatus(), QProcess::CrashExit);
ProcessLauncher: Don't emit error twice on process crash Behave the same as QProcess in this circumstances. Change-Id: If8175ccb7102d6a561584ee73c2e5c5844f2770d Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-03-15 14:41:28 +01:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::crashAfterOneSecond()
QtcProcess: Add a test for crashing app Ensure that when waitForFinished() didn't timeout but the process has terminated, it returns true, like QProcess does, in contrary to what QProcess' documentation says. Change-Id: I6af5034f4df7fc2e14a83bab74334a8abefe7a0f Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-03-21 16:24:22 +01:00
{
tst_QtcProcess: Move subprocesses into a separate executable Don't invoke subcreator test in order to run a custom process. Run a separate executable instead. The advantages are: 1. Faster test running (no need for QTest specific code path when running subprocess). 2. Don't use std::exit() from subprocesses as it doesn't clean up properly. Use qApp->exit() instead. 3. This should support returning NormalExit and proper exit code of subprocess in case the code wasn't 0. Change-Id: I1395bd8a7873c95a594c3e054087f00c55a15376 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 14:15:30 +02:00
SubProcessConfig subConfig(ProcessTestApp::CrashAfterOneSecond::envVar(), {});
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
QtcProcess: Add a test for crashing app Ensure that when waitForFinished() didn't timeout but the process has terminated, it returns true, like QProcess does, in contrary to what QProcess' documentation says. Change-Id: I6af5034f4df7fc2e14a83bab74334a8abefe7a0f Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-03-21 16:24:22 +01:00
subConfig.setupSubProcess(&process);
process.start();
QVERIFY(process.waitForStarted(1000));
QElapsedTimer timer;
timer.start();
// Please note that QProcess documentation says it should return false, but apparently
// it doesn't (try running this test with QTC_USE_QPROCESS=)
tst_QtcProcess::crashAfterOneSecond(): Increase the timeout Increase the timeout to default 30 seconds when waiting for finished. Apparently 2 seconds were sometimes too short. We still ensure that waitForFinished didn't timeout but finished eariler. Change-Id: I12ca647b45537174c7c66d271e7c8a477184f2ff Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-07-04 10:02:46 +02:00
QVERIFY(process.waitForFinished(30000));
QVERIFY(timer.elapsed() < 30000);
Ensure that after a call to waitForFinished() process is not running Amends 5de5f1cf0a957c3a81bd55d4021c84041250f024 Change-Id: I64db8c6736c6a7cc6805813f852faf1048ebb629 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2022-03-22 12:33:03 +01:00
QCOMPARE(process.state(), QProcess::NotRunning);
QCOMPARE(process.error(), QProcess::Crashed);
QtcProcess: Add a test for crashing app Ensure that when waitForFinished() didn't timeout but the process has terminated, it returns true, like QProcess does, in contrary to what QProcess' documentation says. Change-Id: I6af5034f4df7fc2e14a83bab74334a8abefe7a0f Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-03-21 16:24:22 +01:00
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::recursiveCrashingProcess()
tst_QtcProcess: Add a test that invokes a process recursively After the required depth of recursion is met, the most nested process waits for one seconds and crashes. Change-Id: I8d9b359459fc7aa1983734685e5c5f19eb49ee94 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 15:02:23 +02:00
{
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
const int recursionDepth = 5; // must be at least 2
tst_QtcProcess: Add a test that invokes a process recursively After the required depth of recursion is met, the most nested process waits for one seconds and crashes. Change-Id: I8d9b359459fc7aa1983734685e5c5f19eb49ee94 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 15:02:23 +02:00
SubProcessConfig subConfig(ProcessTestApp::RecursiveCrashingProcess::envVar(),
QString::number(recursionDepth));
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
tst_QtcProcess: Add a test that invokes a process recursively After the required depth of recursion is met, the most nested process waits for one seconds and crashes. Change-Id: I8d9b359459fc7aa1983734685e5c5f19eb49ee94 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 15:02:23 +02:00
subConfig.setupSubProcess(&process);
process.start();
QVERIFY(process.waitForStarted(1000));
tst_QtcProcess: Increase the timeout Fix recursiveCrashingProcess() flakiness. Change-Id: I0d62368ccb5b67be691a787b6fa69717a4f024d1 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-07-12 09:45:58 +02:00
QVERIFY(process.waitForFinished());
tst_QtcProcess: Add a test that invokes a process recursively After the required depth of recursion is met, the most nested process waits for one seconds and crashes. Change-Id: I8d9b359459fc7aa1983734685e5c5f19eb49ee94 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-04-01 15:02:23 +02:00
QCOMPARE(process.state(), QProcess::NotRunning);
QCOMPARE(process.exitStatus(), QProcess::NormalExit);
QCOMPARE(process.exitCode(), s_crashCode);
}
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
static int runningTestProcessCount()
{
int testProcessCounter = 0;
const QList<ProcessInfo> processInfoList = ProcessInfo::processInfoList();
for (const ProcessInfo &processInfo : processInfoList) {
if (FilePath::fromString(processInfo.executable).baseName() == "processtestapp")
++testProcessCounter;
}
return testProcessCounter;
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::recursiveBlockingProcess()
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
{
if (HostOsInfo::isWindowsHost())
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
QSKIP(s_skipTerminateOnWindows);
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
Singleton::deleteAll();
QCOMPARE(runningTestProcessCount(), 0);
const int recursionDepth = 5; // must be at least 2
SubProcessConfig subConfig(ProcessTestApp::RecursiveBlockingProcess::envVar(),
QString::number(recursionDepth));
{
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
subConfig.setupSubProcess(&process);
process.start();
QVERIFY(process.waitForStarted(1000));
QVERIFY(process.waitForReadyRead(1000));
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessStarted);
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
QCOMPARE(runningTestProcessCount(), recursionDepth);
QVERIFY(!process.waitForFinished(1000));
process.terminate();
QVERIFY(process.waitForReadyRead());
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessTerminated);
QtcProcess: Fix terminate() for process launcher ProcessLauncherImpl::terminate() was behaving the same as ProcessLauncherImpl::kill() in case of process launcher implementation - in both cases the launcher immediately returned confirmation about receiving the close request and was putting the corresponding process into its reaper. However, the issue with this approach is that we can't receive anymore any potential ready read signal from the process being terminated after a call to terminate(). The fix is to diverge the behavior of terminate() and kill() of ProcessLauncherImpl. The behavior of kill() remains the same, while terminate() just instructs the process launcher to start termination without putting the process into the reaper, yet. Add a test that checks for any possible zombies. We run the RecursiveBlockingProcess recursively. The most nested process blocks. After a short wait we terminate the outermost process. With this test we are trying to see if terminating the middle process terminates also its children and doesn't leave zombies. Before we execute the test (and also by the end of this test) we call Singleton::deleteAll() in order to ensure that reaping of previously running processes has finished. We ensure the number of running processtestapps is zero. Later, we ensure that the leaf process was already started and the number of running processtestapps equals the depth of recursion. Fix apparent bug in getLocalProcessesUsingProc(). Change-Id: I7e2bc46ad5ca22f26620da86fbaf0fa00a7db3c3 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-04-01 15:14:05 +02:00
QVERIFY(process.waitForFinished());
QCOMPARE(process.exitStatus(), QProcess::NormalExit);
QCOMPARE(process.exitCode(), s_crashCode);
}
Singleton::deleteAll();
QCOMPARE(runningTestProcessCount(), 0);
}
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
enum class QuitType {
Terminate,
Kill,
Stop,
Close
};
Q_DECLARE_METATYPE(QuitType)
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::quitBlockingProcess_data()
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
{
QTest::addColumn<QuitType>("quitType");
QTest::addColumn<bool>("doneExpected");
QTest::addColumn<bool>("gracefulQuit");
QTest::newRow("Terminate") << QuitType::Terminate << true << true;
QTest::newRow("Kill") << QuitType::Kill << true << false;
QTest::newRow("Stop") << QuitType::Stop << true << true;
QTest::newRow("Close") << QuitType::Close << false << true;
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::quitBlockingProcess()
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
{
QFETCH(QuitType, quitType);
QFETCH(bool, doneExpected);
QFETCH(bool, gracefulQuit);
if (HostOsInfo::isWindowsHost() && quitType == QuitType::Terminate)
QSKIP(s_skipTerminateOnWindows);
const int recursionDepth = 1;
SubProcessConfig subConfig(ProcessTestApp::RecursiveBlockingProcess::envVar(),
QString::number(recursionDepth));
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process process;
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
subConfig.setupSubProcess(&process);
bool done = false;
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
connect(&process, &Process::done, this, [&done] { done = true; });
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
process.start();
QVERIFY(process.waitForStarted());
QVERIFY(!done);
QVERIFY(process.isRunning());
QVERIFY(process.waitForReadyRead(1000));
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessStarted);
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
switch (quitType) {
case QuitType::Terminate: process.terminate(); break;
case QuitType::Kill: process.kill(); break;
case QuitType::Stop: process.stop(); break;
case QuitType::Close: process.close(); break;
}
QVERIFY(!done);
if (doneExpected) {
QVERIFY(process.isRunning());
QVERIFY(process.waitForFinished());
QVERIFY(!process.isRunning());
QVERIFY(done);
if (gracefulQuit) {
if (HostOsInfo::isWindowsHost())
QSKIP(s_skipTerminateOnWindows);
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessTerminated);
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
QCOMPARE(process.exitStatus(), QProcess::NormalExit);
QCOMPARE(process.exitCode(), s_crashCode);
} else {
Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard* ... and re-use the old QtcProcess::readAllStandard* names for a QString-returning 'decoded' version. For now, only use that in 'full Utf8' cases, to stay bug-compatible, the plan is, however, to employ the QTextCodecs we have already in the channel buffers. That will be one-by-one, though. Change-Id: Id209e0671920d4ea4197918e872f441254112d52 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2023-01-05 17:55:04 +01:00
QCOMPARE(process.readAllRawStandardOutput(), QByteArray());
QtcProcess: Add a test for various quit methods The quitBlockingProcess() test examines different types of process quitting and illustrates differences in behavior. Change-Id: I9209f00576e03eef66fbdf5665351138ed437ac9 Reviewed-by: hjk <hjk@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2022-06-03 11:12:29 +02:00
QCOMPARE(process.exitStatus(), QProcess::CrashExit);
QVERIFY(process.exitCode() != s_crashCode);
}
} else {
QVERIFY(!process.isRunning());
}
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
void tst_Process::tarPipe()
tst_qtcprocess: Add testPipe Change-Id: I5b54231d201960eb6909780e4a2c5b9860b7e523 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Marcus Tillmanns <marcus.tillmanns@qt.io>
2023-01-23 13:14:35 +01:00
{
if (!FilePath::fromString("tar").searchInPath().isExecutableFile())
QSKIP("This test uses \"tar\" command.");
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
Process sourceProcess;
Process targetProcess;
tst_qtcprocess: Add testPipe Change-Id: I5b54231d201960eb6909780e4a2c5b9860b7e523 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Marcus Tillmanns <marcus.tillmanns@qt.io>
2023-01-23 13:14:35 +01:00
targetProcess.setProcessMode(ProcessMode::Writer);
Utils: Rename QtcProcess -> Process Task-number: QTCREATORBUG-29102 Change-Id: Ibc264f9db6a32206e4097766ee3f7d0b35225a5c Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2023-05-03 16:00:22 +02:00
QObject::connect(&sourceProcess, &Process::readyReadStandardOutput,
tst_qtcprocess: Add testPipe Change-Id: I5b54231d201960eb6909780e4a2c5b9860b7e523 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: Marcus Tillmanns <marcus.tillmanns@qt.io>
2023-01-23 13:14:35 +01:00
&targetProcess, [&sourceProcess, &targetProcess]() {
targetProcess.writeRaw(sourceProcess.readAllRawStandardOutput());
});
QTemporaryDir sourceDir;
QVERIFY(sourceDir.isValid());
QTemporaryDir destinationDir;
QVERIFY(destinationDir.isValid());
const FilePath sourcePath = FilePath::fromString(sourceDir.path());
const FilePath sourceArchive = sourcePath / "archive";
QVERIFY(sourceArchive.createDir());
const FilePath sourceFile = sourceArchive / "file1.txt";
QVERIFY(sourceFile.writeFileContents("bla bla"));
const FilePath destinationPath = FilePath::fromString(destinationDir.path());
const FilePath destinationArchive = destinationPath / "archive";
const FilePath destinationFile = destinationArchive / "file1.txt";
QVERIFY(!destinationArchive.exists());
QVERIFY(!destinationFile.exists());
sourceProcess.setCommand({"tar", {"cvf", "-", "-C", sourcePath.nativePath(), "."}});
targetProcess.setCommand({"tar", {"xvf", "-", "-C", destinationPath.nativePath()}});
targetProcess.start();
QVERIFY(targetProcess.waitForStarted());
sourceProcess.start();
QVERIFY(sourceProcess.waitForFinished());
if (targetProcess.isRunning()) {
targetProcess.closeWriteChannel();
QVERIFY(targetProcess.waitForFinished(2000));
}
QCOMPARE(targetProcess.exitCode(), 0);
QCOMPARE(targetProcess.result(), ProcessResult::FinishedWithSuccess);
QVERIFY(destinationArchive.exists());
QVERIFY(destinationFile.exists());
QCOMPARE(sourceFile.fileSize(), destinationFile.fileSize());
}
Tests: Add a test to feed shells via stdin Change-Id: I7e19537d0a3015aeb329849758cc92da17a67606 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2023-04-14 10:00:08 +02:00
void tst_Process::stdinToShell()
{
// proc.setCommand({"cmd.exe", {}}); - Piping into cmd.exe does not appear to work.
if (HostOsInfo::isWindowsHost())
QSKIP("Skipping env test on Windows");
Process proc;
proc.setCommand({"sh", {}});
proc.setWriteData("echo hallo");
proc.runBlocking();
QString result = proc.readAllStandardOutput().trimmed();
QCOMPARE(result, "hallo");
}
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
QTEST_GUILESS_MAIN(tst_Process)
add Utils::QtcProcess this is a wrapper around QProcess with these features: - setEnvironment() takes a Utils::Environment instead of a QStringList - instead of taking a stringlist with arguments, take a single shell command string which is fully compatible with the system's native shell (the bourne shell on unix and cmd.exe on windows) - with support for environment variable expansion, and subject to the shell's splitting and quoting rules. if the command is too complex (e.g., contains redirections), it is transparently executed through a real shell. - additionally, the class contains a set of helper functions for manipulating (constructing, splitting, etc.) shell command lines. in particular, it contains a shell-safe macro expander and the nested class ArgIterator which can be used for inspecting and manipulating a shell command line without going through the stringlist indirection (which is potentially lossy). some of this is based on KDE code (KShell and KMacroExpander) which i have written myself.
2010-10-14 18:05:43 +02:00
Tests: Rename tst_QtcProcess -> tst_Process Follows 470c95c94be58905bc3202d3b58175add5f576fa Change-Id: Ie26b5677d28e645ab27aeebf5976b5507385716a Reviewed-by: hjk <hjk@qt.io>
2023-05-04 17:20:29 +02:00
#include "tst_process.moc"
Copy Permalink