feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
b4b779d6410f0d24a6fb6d760dae68eeb97d123c
qt-creator/tests/auto/utils/qtcprocess/tst_qtcprocess.cpp

1272 lines
48 KiB
C++
Raw Normal View History

Adjust license headers Change-Id: Ice592c6de9951ee3b2c4cb52ed0bb3b6770e0825 Reviewed-by: Eike Ziller <eike.ziller@digia.com>
2012-10-02 09:12:39 +02: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
**
Update License according to agreement with Free Qt Foundation * Update license information in tests directory Change-Id: I311441dd37d053ca3175e44b284258e232ee93e0 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:55:33 +01:00
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
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
**
Adjust license headers Change-Id: Ice592c6de9951ee3b2c4cb52ed0bb3b6770e0825 Reviewed-by: Eike Ziller <eike.ziller@digia.com>
2012-10-02 09:12:39 +02:00
** This file is part of Qt Creator.
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
**
Adjust license headers Change-Id: Ice592c6de9951ee3b2c4cb52ed0bb3b6770e0825 Reviewed-by: Eike Ziller <eike.ziller@digia.com>
2012-10-02 09:12:39 +02:00
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
Update License according to agreement with Free Qt Foundation * Update license information in tests directory Change-Id: I311441dd37d053ca3175e44b284258e232ee93e0 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:55:33 +01:00
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
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
**
Update License according to agreement with Free Qt Foundation * Update license information in tests directory Change-Id: I311441dd37d053ca3175e44b284258e232ee93e0 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:55:33 +01:00
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
License headers, part 2
2010-12-17 17:14:20 +01:00
**
Adjust license headers Change-Id: Ice592c6de9951ee3b2c4cb52ed0bb3b6770e0825 Reviewed-by: Eike Ziller <eike.ziller@digia.com>
2012-10-02 09:12:39 +02: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
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: 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/porting.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>
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>
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/qtcprocess.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;
};
class tst_QtcProcess : public QObject
{
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
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();
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();
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();
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();
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
void killBlockingProcess_data();
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
void killBlockingProcess();
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();
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
void emitOneErrorOnCrash();
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();
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
};
void tst_QtcProcess::initTestCase()
{
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
}
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 tst_QtcProcess::cleanupTestCase()
{
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
void tst_QtcProcess::splitArgs_data()
{
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
}
void tst_QtcProcess::splitArgs()
{
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);
}
void tst_QtcProcess::prepareArgs_data()
{
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
}
void tst_QtcProcess::prepareArgs()
{
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);
}
void tst_QtcProcess::prepareArgsEnv_data()
{
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
}
void tst_QtcProcess::prepareArgsEnv()
{
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);
}
void tst_QtcProcess::expandMacros_data()
{
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];
sprintf(buf, "%s: %s", title, vals[i].in);
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;
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
sprintf(buf, "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
}
}
}
void tst_QtcProcess::expandMacros()
{
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);
}
void tst_QtcProcess::iterations_data()
{
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
}
void tst_QtcProcess::iterations()
{
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);
}
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 tst_QtcProcess::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"));
}
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 tst_QtcProcess::iteratorEditsWindows()
{
iteratorEditsHelper(OsTypeWindows);
}
void tst_QtcProcess::iteratorEditsLinux()
{
iteratorEditsHelper(OsTypeLinux);
}
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 tst_QtcProcess::exitCode_data()
{
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();
}
void tst_QtcProcess::exitCode()
{
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
{
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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
}
{
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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
}
}
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 tst_QtcProcess::runBlockingStdOut_data()
{
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
void tst_QtcProcess::runBlockingStdOut()
{
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");
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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
All: Replace most SynchronousProcess by QtcProcess Change-Id: I0bf22fef2cd4a7297ef5a1e9aa9c3e2b9348ba42 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2021-06-22 04:33:47 +02:00
// See also QTCREATORBUG-25667 for why it is a bad idea to use QtcProcess::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.");
}
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 tst_QtcProcess::lineCallback()
{
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(), {});
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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);
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
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
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 tst_QtcProcess::waitForStartedAfterStarted()
{
SubProcessConfig subConfig(ProcessTestApp::SimpleTest::envVar(), {});
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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;
connect(&process, &QtcProcess::started, this, [&] {
started = true;
waitForStartedResult = process.waitForStarted();
});
process.start();
QVERIFY(process.waitForFinished());
QVERIFY(started);
QVERIFY(waitForStartedResult);
QVERIFY(!process.waitForStarted());
}
// This version is using QProcess
void tst_QtcProcess::waitForStartedAfterStarted2()
{
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());
}
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 tst_QtcProcess::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(), {});
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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);
}
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 tst_QtcProcess::notRunningAfterStartingNonExistingProgram()
{
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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"), {} });
int errorCount = 0;
QObject::connect(&process, &QtcProcess::errorOccurred,
[&errorCount](QProcess::ProcessError error) {
++errorCount;
QCOMPARE(error, QProcess::FailedToStart);
});
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;
QVERIFY(!process.waitForStarted(maxWaitTimeMs));
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
}
}
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
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 tst_QtcProcess::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;
}
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 tst_QtcProcess::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)));
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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());
const QByteArray output = process.readAllStandardOutput();
const QByteArray error = process.readAllStandardError();
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);
}
void tst_QtcProcess::mergedChannels_data()
{
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;
}
void tst_QtcProcess::mergedChannels()
{
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(), {});
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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());
const QByteArray output = process.readAllStandardOutput();
const QByteArray error = process.readAllStandardError();
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
}
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
void tst_QtcProcess::killBlockingProcess_data()
{
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
}
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
void tst_QtcProcess::killBlockingProcess()
{
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);
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::KillBlockingProcess::envVar(),
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
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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
}
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 tst_QtcProcess::flushFinishedWhileWaitingForReadyRead()
{
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(), {});
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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);
reply += process.readAllStandardOutput();
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
}
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
void tst_QtcProcess::emitOneErrorOnCrash()
{
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::EmitOneErrorOnCrash::envVar(), {});
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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);
int errorCount = 0;
connect(&process, &QtcProcess::errorOccurred, this, [&errorCount] { ++errorCount; });
process.start();
QVERIFY(process.waitForStarted(1000));
QEventLoop loop;
connect(&process, &QtcProcess::finished, &loop, &QEventLoop::quit);
loop.exec();
QCOMPARE(errorCount, 1);
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);
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
}
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 tst_QtcProcess::crashAfterOneSecond()
{
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(), {});
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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=)
QVERIFY(process.waitForFinished(2000));
QVERIFY(timer.elapsed() < 2000);
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
}
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 tst_QtcProcess::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
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));
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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));
QVERIFY(process.waitForFinished(3000));
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;
}
void tst_QtcProcess::recursiveBlockingProcess()
{
if (HostOsInfo::isWindowsHost())
QSKIP("Windows implementation of this test is lacking handling of WM_CLOSE message.");
Singleton::deleteAll();
QCOMPARE(runningTestProcessCount(), 0);
const int recursionDepth = 5; // must be at least 2
SubProcessConfig subConfig(ProcessTestApp::RecursiveBlockingProcess::envVar(),
QString::number(recursionDepth));
{
QtcProcess: Make the class final Currently, as a result of many refactorings, the QtcProcess is designed so that if you want to customize the behavior you should implement custom ProcessInterface subclass. Adding virtual methods directly to QtcProcess caused tons of unpredicted side effects and nasty bugs, which were hard to track and hard to fix, as provided fixes were usually fixing particular case while introducing regressions in not related code paths. Consider also aggregating QtcProcess object instead of deriving from it when some additional methods are required. This patch removes the last virtual methods from QtcProcess API and makes the class final in order to prevent from adding any new virtual methods to this class in the future. This commit message should make it clear that having subclasses of QtcProcess is not a desired design. It's a post-mortem conclusion. So: don't derive from QtcProcess - we mean it! Change-Id: I1e43ed45be326b366422fd7db6e05ba48ea5fb98 Reviewed-by: hjk <hjk@qt.io>
2022-05-06 11:59:17 +02:00
QtcProcess 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));
QCOMPARE(process.readAllStandardOutput(), s_leafProcessStarted);
QCOMPARE(runningTestProcessCount(), recursionDepth);
QVERIFY(!process.waitForFinished(1000));
process.terminate();
QVERIFY(process.waitForReadyRead());
QCOMPARE(process.readAllStandardOutput(), s_leafProcessTerminated);
QVERIFY(process.waitForFinished());
QCOMPARE(process.exitStatus(), QProcess::NormalExit);
QCOMPARE(process.exitCode(), s_crashCode);
}
Singleton::deleteAll();
QCOMPARE(runningTestProcessCount(), 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
QTEST_MAIN(tst_QtcProcess)
#include "tst_qtcprocess.moc"
Copy Permalink