luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-11 20:06:18 +01:00
Code Issues Packages Projects Releases Wiki Activity
832dd0805a
glib/gio/tests/gsubprocess.c

2141 lines
66 KiB
C
Raw Normal View History

GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#include <gio/gio.h>
#include <string.h>
#ifdef G_OS_UNIX
#include <sys/wait.h>
#include <glib-unix.h>
#include <gio/gunixinputstream.h>
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
#include <gio/gunixoutputstream.h>
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#include <gio/gfiledescriptorbased.h>
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
#include <unistd.h>
#include <fcntl.h>
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#endif
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
/* We write 2^1 + 2^2 ... + 2^10 or 2047 copies of "Hello World!\n"
* ultimately
*/
#define TOTAL_HELLOS 2047
#define HELLO_WORLD "hello world!\n"
gio/tests/gsubprocess.c: Fix on Windows We need to check for the correct line endings on Windows (\r\n) for the echo tests and currently need to skip the test_echo_eof test there, as it depends on the cat utility that is not normally found on Windows, and using an external installation of cat via MSYS or Cygwin would render the test program to hang as cat waits for user input. https://bugzilla.gnome.org/show_bug.cgi?id=711047
2013-11-05 10:33:09 +01:00
#ifdef G_OS_WIN32
#define LINEEND "\r\n"
#define EXEEXT ".exe"
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
#define SPLICELEN (TOTAL_HELLOS * (strlen (HELLO_WORLD) + 1)) /* because \r */
gio/tests/gsubprocess.c: Fix on Windows We need to check for the correct line endings on Windows (\r\n) for the echo tests and currently need to skip the test_echo_eof test there, as it depends on the cat utility that is not normally found on Windows, and using an external installation of cat via MSYS or Cygwin would render the test program to hang as cat waits for user input. https://bugzilla.gnome.org/show_bug.cgi?id=711047
2013-11-05 10:33:09 +01:00
#else
#define LINEEND "\n"
#define EXEEXT
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
#define SPLICELEN (TOTAL_HELLOS * strlen (HELLO_WORLD))
gio/tests/gsubprocess.c: Fix on Windows We need to check for the correct line endings on Windows (\r\n) for the echo tests and currently need to skip the test_echo_eof test there, as it depends on the cat utility that is not normally found on Windows, and using an external installation of cat via MSYS or Cygwin would render the test program to hang as cat waits for user input. https://bugzilla.gnome.org/show_bug.cgi?id=711047
2013-11-05 10:33:09 +01:00
#endif
gsubprocess: Add G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP
2021-11-17 13:27:46 +01:00
#ifdef G_OS_WIN32
#define TESTPROG "gsubprocess-testprog.exe"
#else
#define TESTPROG "gsubprocess-testprog"
#endif
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
static GPtrArray *
get_test_subprocess_args (const char *mode,
...) G_GNUC_NULL_TERMINATED;
static GPtrArray *
get_test_subprocess_args (const char *mode,
...)
{
GPtrArray *ret;
tests/gsubprocess: Locate test child binary for installed tests too Just use the new g_test_build_filename() rather than assuming it's in cwd.
2013-10-17 23:39:48 +02:00
char *path;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
va_list args;
gpointer arg;
ret = g_ptr_array_new_with_free_func (g_free);
gsubprocess: Add G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP
2021-11-17 13:27:46 +01:00
path = g_test_build_filename (G_TEST_BUILT, TESTPROG, NULL);
tests/gsubprocess: Locate test child binary for installed tests too Just use the new g_test_build_filename() rather than assuming it's in cwd.
2013-10-17 23:39:48 +02:00
g_ptr_array_add (ret, path);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_ptr_array_add (ret, g_strdup (mode));
va_start (args, mode);
while ((arg = va_arg (args, gpointer)) != NULL)
g_ptr_array_add (ret, g_strdup (arg));
va_end (args);
g_ptr_array_add (ret, NULL);
return ret;
}
static void
test_noop (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocess *proc;
args = get_test_subprocess_args ("noop", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
g_subprocess_wait_check (proc, NULL, error);
g_assert_no_error (local_error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_true (g_subprocess_get_successful (proc));
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_object_unref (proc);
}
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
static void
check_ready (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
gboolean ret;
GError *error = NULL;
ret = g_subprocess_wait_check_finish (G_SUBPROCESS (source),
res,
&error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_true (ret);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_assert_no_error (error);
g_object_unref (source);
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
static void
test_noop_all_to_null (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocess *proc;
args = get_test_subprocess_args ("noop", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata,
G_SUBPROCESS_FLAGS_STDOUT_SILENCE | G_SUBPROCESS_FLAGS_STDERR_SILENCE,
error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_subprocess_wait_check_async (proc, NULL, check_ready, NULL);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
}
static void
test_noop_no_wait (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocess *proc;
args = get_test_subprocess_args ("noop", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
g_object_unref (proc);
}
static void
test_noop_stdin_inherit (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocess *proc;
args = get_test_subprocess_args ("noop", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_STDIN_INHERIT, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
g_subprocess_wait_check (proc, NULL, error);
g_assert_no_error (local_error);
g_object_unref (proc);
}
#ifdef G_OS_UNIX
static void
test_search_path (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocess *proc;
proc = g_subprocess_new (G_SUBPROCESS_FLAGS_NONE, error, "true", NULL);
g_assert_no_error (local_error);
g_subprocess_wait_check (proc, NULL, error);
g_assert_no_error (local_error);
g_object_unref (proc);
}
gsubprocess: Add G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP
2021-11-17 13:27:46 +01:00
static void
test_search_path_from_envp (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocessLauncher *launcher;
GSubprocess *proc;
const char *path;
path = g_test_get_dir (G_TEST_BUILT);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP);
g_subprocess_launcher_setenv (launcher, "PATH", path, TRUE);
proc = g_subprocess_launcher_spawn (launcher, error, TESTPROG, "exit1", NULL);
g_assert_no_error (local_error);
g_object_unref (launcher);
g_subprocess_wait_check (proc, NULL, error);
g_assert_error (local_error, G_SPAWN_EXIT_ERROR, 1);
g_clear_error (error);
g_object_unref (proc);
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#endif
static void
test_exit1 (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocess *proc;
args = get_test_subprocess_args ("exit1", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
g_subprocess_wait_check (proc, NULL, error);
g_assert_error (local_error, G_SPAWN_EXIT_ERROR, 1);
g_clear_error (error);
g_object_unref (proc);
}
gio: failing cases for subprocess cancellable bug https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-18 11:41:46 +02:00
typedef struct {
GMainLoop *loop;
GCancellable *cancellable;
gboolean cb_called;
} TestExit1CancelData;
static gboolean
test_exit1_cancel_idle_quit_cb (gpointer user_data)
{
GMainLoop *loop = user_data;
g_main_loop_quit (loop);
return G_SOURCE_REMOVE;
}
static void
test_exit1_cancel_wait_check_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSubprocess *subprocess = G_SUBPROCESS (source);
TestExit1CancelData *data = user_data;
gboolean ret;
GError *error = NULL;
g_assert_false (data->cb_called);
data->cb_called = TRUE;
ret = g_subprocess_wait_check_finish (subprocess, result, &error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_false (ret);
gio: failing cases for subprocess cancellable bug https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-18 11:41:46 +02:00
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_clear_error (&error);
g_idle_add (test_exit1_cancel_idle_quit_cb, data->loop);
}
static void
test_exit1_cancel (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocess *proc;
TestExit1CancelData data = { 0 };
tests: Drop use of g_test_bug_base() Include the base URI in the `g_test_bug()` calls instead. This resolves inconsistencies between the old bug base (bugzilla.gnome.org) and the new bug base (gitlab.gnome.org). It also has the advantage that the URI passed to `g_test_bug()` is now clickable in the code editor, rather than being split across two locations. See https://gitlab.gnome.org/GNOME/glib/-/merge_requests/275#note_303175 Signed-off-by: Philip Withnall <pwithnall@endlessos.org>
2021-05-13 23:12:29 +02:00
g_test_bug ("https://bugzilla.gnome.org/show_bug.cgi?id=786456");
gio: failing cases for subprocess cancellable bug https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-18 11:41:46 +02:00
args = get_test_subprocess_args ("exit1", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
data.loop = g_main_loop_new (NULL, FALSE);
data.cancellable = g_cancellable_new ();
g_subprocess_wait_check_async (proc, data.cancellable, test_exit1_cancel_wait_check_cb, &data);
g_subprocess_wait_check (proc, NULL, error);
g_assert_error (local_error, G_SPAWN_EXIT_ERROR, 1);
g_clear_error (error);
g_cancellable_cancel (data.cancellable);
g_main_loop_run (data.loop);
g_object_unref (proc);
g_main_loop_unref (data.loop);
g_clear_object (&data.cancellable);
}
static void
test_exit1_cancel_in_cb_wait_check_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSubprocess *subprocess = G_SUBPROCESS (source);
TestExit1CancelData *data = user_data;
gboolean ret;
GError *error = NULL;
g_assert_false (data->cb_called);
data->cb_called = TRUE;
ret = g_subprocess_wait_check_finish (subprocess, result, &error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_false (ret);
gio: failing cases for subprocess cancellable bug https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-18 11:41:46 +02:00
g_assert_error (error, G_SPAWN_EXIT_ERROR, 1);
g_clear_error (&error);
g_cancellable_cancel (data->cancellable);
g_idle_add (test_exit1_cancel_idle_quit_cb, data->loop);
}
static void
test_exit1_cancel_in_cb (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocess *proc;
TestExit1CancelData data = { 0 };
tests: Drop use of g_test_bug_base() Include the base URI in the `g_test_bug()` calls instead. This resolves inconsistencies between the old bug base (bugzilla.gnome.org) and the new bug base (gitlab.gnome.org). It also has the advantage that the URI passed to `g_test_bug()` is now clickable in the code editor, rather than being split across two locations. See https://gitlab.gnome.org/GNOME/glib/-/merge_requests/275#note_303175 Signed-off-by: Philip Withnall <pwithnall@endlessos.org>
2021-05-13 23:12:29 +02:00
g_test_bug ("https://bugzilla.gnome.org/show_bug.cgi?id=786456");
gio: failing cases for subprocess cancellable bug https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-18 11:41:46 +02:00
args = get_test_subprocess_args ("exit1", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
data.loop = g_main_loop_new (NULL, FALSE);
data.cancellable = g_cancellable_new ();
g_subprocess_wait_check_async (proc, data.cancellable, test_exit1_cancel_in_cb_wait_check_cb, &data);
g_subprocess_wait_check (proc, NULL, error);
g_assert_error (local_error, G_SPAWN_EXIT_ERROR, 1);
g_clear_error (error);
g_main_loop_run (data.loop);
g_object_unref (proc);
g_main_loop_unref (data.loop);
g_clear_object (&data.cancellable);
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
static gchar *
splice_to_string (GInputStream *stream,
GError **error)
{
GMemoryOutputStream *buffer = NULL;
char *ret = NULL;
buffer = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
if (g_output_stream_splice ((GOutputStream*)buffer, stream, 0, NULL, error) < 0)
goto out;
if (!g_output_stream_write ((GOutputStream*)buffer, "\0", 1, NULL, error))
goto out;
if (!g_output_stream_close ((GOutputStream*)buffer, NULL, error))
goto out;
ret = g_memory_output_stream_steal_data (buffer);
out:
g_clear_object (&buffer);
return ret;
}
static void
test_echo1 (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocess *proc;
GPtrArray *args;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GInputStream *stdout_stream;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
gchar *result;
args = get_test_subprocess_args ("echo", "hello", "world!", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_STDOUT_PIPE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdout_stream = g_subprocess_get_stdout_pipe (proc);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
result = splice_to_string (stdout_stream, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
gio/tests/gsubprocess.c: Fix on Windows We need to check for the correct line endings on Windows (\r\n) for the echo tests and currently need to skip the test_echo_eof test there, as it depends on the cat utility that is not normally found on Windows, and using an external installation of cat via MSYS or Cygwin would render the test program to hang as cat waits for user input. https://bugzilla.gnome.org/show_bug.cgi?id=711047
2013-11-05 10:33:09 +01:00
g_assert_cmpstr (result, ==, "hello" LINEEND "world!" LINEEND);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_free (result);
g_object_unref (proc);
}
#ifdef G_OS_UNIX
static void
test_echo_merged (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocess *proc;
GPtrArray *args;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GInputStream *stdout_stream;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
gchar *result;
args = get_test_subprocess_args ("echo-stdout-and-stderr", "merge", "this", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata,
G_SUBPROCESS_FLAGS_STDOUT_PIPE | G_SUBPROCESS_FLAGS_STDERR_MERGE,
error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdout_stream = g_subprocess_get_stdout_pipe (proc);
result = splice_to_string (stdout_stream, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
g_assert_cmpstr (result, ==, "merge\nmerge\nthis\nthis\n");
g_free (result);
g_object_unref (proc);
}
#endif
typedef struct {
guint events_pending;
GMainLoop *loop;
} TestCatData;
static void
test_cat_on_input_splice_complete (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
TestCatData *data = user_data;
GError *error = NULL;
(void)g_output_stream_splice_finish ((GOutputStream*)object, result, &error);
g_assert_no_error (error);
data->events_pending--;
if (data->events_pending == 0)
g_main_loop_quit (data->loop);
}
static void
test_cat_utf8 (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocess *proc;
GPtrArray *args;
GBytes *input_buf;
GBytes *output_buf;
GInputStream *input_buf_stream = NULL;
GOutputStream *output_buf_stream = NULL;
GOutputStream *stdin_stream = NULL;
GInputStream *stdout_stream = NULL;
TestCatData data;
memset (&data, 0, sizeof (data));
data.loop = g_main_loop_new (NULL, TRUE);
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE,
error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
stdin_stream = g_subprocess_get_stdin_pipe (proc);
stdout_stream = g_subprocess_get_stdout_pipe (proc);
input_buf = g_bytes_new_static ("hello, world!", strlen ("hello, world!"));
input_buf_stream = g_memory_input_stream_new_from_bytes (input_buf);
g_bytes_unref (input_buf);
output_buf_stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
g_output_stream_splice_async (stdin_stream, input_buf_stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, NULL, test_cat_on_input_splice_complete,
&data);
data.events_pending++;
g_output_stream_splice_async (output_buf_stream, stdout_stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, NULL, test_cat_on_input_splice_complete,
&data);
data.events_pending++;
g_main_loop_run (data.loop);
g_subprocess_wait_check (proc, NULL, error);
g_assert_no_error (local_error);
output_buf = g_memory_output_stream_steal_as_bytes ((GMemoryOutputStream*)output_buf_stream);
gtestutils: add g_assert_cmpmem() Add a test macro to compare two buffers (which are not already known to be the same length) for equality. https://bugzilla.gnome.org/show_bug.cgi?id=754283
2014-12-03 11:57:29 +01:00
g_assert_cmpmem (g_bytes_get_data (output_buf, NULL),
g_bytes_get_size (output_buf),
"hello, world!", 13);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_bytes_unref (output_buf);
g_main_loop_unref (data.loop);
g_object_unref (input_buf_stream);
g_object_unref (output_buf_stream);
g_object_unref (proc);
}
static gpointer
cancel_soon (gpointer user_data)
{
GCancellable *cancellable = user_data;
g_usleep (G_TIME_SPAN_SECOND);
g_cancellable_cancel (cancellable);
g_object_unref (cancellable);
return NULL;
}
static void
test_cat_eof (void)
{
GCancellable *cancellable;
GError *error = NULL;
GSubprocess *cat;
gboolean result;
gchar buffer;
gssize s;
gio/tests/gsubprocess.c: Fix on Windows We need to check for the correct line endings on Windows (\r\n) for the echo tests and currently need to skip the test_echo_eof test there, as it depends on the cat utility that is not normally found on Windows, and using an external installation of cat via MSYS or Cygwin would render the test program to hang as cat waits for user input. https://bugzilla.gnome.org/show_bug.cgi?id=711047
2013-11-05 10:33:09 +01:00
#ifdef G_OS_WIN32
g_test_skip ("This test has not been ported to Win32");
return;
#endif
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
/* Spawn 'cat' */
cat = g_subprocess_new (G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE, &error, "cat", NULL);
g_assert_no_error (error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_nonnull (cat);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
/* Make sure that reading stdout blocks (until we cancel) */
cancellable = g_cancellable_new ();
g_thread_unref (g_thread_new ("cancel thread", cancel_soon, g_object_ref (cancellable)));
s = g_input_stream_read (g_subprocess_get_stdout_pipe (cat), &buffer, sizeof buffer, cancellable, &error);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_assert_cmpint (s, ==, -1);
g_object_unref (cancellable);
g_clear_error (&error);
/* Close the stream (EOF on cat's stdin) */
result = g_output_stream_close (g_subprocess_get_stdin_pipe (cat), NULL, &error);
g_assert_no_error (error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_true (result);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
/* Now check that reading cat's stdout gets us an EOF (since it quit) */
s = g_input_stream_read (g_subprocess_get_stdout_pipe (cat), &buffer, sizeof buffer, NULL, &error);
g_assert_no_error (error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_false (s);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
/* Check that the process has exited as a result of the EOF */
result = g_subprocess_wait (cat, NULL, &error);
g_assert_no_error (error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_true (g_subprocess_get_if_exited (cat));
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_cmpint (g_subprocess_get_exit_status (cat), ==, 0);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_true (result);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_object_unref (cat);
}
typedef struct {
guint events_pending;
gboolean caught_error;
GError *error;
GMainLoop *loop;
gint counter;
GOutputStream *first_stdin;
} TestMultiSpliceData;
static void
on_one_multi_splice_done (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
TestMultiSpliceData *data = user_data;
if (!data->caught_error)
{
if (g_output_stream_splice_finish ((GOutputStream*)obj, res, &data->error) < 0)
data->caught_error = TRUE;
}
data->events_pending--;
if (data->events_pending == 0)
g_main_loop_quit (data->loop);
}
static gboolean
on_idle_multisplice (gpointer user_data)
{
TestMultiSpliceData *data = user_data;
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
if (data->counter >= TOTAL_HELLOS || data->caught_error)
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
{
if (!g_output_stream_close (data->first_stdin, NULL, &data->error))
data->caught_error = TRUE;
data->events_pending--;
if (data->events_pending == 0)
{
g_main_loop_quit (data->loop);
}
return FALSE;
}
else
{
int i;
for (i = 0; i < data->counter; i++)
{
gsize bytes_written;
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
if (!g_output_stream_write_all (data->first_stdin, HELLO_WORLD,
strlen (HELLO_WORLD), &bytes_written,
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
NULL, &data->error))
{
data->caught_error = TRUE;
return FALSE;
}
}
data->counter *= 2;
return TRUE;
}
}
static void
on_subprocess_exited (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GSubprocess *subprocess = G_SUBPROCESS (object);
TestMultiSpliceData *data = user_data;
GError *error = NULL;
if (!g_subprocess_wait_finish (subprocess, result, &error))
{
if (!data->caught_error)
{
data->caught_error = TRUE;
g_propagate_error (&data->error, error);
}
}
Distinguish more clearly between wait status and exit status On Unix platforms, wait() and friends yield an integer that encodes how the process exited. Confusingly, this is usually not the same as the integer passed to exit() or returned from main(): conceptually it's an integer encoding of this tagged union: enum { EXITED, SIGNALLED, ... } tag; union { int exit_status; /* if EXITED */ struct { int terminating_signal; bool core_dumped; } terminating_signal; /* if SIGNALLED */ ... } detail; Meanwhile, on Windows, wait statuses and exit statuses are interchangeable. I find that it's clearer what is going on if we are consistent about referring to the result of wait() as a "wait status", and the value passed to exit() as an "exit status". GSubprocess already gets this right: g_subprocess_get_status() returns the wait status, while g_subprocess_get_exit_status() genuinely returns the exit status. However, the GSpawn family of APIs has tended to conflate the two. Confusingly, g_spawn_check_exit_status() has always checked a wait status, and it would not be correct to pass an exit status to it; so let's deprecate it in favour of g_spawn_check_wait_status(), which does the same thing that g_spawn_check_exit_status() always did. Code that needs backwards-compatibility with older GLib can use: #if !GLIB_CHECK_VERSION(2, 69, 0) #define g_spawn_check_wait_status(x) (g_spawn_check_exit_status (x)) #endif Signed-off-by: Simon McVittie <smcv@collabora.com>
2021-06-14 13:51:01 +02:00
g_spawn_check_wait_status (g_subprocess_get_status (subprocess), &error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (error);
data->events_pending--;
if (data->events_pending == 0)
g_main_loop_quit (data->loop);
}
static void
test_multi_1 (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GPtrArray *args;
GSubprocessLauncher *launcher;
GSubprocess *first;
GSubprocess *second;
GSubprocess *third;
GOutputStream *first_stdin;
GInputStream *first_stdout;
GOutputStream *second_stdin;
GInputStream *second_stdout;
GOutputStream *third_stdin;
GInputStream *third_stdout;
GOutputStream *membuf;
TestMultiSpliceData data;
int splice_flags = G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET;
args = get_test_subprocess_args ("cat", NULL);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE);
first = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_assert_no_error (local_error);
second = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_assert_no_error (local_error);
third = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_assert_no_error (local_error);
g_ptr_array_free (args, TRUE);
membuf = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
first_stdin = g_subprocess_get_stdin_pipe (first);
first_stdout = g_subprocess_get_stdout_pipe (first);
second_stdin = g_subprocess_get_stdin_pipe (second);
second_stdout = g_subprocess_get_stdout_pipe (second);
third_stdin = g_subprocess_get_stdin_pipe (third);
third_stdout = g_subprocess_get_stdout_pipe (third);
memset (&data, 0, sizeof (data));
data.loop = g_main_loop_new (NULL, TRUE);
data.counter = 1;
data.first_stdin = first_stdin;
data.events_pending++;
g_output_stream_splice_async (second_stdin, first_stdout, splice_flags, G_PRIORITY_DEFAULT,
NULL, on_one_multi_splice_done, &data);
data.events_pending++;
g_output_stream_splice_async (third_stdin, second_stdout, splice_flags, G_PRIORITY_DEFAULT,
NULL, on_one_multi_splice_done, &data);
data.events_pending++;
g_output_stream_splice_async (membuf, third_stdout, splice_flags, G_PRIORITY_DEFAULT,
NULL, on_one_multi_splice_done, &data);
data.events_pending++;
g_timeout_add (250, on_idle_multisplice, &data);
data.events_pending++;
g_subprocess_wait_async (first, NULL, on_subprocess_exited, &data);
data.events_pending++;
g_subprocess_wait_async (second, NULL, on_subprocess_exited, &data);
data.events_pending++;
g_subprocess_wait_async (third, NULL, on_subprocess_exited, &data);
g_main_loop_run (data.loop);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_false (data.caught_error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (data.error);
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
g_assert_cmpint (g_memory_output_stream_get_data_size ((GMemoryOutputStream*)membuf), ==, SPLICELEN);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_main_loop_unref (data.loop);
g_object_unref (membuf);
g_object_unref (launcher);
g_object_unref (first);
g_object_unref (second);
g_object_unref (third);
}
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
typedef struct {
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GSubprocessFlags flags;
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
gboolean is_utf8;
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
gboolean running;
GError *error;
} TestAsyncCommunicateData;
static void
on_communicate_complete (GObject *proc,
GAsyncResult *result,
gpointer user_data)
{
TestAsyncCommunicateData *data = user_data;
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GBytes *stdout_bytes = NULL, *stderr_bytes = NULL;
char *stdout_str = NULL, *stderr_str = NULL;
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
const guint8 *stdout_data;
gsize stdout_len;
data->running = FALSE;
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
if (data->is_utf8)
(void) g_subprocess_communicate_utf8_finish ((GSubprocess*)proc, result,
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
&stdout_str, &stderr_str, &data->error);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
else
(void) g_subprocess_communicate_finish ((GSubprocess*)proc, result,
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
&stdout_bytes, &stderr_bytes, &data->error);
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
if (data->error)
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
return;
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
if (data->flags & G_SUBPROCESS_FLAGS_STDOUT_PIPE)
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
if (data->is_utf8)
{
stdout_data = (guint8*)stdout_str;
stdout_len = strlen (stdout_str);
}
else
stdout_data = g_bytes_get_data (stdout_bytes, &stdout_len);
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
g_assert_cmpmem (stdout_data, stdout_len, "# hello world" LINEEND, 13 + strlen (LINEEND));
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
}
else
{
g_assert_null (stdout_str);
g_assert_null (stdout_bytes);
}
if (data->flags & G_SUBPROCESS_FLAGS_STDERR_PIPE)
{
if (data->is_utf8)
g_assert_nonnull (stderr_str);
else
g_assert_nonnull (stderr_bytes);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
}
else
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_assert_null (stderr_str);
g_assert_null (stderr_bytes);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
}
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_clear_pointer (&stdout_bytes, g_bytes_unref);
g_clear_pointer (&stderr_bytes, g_bytes_unref);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
g_free (stdout_str);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_free (stderr_str);
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
}
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Test g_subprocess_communicate_async() works correctly with a variety of flags,
* as passed in via @test_data. */
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
static void
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
test_communicate_async (gconstpointer test_data)
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
GError *error = NULL;
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
GPtrArray *args;
Fix several missing initializer warnings in gio/tests/gsubprocess.c gio/tests/gsubprocess.c: In function ‘test_communicate_async’: gio/tests/gsubprocess.c:774:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 774 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async’: gio/tests/gsubprocess.c:1025:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1025 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_cancelled_async’: gio/tests/gsubprocess.c:1058:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1058 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async_invalid’: gio/tests/gsubprocess.c:1202:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1202 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~
2020-11-18 21:07:23 +01:00
TestAsyncCommunicateData data = { flags, 0, 0, NULL };
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
GSubprocess *proc;
GCancellable *cancellable = NULL;
GBytes *input;
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
const char *hellostring;
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
&error);
g_assert_no_error (error);
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
g_ptr_array_free (args, TRUE);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Include a leading hash and trailing newline so that if this gets onto the
* test’s stdout, it doesn’t mess up TAP output. */
hellostring = "# hello world\n";
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
input = g_bytes_new_static (hellostring, strlen (hellostring));
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
g_subprocess_communicate_async (proc, input,
cancellable,
on_communicate_complete,
&data);
data.running = TRUE;
while (data.running)
g_main_context_iteration (NULL, TRUE);
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
g_assert_no_error (data.error);
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
gsubprocess: Fix leaks in tests https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:54:28 +01:00
g_bytes_unref (input);
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
g_object_unref (proc);
}
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Test g_subprocess_communicate() works correctly with a variety of flags,
* as passed in via @test_data. */
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
static void
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
test_communicate (gconstpointer test_data)
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
GError *error = NULL;
GPtrArray *args;
GSubprocess *proc;
GCancellable *cancellable = NULL;
GBytes *input;
const gchar *hellostring;
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GBytes *stdout_bytes, *stderr_bytes;
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
const gchar *stdout_data;
gsize stdout_len;
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
&error);
g_assert_no_error (error);
g_ptr_array_free (args, TRUE);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Include a leading hash and trailing newline so that if this gets onto the
* test’s stdout, it doesn’t mess up TAP output. */
hellostring = "# hello world\n";
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
input = g_bytes_new_static (hellostring, strlen (hellostring));
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_subprocess_communicate (proc, input, cancellable, &stdout_bytes, &stderr_bytes, &error);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_assert_no_error (error);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
if (flags & G_SUBPROCESS_FLAGS_STDOUT_PIPE)
{
stdout_data = g_bytes_get_data (stdout_bytes, &stdout_len);
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
g_assert_cmpmem (stdout_data, stdout_len, "# hello world" LINEEND, 13 + strlen (LINEEND));
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
}
else
g_assert_null (stdout_bytes);
if (flags & G_SUBPROCESS_FLAGS_STDERR_PIPE)
g_assert_nonnull (stderr_bytes);
else
g_assert_null (stderr_bytes);
tests: Fix some leaks and double-frees in the GSubprocess tests Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-23 12:24:32 +02:00
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_bytes_unref (input);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_clear_pointer (&stdout_bytes, g_bytes_unref);
g_clear_pointer (&stderr_bytes, g_bytes_unref);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_object_unref (proc);
}
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
typedef struct {
GSubprocess *proc;
GCancellable *cancellable;
gboolean is_utf8;
gboolean running;
GError *error;
} TestCancelledCommunicateData;
static gboolean
on_test_communicate_cancelled_idle (gpointer user_data)
{
TestCancelledCommunicateData *data = user_data;
GBytes *input;
const gchar *hellostring;
GBytes *stdout_bytes = NULL, *stderr_bytes = NULL;
gchar *stdout_buf = NULL, *stderr_buf = NULL;
/* Include a leading hash and trailing newline so that if this gets onto the
* test’s stdout, it doesn’t mess up TAP output. */
hellostring = "# hello world\n";
input = g_bytes_new_static (hellostring, strlen (hellostring));
if (data->is_utf8)
g_subprocess_communicate_utf8 (data->proc, hellostring, data->cancellable,
&stdout_buf, &stderr_buf, &data->error);
else
g_subprocess_communicate (data->proc, input, data->cancellable, &stdout_bytes,
&stderr_bytes, &data->error);
data->running = FALSE;
if (data->is_utf8)
{
g_assert_null (stdout_buf);
g_assert_null (stderr_buf);
}
else
{
g_assert_null (stdout_bytes);
g_assert_null (stderr_bytes);
}
g_bytes_unref (input);
return G_SOURCE_REMOVE;
}
/* Test g_subprocess_communicate() can be cancelled correctly */
static void
test_communicate_cancelled (gconstpointer test_data)
{
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
GPtrArray *args;
GSubprocess *proc;
GCancellable *cancellable = NULL;
GError *error = NULL;
TestCancelledCommunicateData data = { 0 };
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
&error);
g_assert_no_error (error);
g_ptr_array_free (args, TRUE);
cancellable = g_cancellable_new ();
data.proc = proc;
data.cancellable = cancellable;
data.error = error;
g_cancellable_cancel (cancellable);
g_idle_add (on_test_communicate_cancelled_idle, &data);
data.running = TRUE;
while (data.running)
g_main_context_iteration (NULL, TRUE);
g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_clear_error (&data.error);
g_object_unref (cancellable);
g_object_unref (proc);
}
static void
on_communicate_cancelled_complete (GObject *proc,
GAsyncResult *result,
gpointer user_data)
{
TestAsyncCommunicateData *data = user_data;
GBytes *stdout_bytes = NULL, *stderr_bytes = NULL;
char *stdout_str = NULL, *stderr_str = NULL;
data->running = FALSE;
if (data->is_utf8)
(void) g_subprocess_communicate_utf8_finish ((GSubprocess*)proc, result,
&stdout_str, &stderr_str, &data->error);
else
(void) g_subprocess_communicate_finish ((GSubprocess*)proc, result,
&stdout_bytes, &stderr_bytes, &data->error);
if (data->is_utf8)
{
g_assert_null (stdout_str);
g_assert_null (stderr_str);
}
else
{
g_assert_null (stdout_bytes);
g_assert_null (stderr_bytes);
}
}
/* Test g_subprocess_communicate_async() can be cancelled correctly,
* as passed in via @test_data. */
static void
test_communicate_cancelled_async (gconstpointer test_data)
{
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
GError *error = NULL;
GPtrArray *args;
TestAsyncCommunicateData data = { 0 };
GSubprocess *proc;
GCancellable *cancellable = NULL;
GBytes *input;
const char *hellostring;
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
&error);
g_assert_no_error (error);
g_ptr_array_free (args, TRUE);
/* Include a leading hash and trailing newline so that if this gets onto the
* test’s stdout, it doesn’t mess up TAP output. */
hellostring = "# hello world\n";
input = g_bytes_new_static (hellostring, strlen (hellostring));
cancellable = g_cancellable_new ();
g_subprocess_communicate_async (proc, input,
cancellable,
on_communicate_cancelled_complete,
&data);
g_cancellable_cancel (cancellable);
data.running = TRUE;
while (data.running)
g_main_context_iteration (NULL, TRUE);
g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_clear_error (&data.error);
g_bytes_unref (input);
g_object_unref (cancellable);
g_object_unref (proc);
}
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Test g_subprocess_communicate_utf8_async() works correctly with a variety of
* flags, as passed in via @test_data. */
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
static void
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
test_communicate_utf8_async (gconstpointer test_data)
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
GError *error = NULL;
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
GPtrArray *args;
Fix several missing initializer warnings in gio/tests/gsubprocess.c gio/tests/gsubprocess.c: In function ‘test_communicate_async’: gio/tests/gsubprocess.c:774:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 774 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async’: gio/tests/gsubprocess.c:1025:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1025 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_cancelled_async’: gio/tests/gsubprocess.c:1058:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1058 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async_invalid’: gio/tests/gsubprocess.c:1202:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1202 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~
2020-11-18 21:07:23 +01:00
TestAsyncCommunicateData data = { flags, 0, 0, NULL };
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
GSubprocess *proc;
GCancellable *cancellable = NULL;
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
&error);
g_assert_no_error (error);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
g_ptr_array_free (args, TRUE);
data.is_utf8 = TRUE;
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_subprocess_communicate_utf8_async (proc, "# hello world\n",
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
cancellable,
on_communicate_complete,
&data);
data.running = TRUE;
while (data.running)
g_main_context_iteration (NULL, TRUE);
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
g_assert_no_error (data.error);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
g_object_unref (proc);
}
tree: Fix various typos and outdated terminology This was mostly machine generated with the following command: ``` codespell \ --builtin clear,rare,usage \ --skip './po/*' --skip './.git/*' --skip './NEWS*' \ --write-changes . ``` using the latest git version of `codespell` as per [these instructions](https://github.com/codespell-project/codespell#user-content-updating). Then I manually checked each change using `git add -p`, made a few manual fixups and dropped a load of incorrect changes. There are still some outdated or loaded terms used in GLib, mostly to do with git branch terminology. They will need to be changed later as part of a wider migration of git terminology. If I’ve missed anything, please file an issue! Signed-off-by: Philip Withnall <withnall@endlessm.com>
2020-06-12 15:02:30 +02:00
/* Test g_subprocess_communicate_utf8_async() can be cancelled correctly. */
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
static void
test_communicate_utf8_cancelled_async (gconstpointer test_data)
{
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
GError *error = NULL;
GPtrArray *args;
Fix several missing initializer warnings in gio/tests/gsubprocess.c gio/tests/gsubprocess.c: In function ‘test_communicate_async’: gio/tests/gsubprocess.c:774:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 774 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async’: gio/tests/gsubprocess.c:1025:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1025 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_cancelled_async’: gio/tests/gsubprocess.c:1058:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1058 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async_invalid’: gio/tests/gsubprocess.c:1202:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1202 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~
2020-11-18 21:07:23 +01:00
TestAsyncCommunicateData data = { flags, 0, 0, NULL };
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
GSubprocess *proc;
GCancellable *cancellable = NULL;
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
&error);
g_assert_no_error (error);
g_ptr_array_free (args, TRUE);
cancellable = g_cancellable_new ();
data.is_utf8 = TRUE;
g_subprocess_communicate_utf8_async (proc, "# hello world\n",
cancellable,
on_communicate_cancelled_complete,
&data);
g_cancellable_cancel (cancellable);
data.running = TRUE;
while (data.running)
g_main_context_iteration (NULL, TRUE);
g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_clear_error (&data.error);
g_object_unref (cancellable);
g_object_unref (proc);
}
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Test g_subprocess_communicate_utf8() works correctly with a variety of flags,
* as passed in via @test_data. */
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
static void
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
test_communicate_utf8 (gconstpointer test_data)
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
GError *error = NULL;
GPtrArray *args;
GSubprocess *proc;
GCancellable *cancellable = NULL;
const gchar *stdin_buf;
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
gchar *stdout_buf, *stderr_buf;
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
&error);
g_assert_no_error (error);
g_ptr_array_free (args, TRUE);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Include a leading hash and trailing newline so that if this gets onto the
* test’s stdout, it doesn’t mess up TAP output. */
stdin_buf = "# hello world\n";
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_subprocess_communicate_utf8 (proc, stdin_buf, cancellable, &stdout_buf, &stderr_buf, &error);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_assert_no_error (error);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
if (flags & G_SUBPROCESS_FLAGS_STDOUT_PIPE)
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
g_assert_cmpstr (stdout_buf, ==, "# hello world" LINEEND);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
else
g_assert_null (stdout_buf);
if (flags & G_SUBPROCESS_FLAGS_STDERR_PIPE)
g_assert_nonnull (stderr_buf);
else g_assert_null (stderr_buf);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_free (stdout_buf);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_free (stderr_buf);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_object_unref (proc);
}
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
/* Test g_subprocess_communicate_utf8() can be cancelled correctly */
static void
test_communicate_utf8_cancelled (gconstpointer test_data)
{
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
GPtrArray *args;
GSubprocess *proc;
GCancellable *cancellable = NULL;
GError *error = NULL;
TestCancelledCommunicateData data = { 0 };
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
&error);
g_assert_no_error (error);
g_ptr_array_free (args, TRUE);
cancellable = g_cancellable_new ();
data.proc = proc;
data.cancellable = cancellable;
data.error = error;
g_cancellable_cancel (cancellable);
g_idle_add (on_test_communicate_cancelled_idle, &data);
data.is_utf8 = TRUE;
data.running = TRUE;
while (data.running)
g_main_context_iteration (NULL, TRUE);
g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_clear_error (&data.error);
g_object_unref (cancellable);
g_object_unref (proc);
}
gsubprocess: test empty splices Make sure we handle the case that our splice returns no data properly. https://bugzilla.gnome.org/show_bug.cgi?id=724916
2014-03-04 03:25:16 +01:00
static void
test_communicate_nothing (void)
{
GError *error = NULL;
GPtrArray *args;
GSubprocess *proc;
GCancellable *cancellable = NULL;
gchar *stdout_buf;
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE
| G_SUBPROCESS_FLAGS_STDOUT_PIPE
| G_SUBPROCESS_FLAGS_STDERR_MERGE,
&error);
g_assert_no_error (error);
g_ptr_array_free (args, TRUE);
g_subprocess_communicate_utf8 (proc, "", cancellable, &stdout_buf, NULL, &error);
g_assert_no_error (error);
g_assert_cmpstr (stdout_buf, ==, "");
g_free (stdout_buf);
g_object_unref (proc);
}
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
static void
gsubprocess: Add a missing test for invalid UTF-8 output There were tests for invalid UTF-8 output when asynchronously communicating with a subprocess, but nothing for synchronous communication. Add such a test, and refine the code as a result. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2018-10-11 00:29:17 +02:00
test_communicate_utf8_async_invalid (void)
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
GSubprocessFlags flags = G_SUBPROCESS_FLAGS_STDOUT_PIPE;
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
GError *error = NULL;
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
GPtrArray *args;
Fix several missing initializer warnings in gio/tests/gsubprocess.c gio/tests/gsubprocess.c: In function ‘test_communicate_async’: gio/tests/gsubprocess.c:774:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 774 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async’: gio/tests/gsubprocess.c:1025:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1025 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_cancelled_async’: gio/tests/gsubprocess.c:1058:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1058 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~ gio/tests/gsubprocess.c: In function ‘test_communicate_utf8_async_invalid’: gio/tests/gsubprocess.c:1202:3: error: missing initializer for field ‘running’ of ‘TestAsyncCommunicateData’ 1202 | TestAsyncCommunicateData data = { flags, 0, }; | ^~~~~~~~~~~~~~~~~~~~~~~~
2020-11-18 21:07:23 +01:00
TestAsyncCommunicateData data = { flags, 0, 0, NULL };
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
GSubprocess *proc;
GCancellable *cancellable = NULL;
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
&error);
g_assert_no_error (error);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
g_ptr_array_free (args, TRUE);
data.is_utf8 = TRUE;
g_subprocess_communicate_utf8_async (proc, "\xFF\xFF",
cancellable,
on_communicate_complete,
&data);
data.running = TRUE;
while (data.running)
g_main_context_iteration (NULL, TRUE);
gsubprocess: Fix error detection logic in tests Various tests were depending on local_error being set by a callback when it could never have been the case. Simplify async error detection logic in those cases, and fix leak of GError. https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:53:13 +01:00
g_assert_error (data.error, G_IO_ERROR, G_IO_ERROR_FAILED);
g_error_free (data.error);
gsubprocess: Add UTF-8 variants of communicate() Over many years of writing code interacting with subprocesses, a pattern that comes up a lot is to run a child and get its output as UTF-8, to put inside a JSON document or render in a GtkTextBuffer, etc. It's very important to validate at the boundaries, and not say deep inside Pango. We could do this a bit more efficiently if done in a streaming fashion, but realistically this should be OK for now.
2013-10-15 16:04:54 +02:00
g_object_unref (proc);
}
gsubprocess: Add a missing test for invalid UTF-8 output There were tests for invalid UTF-8 output when asynchronously communicating with a subprocess, but nothing for synchronous communication. Add such a test, and refine the code as a result. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2018-10-11 00:29:17 +02:00
/* Test that invalid UTF-8 received using g_subprocess_communicate_utf8()
* results in an error. */
static void
test_communicate_utf8_invalid (void)
{
GSubprocessFlags flags = G_SUBPROCESS_FLAGS_STDOUT_PIPE;
GError *local_error = NULL;
gboolean ret;
GPtrArray *args;
gchar *stdout_str = NULL, *stderr_str = NULL;
GSubprocess *proc;
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_newv ((const gchar* const*)args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE | flags,
&local_error);
g_assert_no_error (local_error);
g_ptr_array_free (args, TRUE);
ret = g_subprocess_communicate_utf8 (proc, "\xFF\xFF", NULL,
&stdout_str, &stderr_str, &local_error);
g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_FAILED);
g_error_free (local_error);
g_assert_false (ret);
g_assert_null (stdout_str);
g_assert_null (stderr_str);
g_object_unref (proc);
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
static gboolean
send_terminate (gpointer user_data)
{
GSubprocess *proc = user_data;
g_subprocess_force_exit (proc);
return FALSE;
}
static void
on_request_quit_exited (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GSubprocess *subprocess = G_SUBPROCESS (object);
GError *error = NULL;
g_subprocess_wait_finish (subprocess, result, &error);
g_assert_no_error (error);
#ifdef G_OS_UNIX
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_true (g_subprocess_get_if_signaled (subprocess));
g_assert_cmpint (g_subprocess_get_term_sig (subprocess), ==, 9);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#endif
Distinguish more clearly between wait status and exit status On Unix platforms, wait() and friends yield an integer that encodes how the process exited. Confusingly, this is usually not the same as the integer passed to exit() or returned from main(): conceptually it's an integer encoding of this tagged union: enum { EXITED, SIGNALLED, ... } tag; union { int exit_status; /* if EXITED */ struct { int terminating_signal; bool core_dumped; } terminating_signal; /* if SIGNALLED */ ... } detail; Meanwhile, on Windows, wait statuses and exit statuses are interchangeable. I find that it's clearer what is going on if we are consistent about referring to the result of wait() as a "wait status", and the value passed to exit() as an "exit status". GSubprocess already gets this right: g_subprocess_get_status() returns the wait status, while g_subprocess_get_exit_status() genuinely returns the exit status. However, the GSpawn family of APIs has tended to conflate the two. Confusingly, g_spawn_check_exit_status() has always checked a wait status, and it would not be correct to pass an exit status to it; so let's deprecate it in favour of g_spawn_check_wait_status(), which does the same thing that g_spawn_check_exit_status() always did. Code that needs backwards-compatibility with older GLib can use: #if !GLIB_CHECK_VERSION(2, 69, 0) #define g_spawn_check_wait_status(x) (g_spawn_check_exit_status (x)) #endif Signed-off-by: Simon McVittie <smcv@collabora.com>
2021-06-14 13:51:01 +02:00
g_spawn_check_wait_status (g_subprocess_get_status (subprocess), &error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_nonnull (error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_clear_error (&error);
g_main_loop_quit ((GMainLoop*)user_data);
}
static void
test_terminate (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocess *proc;
GPtrArray *args;
GMainLoop *loop;
tests: Fix small race in GSubprocess tests This was introduced in commit 7846d6154a: g_subprocess_get_identifier() will return NULL after the subprocess has exited, and the subprocess in the `noop` test will exit as soon as it has started spawning. So if the scheduler scheduled the testprog subprocess quickly, descheduled the parent test process until the testprog exited, then the return value from g_subprocess_get_identifier() would be NULL. Move the g_subprocess_get_identifier() test to one which calls testprog in `sleep-forever` mode, since that is guaranteed not to exit until killed (which we do later in the test). Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-06-01 00:35:27 +02:00
const gchar *id;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
args = get_test_subprocess_args ("sleep-forever", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
tests: Fix small race in GSubprocess tests This was introduced in commit 7846d6154a: g_subprocess_get_identifier() will return NULL after the subprocess has exited, and the subprocess in the `noop` test will exit as soon as it has started spawning. So if the scheduler scheduled the testprog subprocess quickly, descheduled the parent test process until the testprog exited, then the return value from g_subprocess_get_identifier() would be NULL. Move the g_subprocess_get_identifier() test to one which calls testprog in `sleep-forever` mode, since that is guaranteed not to exit until killed (which we do later in the test). Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-06-01 00:35:27 +02:00
id = g_subprocess_get_identifier (proc);
g_assert_nonnull (id);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
loop = g_main_loop_new (NULL, TRUE);
g_subprocess_wait_async (proc, NULL, on_request_quit_exited, loop);
g_timeout_add_seconds (3, send_terminate, proc);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (proc);
}
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
#ifdef G_OS_UNIX
static gboolean
send_signal (gpointer user_data)
{
GSubprocess *proc = user_data;
g_subprocess_send_signal (proc, SIGKILL);
return FALSE;
}
static void
test_signal (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocess *proc;
GPtrArray *args;
GMainLoop *loop;
args = get_test_subprocess_args ("sleep-forever", NULL);
proc = g_subprocess_newv ((const gchar * const *) args->pdata, G_SUBPROCESS_FLAGS_NONE, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
loop = g_main_loop_new (NULL, TRUE);
g_subprocess_wait_async (proc, NULL, on_request_quit_exited, loop);
g_timeout_add_seconds (3, send_signal, proc);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (proc);
}
#endif
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
static void
test_env (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GInputStream *stdout_stream;
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
gchar *result;
GSubprocess test: Add PATH to the envtable that is passed to child envp in spawn() functions is the *whole* environment table for the child process. Including PATH. Thus, unless PATH is explicitly put into that table, the process will be spawned without PATH. Since on Windows binaries are found via PATH instead of LD_LIBRARY_PATH or whatever, almost no program (unless installed in WINDIR, maybe) can run without a PATH. Certainly not test programs - meson adds bld subdirs to the PATH to make sure that test programs use uninstalled glib at runtime. So make sure that PATH is passed along.
2019-02-12 00:53:38 +01:00
gchar *envp[] = { NULL, "ONE=1", "TWO=1", "THREE=3", "FOUR=1", NULL };
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
gchar **split;
GSubprocess test: Add PATH to the envtable that is passed to child envp in spawn() functions is the *whole* environment table for the child process. Including PATH. Thus, unless PATH is explicitly put into that table, the process will be spawned without PATH. Since on Windows binaries are found via PATH instead of LD_LIBRARY_PATH or whatever, almost no program (unless installed in WINDIR, maybe) can run without a PATH. Certainly not test programs - meson adds bld subdirs to the PATH to make sure that test programs use uninstalled glib at runtime. So make sure that PATH is passed along.
2019-02-12 00:53:38 +01:00
envp[0] = g_strdup_printf ("PATH=%s", g_getenv ("PATH"));
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
args = get_test_subprocess_args ("env", NULL);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE);
g_subprocess_launcher_set_flags (launcher, G_SUBPROCESS_FLAGS_STDOUT_PIPE);
g_subprocess_launcher_set_environ (launcher, envp);
g_subprocess_launcher_setenv (launcher, "TWO", "2", TRUE);
g_subprocess_launcher_setenv (launcher, "THREE", "1", FALSE);
g_subprocess_launcher_unsetenv (launcher, "FOUR");
g_assert_null (g_subprocess_launcher_getenv (launcher, "FOUR"));
Test g_subprocess_launcher_spawn The spawnv variant of this function already had a test, but spawn was not tested.
2013-11-28 07:36:29 +01:00
proc = g_subprocess_launcher_spawn (launcher, error, args->pdata[0], "env", NULL);
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
GSubprocess test: Add PATH to the envtable that is passed to child envp in spawn() functions is the *whole* environment table for the child process. Including PATH. Thus, unless PATH is explicitly put into that table, the process will be spawned without PATH. Since on Windows binaries are found via PATH instead of LD_LIBRARY_PATH or whatever, almost no program (unless installed in WINDIR, maybe) can run without a PATH. Certainly not test programs - meson adds bld subdirs to the PATH to make sure that test programs use uninstalled glib at runtime. So make sure that PATH is passed along.
2019-02-12 00:53:38 +01:00
g_free (envp[0]);
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdout_stream = g_subprocess_get_stdout_pipe (proc);
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
result = splice_to_string (stdout_stream, error);
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
split = g_strsplit (result, LINEEND, -1);
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
g_assert_cmpstr (g_environ_getenv (split, "ONE"), ==, "1");
g_assert_cmpstr (g_environ_getenv (split, "TWO"), ==, "2");
g_assert_cmpstr (g_environ_getenv (split, "THREE"), ==, "3");
g_assert_null (g_environ_getenv (split, "FOUR"));
g_strfreev (split);
g_free (result);
g_object_unref (proc);
tests: Fix some leaks and double-frees in the GSubprocess tests Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-23 12:24:32 +02:00
g_object_unref (launcher);
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
}
gsubprocess: Copy parent process’ environ when clearing subprocess’ Previously, this was done at the time of spawning the subprocess, which meant the g_subprocess_launcher_*_environ() functions could not be used to modify the parent process’ environment. Change the code to copy the parent process’ environment when g_subprocess_launcher_set_environ(NULL) is called. Document the change and add a unit test. https://bugzilla.gnome.org/show_bug.cgi?id=778422
2017-03-30 12:02:14 +02:00
/* Test that explicitly inheriting and modifying the parent process’
* environment works. */
static void
test_env_inherit (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GInputStream *stdout_stream;
gsubprocess: Copy parent process’ environ when clearing subprocess’ Previously, this was done at the time of spawning the subprocess, which meant the g_subprocess_launcher_*_environ() functions could not be used to modify the parent process’ environment. Change the code to copy the parent process’ environment when g_subprocess_launcher_set_environ(NULL) is called. Document the change and add a unit test. https://bugzilla.gnome.org/show_bug.cgi?id=778422
2017-03-30 12:02:14 +02:00
gchar *result;
gchar **split;
g_setenv ("TEST_ENV_INHERIT1", "1", TRUE);
g_setenv ("TEST_ENV_INHERIT2", "2", TRUE);
args = get_test_subprocess_args ("env", NULL);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE);
g_subprocess_launcher_set_flags (launcher, G_SUBPROCESS_FLAGS_STDOUT_PIPE);
g_subprocess_launcher_set_environ (launcher, NULL);
g_subprocess_launcher_setenv (launcher, "TWO", "2", TRUE);
g_subprocess_launcher_unsetenv (launcher, "TEST_ENV_INHERIT1");
g_assert_null (g_subprocess_launcher_getenv (launcher, "TEST_ENV_INHERIT1"));
g_assert_cmpstr (g_subprocess_launcher_getenv (launcher, "TEST_ENV_INHERIT2"), ==, "2");
g_assert_cmpstr (g_subprocess_launcher_getenv (launcher, "TWO"), ==, "2");
proc = g_subprocess_launcher_spawn (launcher, error, args->pdata[0], "env", NULL);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdout_stream = g_subprocess_get_stdout_pipe (proc);
gsubprocess: Copy parent process’ environ when clearing subprocess’ Previously, this was done at the time of spawning the subprocess, which meant the g_subprocess_launcher_*_environ() functions could not be used to modify the parent process’ environment. Change the code to copy the parent process’ environment when g_subprocess_launcher_set_environ(NULL) is called. Document the change and add a unit test. https://bugzilla.gnome.org/show_bug.cgi?id=778422
2017-03-30 12:02:14 +02:00
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
result = splice_to_string (stdout_stream, error);
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
split = g_strsplit (result, LINEEND, -1);
gsubprocess: Copy parent process’ environ when clearing subprocess’ Previously, this was done at the time of spawning the subprocess, which meant the g_subprocess_launcher_*_environ() functions could not be used to modify the parent process’ environment. Change the code to copy the parent process’ environment when g_subprocess_launcher_set_environ(NULL) is called. Document the change and add a unit test. https://bugzilla.gnome.org/show_bug.cgi?id=778422
2017-03-30 12:02:14 +02:00
g_assert_null (g_environ_getenv (split, "TEST_ENV_INHERIT1"));
g_assert_cmpstr (g_environ_getenv (split, "TEST_ENV_INHERIT2"), ==, "2");
g_assert_cmpstr (g_environ_getenv (split, "TWO"), ==, "2");
g_strfreev (split);
g_free (result);
g_object_unref (proc);
tests: Fix some leaks and double-frees in the GSubprocess tests Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-23 12:24:32 +02:00
g_object_unref (launcher);
gsubprocess: Copy parent process’ environ when clearing subprocess’ Previously, this was done at the time of spawning the subprocess, which meant the g_subprocess_launcher_*_environ() functions could not be used to modify the parent process’ environment. Change the code to copy the parent process’ environment when g_subprocess_launcher_set_environ(NULL) is called. Document the change and add a unit test. https://bugzilla.gnome.org/show_bug.cgi?id=778422
2017-03-30 12:02:14 +02:00
}
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
static void
test_cwd (void)
{
GError *local_error = NULL;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GInputStream *stdout_stream;
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
gchar *result;
tests: Fix incorrect basename comparison in gsubprocess test This was causing intermittent failures on macOS, depending on whether the tmpdir ended with a `/` or `/some-dir`. `g_strrstr()` is not the right function to use to extract a basename from a path, for this reason. When it failed, the macOS test was failing with: ``` ok 16 /gsubprocess/env Bail out! GLib-GIO:ERROR:../gio/tests/gsubprocess.c:1507:test_cwd: assertion failed (basename == tmp_lineend_basename): ("/T\n" == "/\n") ``` The test now passes reliably, which means that it can be removed from the list of expected failures on macOS. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #1392
2022-06-27 16:00:39 +02:00
gsize result_len;
const gchar *tmpdir = g_get_tmp_dir ();
gchar *tmpdir_basename = NULL, *result_basename = NULL;
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
args = get_test_subprocess_args ("cwd", NULL);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE);
g_subprocess_launcher_set_flags (launcher, G_SUBPROCESS_FLAGS_STDOUT_PIPE);
tests: Fix incorrect basename comparison in gsubprocess test This was causing intermittent failures on macOS, depending on whether the tmpdir ended with a `/` or `/some-dir`. `g_strrstr()` is not the right function to use to extract a basename from a path, for this reason. When it failed, the macOS test was failing with: ``` ok 16 /gsubprocess/env Bail out! GLib-GIO:ERROR:../gio/tests/gsubprocess.c:1507:test_cwd: assertion failed (basename == tmp_lineend_basename): ("/T\n" == "/\n") ``` The test now passes reliably, which means that it can be removed from the list of expected failures on macOS. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #1392
2022-06-27 16:00:39 +02:00
g_subprocess_launcher_set_cwd (launcher, tmpdir);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
tests: Fix incorrect basename comparison in gsubprocess test This was causing intermittent failures on macOS, depending on whether the tmpdir ended with a `/` or `/some-dir`. `g_strrstr()` is not the right function to use to extract a basename from a path, for this reason. When it failed, the macOS test was failing with: ``` ok 16 /gsubprocess/env Bail out! GLib-GIO:ERROR:../gio/tests/gsubprocess.c:1507:test_cwd: assertion failed (basename == tmp_lineend_basename): ("/T\n" == "/\n") ``` The test now passes reliably, which means that it can be removed from the list of expected failures on macOS. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #1392
2022-06-27 16:00:39 +02:00
proc = g_subprocess_launcher_spawnv (launcher, (const char * const *)args->pdata, &local_error);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdout_stream = g_subprocess_get_stdout_pipe (proc);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
tests: Fix incorrect basename comparison in gsubprocess test This was causing intermittent failures on macOS, depending on whether the tmpdir ended with a `/` or `/some-dir`. `g_strrstr()` is not the right function to use to extract a basename from a path, for this reason. When it failed, the macOS test was failing with: ``` ok 16 /gsubprocess/env Bail out! GLib-GIO:ERROR:../gio/tests/gsubprocess.c:1507:test_cwd: assertion failed (basename == tmp_lineend_basename): ("/T\n" == "/\n") ``` The test now passes reliably, which means that it can be removed from the list of expected failures on macOS. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #1392
2022-06-27 16:00:39 +02:00
result = splice_to_string (stdout_stream, &local_error);
g_assert_no_error (local_error);
result_len = strlen (result);
/* The result should end with a line ending */
g_assert_cmpstr (result + result_len - strlen (LINEEND), ==, LINEEND);
/* Not sure if the testprog guarantees to return an absolute path for the cwd,
* so only compare the basenames. */
tmpdir_basename = g_path_get_basename (tmpdir);
result_basename = g_path_get_basename (g_strstrip (result));
g_assert_cmpstr (tmpdir_basename, ==, result_basename);
g_free (tmpdir_basename);
g_free (result_basename);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
g_free (result);
g_object_unref (proc);
tests: Fix some leaks and double-frees in the GSubprocess tests Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-23 12:24:32 +02:00
g_object_unref (launcher);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#ifdef G_OS_UNIX
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
static void
test_subprocess_launcher_close (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
tests: Test g_subprocess_launcher_close() doesn’t close too many FDs Expand an existing unit test to check that the target FD of a `g_subprocess_launcher_take_fd()` call doesn’t get closed when `g_subprocess_launcher_close()` is called. Only the source FD should be closed by the parent process. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #2332
2021-02-19 19:09:42 +01:00
int fd, fd2;
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
gboolean is_open;
tests: Test g_subprocess_launcher_close() doesn’t close too many FDs Expand an existing unit test to check that the target FD of a `g_subprocess_launcher_take_fd()` call doesn’t get closed when `g_subprocess_launcher_close()` is called. Only the source FD should be closed by the parent process. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #2332
2021-02-19 19:09:42 +01:00
/* Open two arbitrary FDs. One of them, @fd, will be transferred to the
* launcher, and the other’s FD integer will be used as its target FD, giving
* the mapping `fd → fd2` if a child process were to be spawned.
*
* The launcher will then be closed, which should close @fd but *not* @fd2,
* as the value of @fd2 is only valid as an FD in a child process. (A child
* process is not actually spawned in this test.)
*/
fd = dup (0);
fd2 = dup (0);
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE);
tests: Test g_subprocess_launcher_close() doesn’t close too many FDs Expand an existing unit test to check that the target FD of a `g_subprocess_launcher_take_fd()` call doesn’t get closed when `g_subprocess_launcher_close()` is called. Only the source FD should be closed by the parent process. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #2332
2021-02-19 19:09:42 +01:00
g_subprocess_launcher_take_fd (launcher, fd, fd2);
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
is_open = fcntl (fd, F_GETFD) != -1;
g_assert_true (is_open);
tests: Test g_subprocess_launcher_close() doesn’t close too many FDs Expand an existing unit test to check that the target FD of a `g_subprocess_launcher_take_fd()` call doesn’t get closed when `g_subprocess_launcher_close()` is called. Only the source FD should be closed by the parent process. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #2332
2021-02-19 19:09:42 +01:00
is_open = fcntl (fd2, F_GETFD) != -1;
g_assert_true (is_open);
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
g_subprocess_launcher_close (launcher);
tests: Test g_subprocess_launcher_close() doesn’t close too many FDs Expand an existing unit test to check that the target FD of a `g_subprocess_launcher_take_fd()` call doesn’t get closed when `g_subprocess_launcher_close()` is called. Only the source FD should be closed by the parent process. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #2332
2021-02-19 19:09:42 +01:00
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
is_open = fcntl (fd, F_GETFD) != -1;
g_assert_false (is_open);
tests: Test g_subprocess_launcher_close() doesn’t close too many FDs Expand an existing unit test to check that the target FD of a `g_subprocess_launcher_take_fd()` call doesn’t get closed when `g_subprocess_launcher_close()` is called. Only the source FD should be closed by the parent process. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #2332
2021-02-19 19:09:42 +01:00
is_open = fcntl (fd2, F_GETFD) != -1;
g_assert_true (is_open);
/* Now test that actually trying to spawn the child gives %G_IO_ERROR_CLOSED,
* as g_subprocess_launcher_close() has been called. */
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
args = get_test_subprocess_args ("cat", NULL);
proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_ptr_array_free (args, TRUE);
g_assert_null (proc);
g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_CLOSED);
g_clear_error (error);
tests: Test g_subprocess_launcher_close() doesn’t close too many FDs Expand an existing unit test to check that the target FD of a `g_subprocess_launcher_take_fd()` call doesn’t get closed when `g_subprocess_launcher_close()` is called. Only the source FD should be closed by the parent process. Signed-off-by: Philip Withnall <pwithnall@endlessos.org> Helps: #2332
2021-02-19 19:09:42 +01:00
close (fd2);
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
g_object_unref (launcher);
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
static void
test_stdout_file (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
GFile *tmpfile;
GFileIOStream *iostream;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GOutputStream *stdin_stream;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
const char *test_data = "this is some test data\n";
char *tmp_contents;
char *tmp_file_path;
tmpfile = g_file_new_tmp ("gsubprocessXXXXXX", &iostream, error);
g_assert_no_error (local_error);
g_clear_object (&iostream);
tmp_file_path = g_file_get_path (tmpfile);
args = get_test_subprocess_args ("cat", NULL);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE);
g_subprocess_launcher_set_stdout_file_path (launcher, tmp_file_path);
proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdin_stream = g_subprocess_get_stdin_pipe (proc);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
g_output_stream_write_all (stdin_stream, test_data, strlen (test_data), NULL, NULL, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
g_output_stream_close (stdin_stream, NULL, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
g_subprocess_wait_check (proc, NULL, error);
g_object_unref (launcher);
g_object_unref (proc);
g_file_load_contents (tmpfile, NULL, &tmp_contents, NULL, NULL, error);
g_assert_no_error (local_error);
g_assert_cmpstr (test_data, ==, tmp_contents);
g_free (tmp_contents);
(void) g_file_delete (tmpfile, NULL, NULL);
gsubprocess: Fix leaks in tests https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:54:28 +01:00
g_object_unref (tmpfile);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_free (tmp_file_path);
}
static void
test_stdout_fd (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
GFile *tmpfile;
GFileIOStream *iostream;
GFileDescriptorBased *descriptor_stream;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GOutputStream *stdin_stream;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
const char *test_data = "this is some test data\n";
char *tmp_contents;
tmpfile = g_file_new_tmp ("gsubprocessXXXXXX", &iostream, error);
g_assert_no_error (local_error);
args = get_test_subprocess_args ("cat", NULL);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE);
descriptor_stream = G_FILE_DESCRIPTOR_BASED (g_io_stream_get_output_stream (G_IO_STREAM (iostream)));
g_subprocess_launcher_take_stdout_fd (launcher, dup (g_file_descriptor_based_get_fd (descriptor_stream)));
proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
g_clear_object (&iostream);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdin_stream = g_subprocess_get_stdin_pipe (proc);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
g_output_stream_write_all (stdin_stream, test_data, strlen (test_data), NULL, NULL, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
g_output_stream_close (stdin_stream, NULL, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
g_subprocess_wait_check (proc, NULL, error);
g_object_unref (launcher);
g_object_unref (proc);
g_file_load_contents (tmpfile, NULL, &tmp_contents, NULL, NULL, error);
g_assert_no_error (local_error);
g_assert_cmpstr (test_data, ==, tmp_contents);
g_free (tmp_contents);
(void) g_file_delete (tmpfile, NULL, NULL);
gsubprocess: Fix leaks in tests https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:54:28 +01:00
g_object_unref (tmpfile);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
}
static void
child_setup (gpointer user_data)
{
dup2 (GPOINTER_TO_INT (user_data), 1);
}
static void
test_child_setup (void)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
GFile *tmpfile;
GFileIOStream *iostream;
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
GOutputStream *stdin_stream;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
const char *test_data = "this is some test data\n";
char *tmp_contents;
int fd;
tmpfile = g_file_new_tmp ("gsubprocessXXXXXX", &iostream, error);
g_assert_no_error (local_error);
fd = g_file_descriptor_based_get_fd (G_FILE_DESCRIPTOR_BASED (g_io_stream_get_output_stream (G_IO_STREAM (iostream))));
args = get_test_subprocess_args ("cat", NULL);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_PIPE);
g_subprocess_launcher_set_child_setup (launcher, child_setup, GINT_TO_POINTER (fd), NULL);
proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
g_clear_object (&iostream);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
stdin_stream = g_subprocess_get_stdin_pipe (proc);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
g_output_stream_write_all (stdin_stream, test_data, strlen (test_data), NULL, NULL, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
Tests: gsubprocess: Do not use stdin/stdout variables https://bugzilla.gnome.org/show_bug.cgi?id=795406
2018-04-20 18:10:18 +02:00
g_output_stream_close (stdin_stream, NULL, error);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_assert_no_error (local_error);
g_subprocess_wait_check (proc, NULL, error);
g_object_unref (launcher);
g_object_unref (proc);
g_file_load_contents (tmpfile, NULL, &tmp_contents, NULL, NULL, error);
g_assert_no_error (local_error);
g_assert_cmpstr (test_data, ==, tmp_contents);
g_free (tmp_contents);
(void) g_file_delete (tmpfile, NULL, NULL);
gsubprocess: Fix leaks in tests https://bugzilla.gnome.org/show_bug.cgi?id=711802
2013-11-09 08:54:28 +01:00
g_object_unref (tmpfile);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
}
static void
gsubprocess: ensure we test fd remapping on the posix_spawn() codepath We should run test_pass_fd twice, once using gspawn's fork/exec codepath and once attempting to use its posix_spawn() codepath. There's no guarantee we'll actually get the posix_spawn() codepath, but it works for now on Linux. For good measure, run it a third time with no flags at all. This causes the test to fail if I separately break the fd remapping implementation. Without this, we fail to test fd remapping on the posix_spawn() codepath.
2021-12-14 20:36:29 +01:00
do_test_pass_fd (GSubprocessFlags flags,
GSpawnChildSetupFunc child_setup)
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
{
GError *local_error = NULL;
GError **error = &local_error;
GInputStream *child_input;
GDataInputStream *child_datainput;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
int basic_pipefds[2];
int needdup_pipefds[2];
char *buf;
gsize len;
char *basic_fd_str;
char *needdup_fd_str;
g_unix_open_pipe (basic_pipefds, FD_CLOEXEC, error);
g_assert_no_error (local_error);
g_unix_open_pipe (needdup_pipefds, FD_CLOEXEC, error);
g_assert_no_error (local_error);
basic_fd_str = g_strdup_printf ("%d", basic_pipefds[1]);
needdup_fd_str = g_strdup_printf ("%d", needdup_pipefds[1] + 1);
args = get_test_subprocess_args ("write-to-fds", basic_fd_str, needdup_fd_str, NULL);
gsubprocess: ensure we test fd remapping on the posix_spawn() codepath We should run test_pass_fd twice, once using gspawn's fork/exec codepath and once attempting to use its posix_spawn() codepath. There's no guarantee we'll actually get the posix_spawn() codepath, but it works for now on Linux. For good measure, run it a third time with no flags at all. This causes the test to fail if I separately break the fd remapping implementation. Without this, we fail to test fd remapping on the posix_spawn() codepath.
2021-12-14 20:36:29 +01:00
launcher = g_subprocess_launcher_new (flags);
gsubprocess: Fix up communicate We weren't closing the streams after we were done reading or writing, which is kind of essential. The easy way to fix this is to just use g_output_stream_splice() to a GMemoryOutputStream rather than hand-rolling it. This results in a substantial reduction of code complexity. A second serious issue is that we were marking the task as complete when the process exits, but that's racy - there could still be data to read from stdout. Fix this by just refcounting outstanding operations. This code, not surprisingly, looks a lot like the "multi" test. Next, because processes output binary data, I'd be forced to annotate the char*/length pairs as (array) (element-type uint8). But rather than doing that, it's *far* simpler to just use GBytes. We need a version of this that actually validates as UTF-8, that will be in the next patch.
2013-10-15 01:12:22 +02:00
g_subprocess_launcher_take_fd (launcher, basic_pipefds[1], basic_pipefds[1]);
g_subprocess_launcher_take_fd (launcher, needdup_pipefds[1], needdup_pipefds[1] + 1);
gsubprocess: ensure we test fd remapping on the posix_spawn() codepath We should run test_pass_fd twice, once using gspawn's fork/exec codepath and once attempting to use its posix_spawn() codepath. There's no guarantee we'll actually get the posix_spawn() codepath, but it works for now on Linux. For good measure, run it a third time with no flags at all. This causes the test to fail if I separately break the fd remapping implementation. Without this, we fail to test fd remapping on the posix_spawn() codepath.
2021-12-14 20:36:29 +01:00
if (child_setup != NULL)
g_subprocess_launcher_set_child_setup (launcher, child_setup, NULL, NULL);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, error);
g_ptr_array_free (args, TRUE);
g_assert_no_error (local_error);
g_free (basic_fd_str);
g_free (needdup_fd_str);
child_input = g_unix_input_stream_new (basic_pipefds[0], TRUE);
child_datainput = g_data_input_stream_new (child_input);
buf = g_data_input_stream_read_line_utf8 (child_datainput, &len, NULL, error);
g_assert_no_error (local_error);
g_assert_cmpstr (buf, ==, "hello world");
g_object_unref (child_datainput);
g_object_unref (child_input);
g_free (buf);
child_input = g_unix_input_stream_new (needdup_pipefds[0], TRUE);
child_datainput = g_data_input_stream_new (child_input);
buf = g_data_input_stream_read_line_utf8 (child_datainput, &len, NULL, error);
g_assert_no_error (local_error);
g_assert_cmpstr (buf, ==, "hello world");
g_free (buf);
g_object_unref (child_datainput);
g_object_unref (child_input);
g_object_unref (launcher);
g_object_unref (proc);
}
gsubprocess: ensure we test fd remapping on the posix_spawn() codepath We should run test_pass_fd twice, once using gspawn's fork/exec codepath and once attempting to use its posix_spawn() codepath. There's no guarantee we'll actually get the posix_spawn() codepath, but it works for now on Linux. For good measure, run it a third time with no flags at all. This causes the test to fail if I separately break the fd remapping implementation. Without this, we fail to test fd remapping on the posix_spawn() codepath.
2021-12-14 20:36:29 +01:00
static void
test_pass_fd (void)
{
do_test_pass_fd (G_SUBPROCESS_FLAGS_NONE, NULL);
}
static void
empty_child_setup (gpointer user_data)
{
}
static void
test_pass_fd_empty_child_setup (void)
{
/* Using a child setup function forces gspawn to use fork/exec
* rather than posix_spawn.
*/
do_test_pass_fd (G_SUBPROCESS_FLAGS_NONE, empty_child_setup);
}
static void
test_pass_fd_inherit_fds (void)
{
/* Try to test the optimized posix_spawn codepath instead of
* fork/exec. Currently this requires using INHERIT_FDS since gspawn's
* posix_spawn codepath does not currently handle closing
* non-inherited fds. Note that using INHERIT_FDS means our testing of
* g_subprocess_launcher_take_fd() is less-comprehensive than when
* using G_SUBPROCESS_FLAGS_NONE.
*/
do_test_pass_fd (G_SUBPROCESS_FLAGS_INHERIT_FDS, NULL);
}
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
static void
do_test_fd_conflation (GSubprocessFlags flags,
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
GSpawnChildSetupFunc child_setup,
gboolean test_child_err_report_fd)
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
{
char success_message[] = "Yay success!";
GError *error = NULL;
GOutputStream *output_stream;
GSubprocessLauncher *launcher;
GSubprocess *proc;
GPtrArray *args;
int unused_pipefds[2];
int pipefds[2];
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
int fd_to_pass_to_child;
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
gsize bytes_written;
gboolean success;
char *fd_str;
/* This test must run in a new process because it is extremely sensitive to
* order of opened fds.
*/
if (!g_test_subprocess ())
{
g_test_trap_subprocess (NULL, 0, G_TEST_SUBPROCESS_INHERIT_STDOUT | G_TEST_SUBPROCESS_INHERIT_STDERR);
g_test_trap_assert_passed ();
return;
}
g_unix_open_pipe (unused_pipefds, FD_CLOEXEC, &error);
g_assert_no_error (error);
g_unix_open_pipe (pipefds, FD_CLOEXEC, &error);
g_assert_no_error (error);
/* The fds should be sequential since we are in a new process. */
g_assert_cmpint (unused_pipefds[0] /* 3 */, ==, unused_pipefds[1] - 1);
g_assert_cmpint (unused_pipefds[1] /* 4 */, ==, pipefds[0] - 1);
g_assert_cmpint (pipefds[0] /* 5 */, ==, pipefds[1] /* 6 */ - 1);
/* Because GSubprocess allows arbitrary remapping of fds, it has to be careful
* to avoid fd conflation issues, e.g. it should properly handle 5 -> 4 and
* 4 -> 5 at the same time. GIO previously attempted to handle this by naively
* dup'ing the source fds, but this was not good enough because it was
* possible that the dup'ed result could still conflict with one of the target
* fds. For example:
*
* source_fd 5 -> target_fd 9, source_fd 3 -> target_fd 7
*
* dup(5) -> dup returns 8
* dup(3) -> dup returns 9
*
* After dup'ing, we wind up with: 8 -> 9, 9 -> 7. That means that after we
* dup2(8, 9), we have clobbered fd 9 before we dup2(9, 7). The end result is
* we have remapped 5 -> 9 as expected, but then remapped 5 -> 7 instead of
* 3 -> 7 as the application intended.
*
* This issue has been fixed in the simplest way possible, by passing a
* minimum fd value when using F_DUPFD_CLOEXEC that is higher than any of the
* target fds, to guarantee all source fds are different than all target fds,
* eliminating any possibility of conflation.
*
* Anyway, that is why we have the unused_pipefds here. We need to open fds in
* a certain order in order to trick older GSubprocess into conflating the
* fds. The primary goal of this test is to ensure this particular conflation
* issue is not reintroduced. See glib#2503.
*
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
* This test also has an alternate mode of operation where it instead tests
* for conflation with gspawn's child_err_report_fd, glib#2506.
*
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
* Be aware this test is necessarily extremely fragile. To reproduce these
* bugs, it relies on internals of gspawn and gmain that will likely change
* in the future, eventually causing this test to no longer test the bugs
* it was originally designed to test. That is OK! If the test fails, at
* least you know *something* is wrong.
*/
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
if (test_child_err_report_fd)
fd_to_pass_to_child = pipefds[1] + 2 /* 8 */;
else
fd_to_pass_to_child = pipefds[1] + 3 /* 9 */;
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
launcher = g_subprocess_launcher_new (flags);
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
g_subprocess_launcher_take_fd (launcher, pipefds[0] /* 5 */, fd_to_pass_to_child);
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
g_subprocess_launcher_take_fd (launcher, unused_pipefds[0] /* 3 */, pipefds[1] + 1 /* 7 */);
if (child_setup != NULL)
g_subprocess_launcher_set_child_setup (launcher, child_setup, NULL, NULL);
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
fd_str = g_strdup_printf ("%d", fd_to_pass_to_child);
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
args = get_test_subprocess_args ("read-from-fd", fd_str, NULL);
proc = g_subprocess_launcher_spawnv (launcher, (const gchar * const *) args->pdata, &error);
g_assert_no_error (error);
g_assert_nonnull (proc);
g_ptr_array_free (args, TRUE);
g_object_unref (launcher);
g_free (fd_str);
/* Close the read ends of the pipes. */
close (unused_pipefds[0]);
close (pipefds[0]);
/* Also close the write end of the unused pipe. */
close (unused_pipefds[1]);
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
/* If doing our normal test:
*
* So now pipefds[0] should be inherited into the subprocess as
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
* pipefds[1] + 2, and unused_pipefds[0] should be inherited as
* pipefds[1] + 1. We will write to pipefds[1] and the subprocess will verify
* that it reads the expected data. But older broken GIO will accidentally
* clobber pipefds[1] + 2 with pipefds[1] + 1! This will cause the subprocess
* to hang trying to read from the wrong pipe.
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
*
* If testing conflation with child_err_report_fd:
*
* We are actually already done. The real test succeeded if we made it this
* far without hanging while spawning the child. But let's continue with our
* write and read anyway, to ensure things are good.
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
*/
output_stream = g_unix_output_stream_new (pipefds[1], TRUE);
success = g_output_stream_write_all (output_stream,
success_message, sizeof (success_message),
&bytes_written,
NULL,
&error);
g_assert_no_error (error);
g_assert_cmpint (bytes_written, ==, sizeof (success_message));
g_assert_true (success);
g_object_unref (output_stream);
success = g_subprocess_wait_check (proc, NULL, &error);
g_assert_no_error (error);
g_object_unref (proc);
}
static void
test_fd_conflation (void)
{
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
do_test_fd_conflation (G_SUBPROCESS_FLAGS_NONE, NULL, FALSE);
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
}
static void
test_fd_conflation_empty_child_setup (void)
{
/* Using a child setup function forces gspawn to use fork/exec
* rather than posix_spawn.
*/
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
do_test_fd_conflation (G_SUBPROCESS_FLAGS_NONE, empty_child_setup, FALSE);
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
}
static void
test_fd_conflation_inherit_fds (void)
{
/* Try to test the optimized posix_spawn codepath instead of
* fork/exec. Currently this requires using INHERIT_FDS since gspawn's
* posix_spawn codepath does not currently handle closing
* non-inherited fds.
*/
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
do_test_fd_conflation (G_SUBPROCESS_FLAGS_INHERIT_FDS, NULL, FALSE);
}
static void
test_fd_conflation_child_err_report_fd (void)
{
/* Using a child setup function forces gspawn to use fork/exec
* rather than posix_spawn.
*/
do_test_fd_conflation (G_SUBPROCESS_FLAGS_NONE, empty_child_setup, TRUE);
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#endif
gsubprocess: test environment a bit more Add a test for GSubprocess to test setting, unsetting and inheritance of environment variables. Use communicate() to give it a bit more of a workout as well. https://bugzilla.gnome.org/show_bug.cgi?id=725651
2014-03-04 15:08:24 +01:00
static void
test_launcher_environment (void)
{
GSubprocessLauncher *launcher;
GError *error = NULL;
GSubprocess *proc;
GPtrArray *args;
gchar *out;
g_setenv ("A", "B", TRUE);
g_setenv ("C", "D", TRUE);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE);
/* unset a variable */
g_subprocess_launcher_unsetenv (launcher, "A");
tree: Fix various typos and outdated terminology This was mostly machine generated with the following command: ``` codespell \ --builtin clear,rare,usage \ --skip './po/*' --skip './.git/*' --skip './NEWS*' \ --write-changes . ``` using the latest git version of `codespell` as per [these instructions](https://github.com/codespell-project/codespell#user-content-updating). Then I manually checked each change using `git add -p`, made a few manual fixups and dropped a load of incorrect changes. There are still some outdated or loaded terms used in GLib, mostly to do with git branch terminology. They will need to be changed later as part of a wider migration of git terminology. If I’ve missed anything, please file an issue! Signed-off-by: Philip Withnall <withnall@endlessm.com>
2020-06-12 15:02:30 +02:00
/* and set a different one */
gsubprocess: test environment a bit more Add a test for GSubprocess to test setting, unsetting and inheritance of environment variables. Use communicate() to give it a bit more of a workout as well. https://bugzilla.gnome.org/show_bug.cgi?id=725651
2014-03-04 15:08:24 +01:00
g_subprocess_launcher_setenv (launcher, "E", "F", TRUE);
args = get_test_subprocess_args ("printenv", "A", "C", "E", NULL);
proc = g_subprocess_launcher_spawnv (launcher, (const gchar **) args->pdata, &error);
g_assert_no_error (error);
tests: Convert g_assert() to g_assert_*() in gio/tests/gsubprocess.c g_assert_*() give more informative failure messages, and aren’t compiled out when building with G_DISABLE_ASSERT. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2019-03-05 11:57:29 +01:00
g_assert_nonnull (proc);
gsubprocess: test environment a bit more Add a test for GSubprocess to test setting, unsetting and inheritance of environment variables. Use communicate() to give it a bit more of a workout as well. https://bugzilla.gnome.org/show_bug.cgi?id=725651
2014-03-04 15:08:24 +01:00
g_subprocess_communicate_utf8 (proc, NULL, NULL, &out, NULL, &error);
g_assert_no_error (error);
GSubprocess test: Use LINEEND more Windows \r\n EOLs strike again. The test already knows about LINEEND, so make it use LINEEND more (instead of swithcing pipes to binary mode). This also applies to counting the bytes read.
2019-02-12 00:51:53 +01:00
g_assert_cmpstr (out, ==, "C=D" LINEEND "E=F" LINEEND);
gsubprocess: test environment a bit more Add a test for GSubprocess to test setting, unsetting and inheritance of environment variables. Use communicate() to give it a bit more of a workout as well. https://bugzilla.gnome.org/show_bug.cgi?id=725651
2014-03-04 15:08:24 +01:00
g_free (out);
g_object_unref (proc);
tests: Fix some leaks and double-frees in the GSubprocess tests Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-23 12:24:32 +02:00
g_object_unref (launcher);
g_ptr_array_unref (args);
gsubprocess: test environment a bit more Add a test for GSubprocess to test setting, unsetting and inheritance of environment variables. Use communicate() to give it a bit more of a workout as well. https://bugzilla.gnome.org/show_bug.cgi?id=725651
2014-03-04 15:08:24 +01:00
}
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
int
main (int argc, char **argv)
{
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
const struct
{
const gchar *subtest;
GSubprocessFlags flags;
}
flags_vectors[] =
{
{ "", G_SUBPROCESS_FLAGS_STDOUT_PIPE | G_SUBPROCESS_FLAGS_STDERR_MERGE },
{ "/no-pipes", G_SUBPROCESS_FLAGS_NONE },
{ "/separate-stderr", G_SUBPROCESS_FLAGS_STDOUT_PIPE | G_SUBPROCESS_FLAGS_STDERR_PIPE },
{ "/stdout-only", G_SUBPROCESS_FLAGS_STDOUT_PIPE },
{ "/stderr-only", G_SUBPROCESS_FLAGS_STDERR_PIPE },
{ "/stdout-silence", G_SUBPROCESS_FLAGS_STDOUT_SILENCE },
};
gsize i;
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/gsubprocess/noop", test_noop);
g_test_add_func ("/gsubprocess/noop-all-to-null", test_noop_all_to_null);
g_test_add_func ("/gsubprocess/noop-no-wait", test_noop_no_wait);
g_test_add_func ("/gsubprocess/noop-stdin-inherit", test_noop_stdin_inherit);
#ifdef G_OS_UNIX
g_test_add_func ("/gsubprocess/search-path", test_search_path);
gsubprocess: Add G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP
2021-11-17 13:27:46 +01:00
g_test_add_func ("/gsubprocess/search-path-from-envp", test_search_path_from_envp);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_test_add_func ("/gsubprocess/signal", test_signal);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#endif
g_test_add_func ("/gsubprocess/exit1", test_exit1);
gio: failing cases for subprocess cancellable bug https://bugzilla.gnome.org/show_bug.cgi?id=786456
2017-08-18 11:41:46 +02:00
g_test_add_func ("/gsubprocess/exit1/cancel", test_exit1_cancel);
g_test_add_func ("/gsubprocess/exit1/cancel_in_cb", test_exit1_cancel_in_cb);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_test_add_func ("/gsubprocess/echo1", test_echo1);
#ifdef G_OS_UNIX
g_test_add_func ("/gsubprocess/echo-merged", test_echo_merged);
#endif
g_test_add_func ("/gsubprocess/cat-utf8", test_cat_utf8);
g_test_add_func ("/gsubprocess/cat-eof", test_cat_eof);
g_test_add_func ("/gsubprocess/multi1", test_multi_1);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
/* Add various tests for g_subprocess_communicate() with different flags. */
for (i = 0; i < G_N_ELEMENTS (flags_vectors); i++)
{
gchar *test_path = NULL;
test_path = g_strdup_printf ("/gsubprocess/communicate%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate);
g_free (test_path);
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
test_path = g_strdup_printf ("/gsubprocess/communicate/cancelled%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate_cancelled);
g_free (test_path);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
test_path = g_strdup_printf ("/gsubprocess/communicate/async%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate_async);
g_free (test_path);
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
test_path = g_strdup_printf ("/gsubprocess/communicate/async/cancelled%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate_cancelled_async);
g_free (test_path);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
test_path = g_strdup_printf ("/gsubprocess/communicate/utf8%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate_utf8);
g_free (test_path);
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
test_path = g_strdup_printf ("/gsubprocess/communicate/utf8/cancelled%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate_utf8_cancelled);
g_free (test_path);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
test_path = g_strdup_printf ("/gsubprocess/communicate/utf8/async%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate_utf8_async);
g_free (test_path);
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
test_path = g_strdup_printf ("/gsubprocess/communicate/utf8/async/cancelled%s", flags_vectors[i].subtest);
g_test_add_data_func (test_path, GINT_TO_POINTER (flags_vectors[i].flags),
test_communicate_utf8_cancelled_async);
g_free (test_path);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
}
gsubprocess: Add a missing test for invalid UTF-8 output There were tests for invalid UTF-8 output when asynchronously communicating with a subprocess, but nothing for synchronous communication. Add such a test, and refine the code as a result. Signed-off-by: Philip Withnall <withnall@endlessm.com>
2018-10-11 00:29:17 +02:00
g_test_add_func ("/gsubprocess/communicate/utf8/async/invalid", test_communicate_utf8_async_invalid);
gsubprocess: Fix a critical calling communicate() with no pipes If calling g_subprocess_communicate() on a GSubprocess with no stdout/stderr pipe, a critical warning would be emitted from g_memory_output_stream_steal_as_bytes(), as it would be called on a NULL output stream. Fix that, improve the relevant GIR annotations, and expand the unit tests to cover it (and various other combinations of flags). Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=793331
2018-02-09 13:25:54 +01:00
g_test_add_func ("/gsubprocess/communicate/utf8/invalid", test_communicate_utf8_invalid);
g_test_add_func ("/gsubprocess/communicate/nothing", test_communicate_nothing);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_test_add_func ("/gsubprocess/terminate", test_terminate);
Test some more GSubProcess api This covers g_subprocess_set_environ, g_subprocess_setenv, g_subprocess_getenv, and g_subprocess_set_flags.
2013-11-28 07:12:26 +01:00
g_test_add_func ("/gsubprocess/env", test_env);
gsubprocess: Copy parent process’ environ when clearing subprocess’ Previously, this was done at the time of spawning the subprocess, which meant the g_subprocess_launcher_*_environ() functions could not be used to modify the parent process’ environment. Change the code to copy the parent process’ environment when g_subprocess_launcher_set_environ(NULL) is called. Document the change and add a unit test. https://bugzilla.gnome.org/show_bug.cgi?id=778422
2017-03-30 12:02:14 +02:00
g_test_add_func ("/gsubprocess/env/inherit", test_env_inherit);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
g_test_add_func ("/gsubprocess/cwd", test_cwd);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#ifdef G_OS_UNIX
GSubprocessLauncher: allow to close passed FDs By default, when using g_subprocess_launcher_take_fd() to pass an FD to a child, the GSubprocessLauncher object also takes ownership of the FD in the parent, and closes it during finalize(). This is a reasonable assumption in the majority of the cases, but sometimes it isn't a good idea. An example is when creating a GSubprocessLauncher in JavaScript: here, the destruction process is managed by the Garbage Collector, which means that those sockets will remain opened for some time after all the references to the object has been droped. This means that it could be not possible to detect when the child has closed that same FD, because in order to make that work, both FDs instances (the one in the parent and the one in the children) must be closed. This can be a problem in, as an example, a process that launches a child that communicates with Wayland using an specific socket (like when using the new API MetaWaylandClient). Of course, it isn't a valid solution to manually call close() in the parent process just after the call to spawn(), because the FD number could be reused in the time between it is manually closed, and when the object is destroyed and closes again that FD. If that happens, it will close an incorrect FD. One solution could be to call run_dispose() from Javascript on the GSubprocessLauncher object, to force freeing the resources. Unfortunately, the current code frees them in the finalize() method, not in dispose() (this is fixed in !1670 (merged) ) but it isn't a very elegant solution. This proposal adds a new method, g_subprocess_launcher_close(), that allows to close the FDs passed to the child. To avoid problems, after closing an FD with this method, no more spawns are allowed. Fix: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1677
2020-10-04 14:34:41 +02:00
g_test_add_func ("/gsubprocess/launcher-close", test_subprocess_launcher_close);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
g_test_add_func ("/gsubprocess/stdout-file", test_stdout_file);
g_test_add_func ("/gsubprocess/stdout-fd", test_stdout_fd);
g_test_add_func ("/gsubprocess/child-setup", test_child_setup);
gsubprocess: ensure we test fd remapping on the posix_spawn() codepath We should run test_pass_fd twice, once using gspawn's fork/exec codepath and once attempting to use its posix_spawn() codepath. There's no guarantee we'll actually get the posix_spawn() codepath, but it works for now on Linux. For good measure, run it a third time with no flags at all. This causes the test to fail if I separately break the fd remapping implementation. Without this, we fail to test fd remapping on the posix_spawn() codepath.
2021-12-14 20:36:29 +01:00
g_test_add_func ("/gsubprocess/pass-fd/basic", test_pass_fd);
g_test_add_func ("/gsubprocess/pass-fd/empty-child-setup", test_pass_fd_empty_child_setup);
g_test_add_func ("/gsubprocess/pass-fd/inherit-fds", test_pass_fd_inherit_fds);
Add tests for GSubprocess fd conflation issues This tests for #2503. It's fragile, but there is no non-fragile way to test this. If the test breaks in the future, it will pass without successfully testing the bug, not fail spuriously, so I think this is OK.
2021-12-14 20:36:31 +01:00
g_test_add_func ("/gsubprocess/fd-conflation/basic", test_fd_conflation);
g_test_add_func ("/gsubprocess/fd-conflation/empty-child-setup", test_fd_conflation_empty_child_setup);
g_test_add_func ("/gsubprocess/fd-conflation/inherit-fds", test_fd_conflation_inherit_fds);
Add test for child_err_report_fd conflation with target fds This tests for glib#2506.
2021-12-14 20:36:32 +01:00
g_test_add_func ("/gsubprocess/fd-conflation/child-err-report-fd", test_fd_conflation_child_err_report_fd);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
#endif
gsubprocess: test environment a bit more Add a test for GSubprocess to test setting, unsetting and inheritance of environment variables. Use communicate() to give it a bit more of a workout as well. https://bugzilla.gnome.org/show_bug.cgi?id=725651
2014-03-04 15:08:24 +01:00
g_test_add_func ("/gsubprocess/launcher-environment", test_launcher_environment);
GSubprocess: New class for spawning child processes There are a number of nice things this class brings: 0) Has a race-free termination API on all platforms (on UNIX, calls to kill() and waitpid() are coordinated as not to cause problems). 1) Operates in terms of G{Input,Output}Stream, not file descriptors 2) Standard GIO-style async API for wait() with cancellation 3) Makes some simple cases easy, like synchronously spawning a process with an argument list 4) Makes hard cases possible, like asynchronously running a process with stdout/stderr merged, output directly to a file path Much rewriting and code review from Ryan Lortie <desrt@desrt.ca> https://bugzilla.gnome.org/show_bug.cgi?id=672102
2012-05-17 20:37:17 +02:00
return g_test_run ();
}
Reference in New Issue Copy Permalink