luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-10 11:26:16 +01:00
Code Issues Packages Projects Releases Wiki Activity
6a724d9ccd
glib/gio/tests/gsubprocess.c

1846 lines
55 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>
#include <gio/gfiledescriptorbased.h>
#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: 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
const char *binname;
va_list args;
gpointer arg;
ret = g_ptr_array_new_with_free_func (g_free);
#ifdef G_OS_WIN32
binname = "gsubprocess-testprog.exe";
#else
binname = "gsubprocess-testprog";
#endif
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
path = g_test_build_filename (G_TEST_BUILT, binname, NULL);
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;
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01: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 ("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);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
id = g_subprocess_get_identifier (proc);
g_assert (id != 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
g_subprocess_wait_check (proc, NULL, error);
g_assert_no_error (local_error);
Improve GSubprocess test coverage Test the synchronous communicate functions.
2013-12-23 18:08:08 +01:00
g_assert (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);
g_assert (ret);
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);
}
#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);
g_assert (!ret);
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 };
g_test_bug ("786456");
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);
g_assert (!ret);
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 };
g_test_bug ("786456");
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);
g_assert (cat);
/* 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);
g_assert (result);
/* 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);
g_assert (!s);
/* Check that the process has exited as a result of the EOF */
result = g_subprocess_wait (cat, NULL, &error);
g_assert_no_error (error);
g_assert (g_subprocess_get_if_exited (cat));
g_assert_cmpint (g_subprocess_get_exit_status (cat), ==, 0);
g_assert (result);
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);
}
}
g_spawn_check_exit_status (g_subprocess_get_exit_status (subprocess), &error);
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);
g_assert (!data.caught_error);
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;
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
TestAsyncCommunicateData data = { flags, 0, };
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;
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
TestAsyncCommunicateData data = { flags, 0, };
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);
}
tests, subprocess: units for cancelled communications
2018-08-27 15:56:35 +02:00
/* Test g_subprocess_communicate_utf8_async() can be cancelled correclty. */
static void
test_communicate_utf8_cancelled_async (gconstpointer test_data)
{
GSubprocessFlags flags = GPOINTER_TO_INT (test_data);
GError *error = NULL;
GPtrArray *args;
TestAsyncCommunicateData data = { flags, 0, };
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;
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
TestAsyncCommunicateData data = { flags, 0, };
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
g_assert (g_subprocess_get_if_signaled (subprocess));
g_assert (g_subprocess_get_term_sig (subprocess) == 9);
#endif
g_spawn_check_exit_status (g_subprocess_get_status (subprocess), &error);
g_assert (error != NULL);
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;
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_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;
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;
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
gchar *result;
tests/gsubprocess: Only compare basename of /tmp Otherwise, we break in Continuous where /tmp == /sysroot/tmp, and something in the execve() or the kernel will do realpath() for us.
2013-11-29 05:12:26 +01:00
const char *basename;
GSubprocess test: Adjust the cwd test to pass on Windows There's no /tmp directory on Windows. Use g_get_tmp_dir(), and adjust the test to work with that. The test *still* checks the basename of the new CWD, it just doesn't need to be "tmp" anymore.
2019-02-12 00:55:08 +01:00
gchar *tmp_lineend;
const gchar *tmp_lineend_basename;
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);
GSubprocess test: Adjust the cwd test to pass on Windows There's no /tmp directory on Windows. Use g_get_tmp_dir(), and adjust the test to work with that. The test *still* checks the basename of the new CWD, it just doesn't need to be "tmp" anymore.
2019-02-12 00:55:08 +01:00
g_subprocess_launcher_set_cwd (launcher, g_get_tmp_dir ());
tmp_lineend = g_strdup_printf ("%s%s", g_get_tmp_dir (), LINEEND);
tmp_lineend_basename = g_strrstr (tmp_lineend, G_DIR_SEPARATOR_S);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
proc = g_subprocess_launcher_spawnv (launcher, (const char * 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
stdout_stream = g_subprocess_get_stdout_pipe (proc);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +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);
Improve test coverage for GSubprocess
2013-11-28 18:59:11 +01:00
GSubprocess test: Adjust the cwd test to pass on Windows There's no /tmp directory on Windows. Use g_get_tmp_dir(), and adjust the test to work with that. The test *still* checks the basename of the new CWD, it just doesn't need to be "tmp" anymore.
2019-02-12 00:55:08 +01:00
basename = g_strrstr (result, G_DIR_SEPARATOR_S);
tests/gsubprocess: Only compare basename of /tmp Otherwise, we break in Continuous where /tmp == /sysroot/tmp, and something in the execve() or the kernel will do realpath() for us.
2013-11-29 05:12:26 +01:00
g_assert (basename != NULL);
GSubprocess test: Adjust the cwd test to pass on Windows There's no /tmp directory on Windows. Use g_get_tmp_dir(), and adjust the test to work with that. The test *still* checks the basename of the new CWD, it just doesn't need to be "tmp" anymore.
2019-02-12 00:55:08 +01:00
g_assert_cmpstr (basename, ==, tmp_lineend_basename);
g_free (tmp_lineend);
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
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
test_pass_fd (void)
{
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);
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE);
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: 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);
}
#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");
/* and set a diffferent one */
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);
g_assert (proc);
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);
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_bug_base ("https://bugzilla.gnome.org/");
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/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);
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
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);
g_test_add_func ("/gsubprocess/pass-fd", test_pass_fd);
#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