/* test.c generated by valac 0.56.18, the Vala compiler
 * generated from test.vala, do not modify */

/* rpl tests*/
/**/
/* © 2025 Reuben Thomas <rrt@sc3d.org>*/
/**/
/* This program is free software; you can redistribute it and/or modify*/
/* it under the terms of the GNU General Public License as published by*/
/* the Free Software Foundation; either version 3, or (at your option)*/
/* any later version.*/
/**/
/* This program is distributed in the hope that it will be useful,*/
/* but WITHOUT ANY WARRANTY; without even the implied warranty of*/
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the*/
/* GNU General Public License for more details.*/
/**/
/* You should have received a copy of the GNU General Public License*/
/* along with this program; if not, see <https://www.gnu.org/licenses/>.*/
/* To run only some tests, run the tests normally to ensure the binary is up*/
/* to date, then:*/
/* TEST_FILES_DIR=./test-files ./test -p "/PATH/TO/TEST"*/
/* ./test --help for more details*/

#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <glib/gstdio.h>
#include <gio/gio.h>
#include <glib-object.h>
#include <sys/stat.h>
#include <time.h>
#include <stat-time.h>
#include <sys/types.h>

#define OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES ((2 * 1024) * 1024)
#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif
#if !defined(VALA_EXTERN)
#if defined(_MSC_VER)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif

#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define TYPE_TEST_ERROR (test_error_get_type ())
#define _g_array_unref0(var) ((var == NULL) ? NULL : (var = (g_array_unref (var), NULL)))

#define TYPE_OUTPUT (output_get_type ())
typedef struct _Output Output;

#define TYPE_GEE_TEST_CASE (gee_test_case_get_type ())
#define GEE_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GEE_TEST_CASE, GeeTestCase))
#define GEE_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GEE_TEST_CASE, GeeTestCaseClass))
#define IS_GEE_TEST_CASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GEE_TEST_CASE))
#define IS_GEE_TEST_CASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_GEE_TEST_CASE))
#define GEE_TEST_CASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_GEE_TEST_CASE, GeeTestCaseClass))

typedef struct _GeeTestCase GeeTestCase;
typedef struct _GeeTestCaseClass GeeTestCaseClass;
typedef struct _GeeTestCasePrivate GeeTestCasePrivate;

#define TYPE_TEST_RPL (test_rpl_get_type ())
#define TEST_RPL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST_RPL, TestRpl))
#define TEST_RPL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST_RPL, TestRplClass))
#define IS_TEST_RPL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST_RPL))
#define IS_TEST_RPL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST_RPL))
#define TEST_RPL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST_RPL, TestRplClass))

typedef struct _TestRpl TestRpl;
typedef struct _TestRplClass TestRplClass;
typedef struct _TestRplPrivate TestRplPrivate;
enum  {
	TEST_RPL_0_PROPERTY,
	TEST_RPL_NUM_PROPERTIES
};
static GParamSpec* test_rpl_properties[TEST_RPL_NUM_PROPERTIES];

#define TYPE_TEST_RPL_OUTPUT_FILE (test_rpl_output_file_get_type ())
#define TEST_RPL_OUTPUT_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST_RPL_OUTPUT_FILE, TestRplOutputFile))
#define TEST_RPL_OUTPUT_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST_RPL_OUTPUT_FILE, TestRplOutputFileClass))
#define IS_TEST_RPL_OUTPUT_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST_RPL_OUTPUT_FILE))
#define IS_TEST_RPL_OUTPUT_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST_RPL_OUTPUT_FILE))
#define TEST_RPL_OUTPUT_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST_RPL_OUTPUT_FILE, TestRplOutputFileClass))

typedef struct _TestRplOutputFile TestRplOutputFile;
typedef struct _TestRplOutputFileClass TestRplOutputFileClass;
typedef struct _TestRplOutputFilePrivate TestRplOutputFilePrivate;
enum  {
	TEST_RPL_OUTPUT_FILE_0_PROPERTY,
	TEST_RPL_OUTPUT_FILE_NUM_PROPERTIES
};
static GParamSpec* test_rpl_output_file_properties[TEST_RPL_OUTPUT_FILE_NUM_PROPERTIES];

#define TYPE_TEST_RPL_FILE (test_rpl_file_get_type ())
#define TEST_RPL_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST_RPL_FILE, TestRplFile))
#define TEST_RPL_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST_RPL_FILE, TestRplFileClass))
#define IS_TEST_RPL_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST_RPL_FILE))
#define IS_TEST_RPL_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST_RPL_FILE))
#define TEST_RPL_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST_RPL_FILE, TestRplFileClass))

typedef struct _TestRplFile TestRplFile;
typedef struct _TestRplFileClass TestRplFileClass;
typedef struct _TestRplFilePrivate TestRplFilePrivate;
enum  {
	TEST_RPL_FILE_0_PROPERTY,
	TEST_RPL_FILE_NUM_PROPERTIES
};
static GParamSpec* test_rpl_file_properties[TEST_RPL_FILE_NUM_PROPERTIES];

#define TYPE_ENCODING_TESTS (encoding_tests_get_type ())
#define ENCODING_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ENCODING_TESTS, EncodingTests))
#define ENCODING_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ENCODING_TESTS, EncodingTestsClass))
#define IS_ENCODING_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ENCODING_TESTS))
#define IS_ENCODING_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ENCODING_TESTS))
#define ENCODING_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ENCODING_TESTS, EncodingTestsClass))

typedef struct _EncodingTests EncodingTests;
typedef struct _EncodingTestsClass EncodingTestsClass;
typedef struct _EncodingTestsPrivate EncodingTestsPrivate;
enum  {
	ENCODING_TESTS_0_PROPERTY,
	ENCODING_TESTS_NUM_PROPERTIES
};
static GParamSpec* encoding_tests_properties[ENCODING_TESTS_NUM_PROPERTIES];
typedef void (*GeeTestCaseTestMethod) (gpointer user_data);

#define TYPE_NO_FILE_TESTS (no_file_tests_get_type ())
#define NO_FILE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NO_FILE_TESTS, NoFileTests))
#define NO_FILE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NO_FILE_TESTS, NoFileTestsClass))
#define IS_NO_FILE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NO_FILE_TESTS))
#define IS_NO_FILE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NO_FILE_TESTS))
#define NO_FILE_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NO_FILE_TESTS, NoFileTestsClass))

typedef struct _NoFileTests NoFileTests;
typedef struct _NoFileTestsClass NoFileTestsClass;
typedef struct _NoFileTestsPrivate NoFileTestsPrivate;
enum  {
	NO_FILE_TESTS_0_PROPERTY,
	NO_FILE_TESTS_NUM_PROPERTIES
};
static GParamSpec* no_file_tests_properties[NO_FILE_TESTS_NUM_PROPERTIES];

#define TYPE_OUTPUT_FILE_TESTS (output_file_tests_get_type ())
#define OUTPUT_FILE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_OUTPUT_FILE_TESTS, OutputFileTests))
#define OUTPUT_FILE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_OUTPUT_FILE_TESTS, OutputFileTestsClass))
#define IS_OUTPUT_FILE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_OUTPUT_FILE_TESTS))
#define IS_OUTPUT_FILE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_OUTPUT_FILE_TESTS))
#define OUTPUT_FILE_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_OUTPUT_FILE_TESTS, OutputFileTestsClass))

typedef struct _OutputFileTests OutputFileTests;
typedef struct _OutputFileTestsClass OutputFileTestsClass;
typedef struct _OutputFileTestsPrivate OutputFileTestsPrivate;
enum  {
	OUTPUT_FILE_TESTS_0_PROPERTY,
	OUTPUT_FILE_TESTS_NUM_PROPERTIES
};
static GParamSpec* output_file_tests_properties[OUTPUT_FILE_TESTS_NUM_PROPERTIES];
#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))

#define TYPE_LOREM_TESTS (lorem_tests_get_type ())
#define LOREM_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LOREM_TESTS, LoremTests))
#define LOREM_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LOREM_TESTS, LoremTestsClass))
#define IS_LOREM_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LOREM_TESTS))
#define IS_LOREM_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LOREM_TESTS))
#define LOREM_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LOREM_TESTS, LoremTestsClass))

typedef struct _LoremTests LoremTests;
typedef struct _LoremTestsClass LoremTestsClass;
typedef struct _LoremTestsPrivate LoremTestsPrivate;
enum  {
	LOREM_TESTS_0_PROPERTY,
	LOREM_TESTS_NUM_PROPERTIES
};
static GParamSpec* lorem_tests_properties[LOREM_TESTS_NUM_PROPERTIES];

#define TYPE_LOREM_UTF8_TESTS (lorem_utf8_tests_get_type ())
#define LOREM_UTF8_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LOREM_UTF8_TESTS, LoremUtf8Tests))
#define LOREM_UTF8_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LOREM_UTF8_TESTS, LoremUtf8TestsClass))
#define IS_LOREM_UTF8_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LOREM_UTF8_TESTS))
#define IS_LOREM_UTF8_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LOREM_UTF8_TESTS))
#define LOREM_UTF8_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LOREM_UTF8_TESTS, LoremUtf8TestsClass))

typedef struct _LoremUtf8Tests LoremUtf8Tests;
typedef struct _LoremUtf8TestsClass LoremUtf8TestsClass;
typedef struct _LoremUtf8TestsPrivate LoremUtf8TestsPrivate;
enum  {
	LOREM_UTF8_TESTS_0_PROPERTY,
	LOREM_UTF8_TESTS_NUM_PROPERTIES
};
static GParamSpec* lorem_utf8_tests_properties[LOREM_UTF8_TESTS_NUM_PROPERTIES];

#define TYPE_UTF8_SIG_TESTS (utf8_sig_tests_get_type ())
#define UTF8_SIG_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_UTF8_SIG_TESTS, Utf8SigTests))
#define UTF8_SIG_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_UTF8_SIG_TESTS, Utf8SigTestsClass))
#define IS_UTF8_SIG_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_UTF8_SIG_TESTS))
#define IS_UTF8_SIG_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_UTF8_SIG_TESTS))
#define UTF8_SIG_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_UTF8_SIG_TESTS, Utf8SigTestsClass))

typedef struct _Utf8SigTests Utf8SigTests;
typedef struct _Utf8SigTestsClass Utf8SigTestsClass;
typedef struct _Utf8SigTestsPrivate Utf8SigTestsPrivate;
enum  {
	UTF8_SIG_TESTS_0_PROPERTY,
	UTF8_SIG_TESTS_NUM_PROPERTIES
};
static GParamSpec* utf8_sig_tests_properties[UTF8_SIG_TESTS_NUM_PROPERTIES];

#define TYPE_MIXED_CASE_TESTS (mixed_case_tests_get_type ())
#define MIXED_CASE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MIXED_CASE_TESTS, MixedCaseTests))
#define MIXED_CASE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MIXED_CASE_TESTS, MixedCaseTestsClass))
#define IS_MIXED_CASE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MIXED_CASE_TESTS))
#define IS_MIXED_CASE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MIXED_CASE_TESTS))
#define MIXED_CASE_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MIXED_CASE_TESTS, MixedCaseTestsClass))

typedef struct _MixedCaseTests MixedCaseTests;
typedef struct _MixedCaseTestsClass MixedCaseTestsClass;
typedef struct _MixedCaseTestsPrivate MixedCaseTestsPrivate;
enum  {
	MIXED_CASE_TESTS_0_PROPERTY,
	MIXED_CASE_TESTS_NUM_PROPERTIES
};
static GParamSpec* mixed_case_tests_properties[MIXED_CASE_TESTS_NUM_PROPERTIES];

#define TYPE_BACKREFERENCE_TESTS (backreference_tests_get_type ())
#define BACKREFERENCE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BACKREFERENCE_TESTS, BackreferenceTests))
#define BACKREFERENCE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BACKREFERENCE_TESTS, BackreferenceTestsClass))
#define IS_BACKREFERENCE_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BACKREFERENCE_TESTS))
#define IS_BACKREFERENCE_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BACKREFERENCE_TESTS))
#define BACKREFERENCE_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BACKREFERENCE_TESTS, BackreferenceTestsClass))

typedef struct _BackreferenceTests BackreferenceTests;
typedef struct _BackreferenceTestsClass BackreferenceTestsClass;
typedef struct _BackreferenceTestsPrivate BackreferenceTestsPrivate;
enum  {
	BACKREFERENCE_TESTS_0_PROPERTY,
	BACKREFERENCE_TESTS_NUM_PROPERTIES
};
static GParamSpec* backreference_tests_properties[BACKREFERENCE_TESTS_NUM_PROPERTIES];

#define TYPE_EMPTY_MATCHES_TESTS (empty_matches_tests_get_type ())
#define EMPTY_MATCHES_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_EMPTY_MATCHES_TESTS, EmptyMatchesTests))
#define EMPTY_MATCHES_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_EMPTY_MATCHES_TESTS, EmptyMatchesTestsClass))
#define IS_EMPTY_MATCHES_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_EMPTY_MATCHES_TESTS))
#define IS_EMPTY_MATCHES_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_EMPTY_MATCHES_TESTS))
#define EMPTY_MATCHES_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_EMPTY_MATCHES_TESTS, EmptyMatchesTestsClass))

typedef struct _EmptyMatchesTests EmptyMatchesTests;
typedef struct _EmptyMatchesTestsClass EmptyMatchesTestsClass;
typedef struct _EmptyMatchesTestsPrivate EmptyMatchesTestsPrivate;
enum  {
	EMPTY_MATCHES_TESTS_0_PROPERTY,
	EMPTY_MATCHES_TESTS_NUM_PROPERTIES
};
static GParamSpec* empty_matches_tests_properties[EMPTY_MATCHES_TESTS_NUM_PROPERTIES];

#define TYPE_DIR_TESTS (dir_tests_get_type ())
#define DIR_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DIR_TESTS, DirTests))
#define DIR_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DIR_TESTS, DirTestsClass))
#define IS_DIR_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DIR_TESTS))
#define IS_DIR_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DIR_TESTS))
#define DIR_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DIR_TESTS, DirTestsClass))

typedef struct _DirTests DirTests;
typedef struct _DirTestsClass DirTestsClass;
typedef struct _DirTestsPrivate DirTestsPrivate;
enum  {
	DIR_TESTS_0_PROPERTY,
	DIR_TESTS_NUM_PROPERTIES
};
static GParamSpec* dir_tests_properties[DIR_TESTS_NUM_PROPERTIES];

#define TYPE_GLOB_TESTS (glob_tests_get_type ())
#define GLOB_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GLOB_TESTS, GlobTests))
#define GLOB_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GLOB_TESTS, GlobTestsClass))
#define IS_GLOB_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GLOB_TESTS))
#define IS_GLOB_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_GLOB_TESTS))
#define GLOB_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_GLOB_TESTS, GlobTestsClass))

typedef struct _GlobTests GlobTests;
typedef struct _GlobTestsClass GlobTestsClass;
typedef struct _GlobTestsPrivate GlobTestsPrivate;
enum  {
	GLOB_TESTS_0_PROPERTY,
	GLOB_TESTS_NUM_PROPERTIES
};
static GParamSpec* glob_tests_properties[GLOB_TESTS_NUM_PROPERTIES];

typedef enum  {
	TEST_ERROR_TESTERROR
} TestError;
#define TEST_ERROR test_error_quark ()

struct _Output {
	gchar* std_out;
	gchar* std_err;
};

struct _GeeTestCase {
	GObject parent_instance;
	GeeTestCasePrivate * priv;
};

struct _GeeTestCaseClass {
	GObjectClass parent_class;
	void (*set_up) (GeeTestCase* self);
	void (*tear_down) (GeeTestCase* self);
};

struct _TestRpl {
	GeeTestCase parent_instance;
	TestRplPrivate * priv;
	gchar* rpl;
	gchar* test_files_dir;
	gchar* test_result_dir;
};

struct _TestRplClass {
	GeeTestCaseClass parent_class;
};

struct _TestRplOutputFile {
	TestRpl parent_instance;
	TestRplOutputFilePrivate * priv;
	gchar* test_result_root;
};

struct _TestRplOutputFileClass {
	TestRplClass parent_class;
};

struct _TestRplFile {
	TestRplOutputFile parent_instance;
	TestRplFilePrivate * priv;
	gchar* test_data_root;
	gchar* test_data;
};

struct _TestRplFileClass {
	TestRplOutputFileClass parent_class;
};

struct _EncodingTests {
	TestRplFile parent_instance;
	EncodingTestsPrivate * priv;
};

struct _EncodingTestsClass {
	TestRplFileClass parent_class;
};

struct _NoFileTests {
	TestRpl parent_instance;
	NoFileTestsPrivate * priv;
};

struct _NoFileTestsClass {
	TestRplClass parent_class;
};

struct _OutputFileTests {
	TestRplOutputFile parent_instance;
	OutputFileTestsPrivate * priv;
};

struct _OutputFileTestsClass {
	TestRplOutputFileClass parent_class;
};

struct _LoremTests {
	TestRplFile parent_instance;
	LoremTestsPrivate * priv;
};

struct _LoremTestsClass {
	TestRplFileClass parent_class;
};

struct _LoremUtf8Tests {
	TestRplFile parent_instance;
	LoremUtf8TestsPrivate * priv;
};

struct _LoremUtf8TestsClass {
	TestRplFileClass parent_class;
};

struct _Utf8SigTests {
	TestRplFile parent_instance;
	Utf8SigTestsPrivate * priv;
};

struct _Utf8SigTestsClass {
	TestRplFileClass parent_class;
};

struct _MixedCaseTests {
	TestRplFile parent_instance;
	MixedCaseTestsPrivate * priv;
};

struct _MixedCaseTestsClass {
	TestRplFileClass parent_class;
};

struct _BackreferenceTests {
	TestRplFile parent_instance;
	BackreferenceTestsPrivate * priv;
};

struct _BackreferenceTestsClass {
	TestRplFileClass parent_class;
};

struct _EmptyMatchesTests {
	TestRplFile parent_instance;
	EmptyMatchesTestsPrivate * priv;
};

struct _EmptyMatchesTestsClass {
	TestRplFileClass parent_class;
};

struct _DirTests {
	TestRplFile parent_instance;
	DirTestsPrivate * priv;
};

struct _DirTestsClass {
	TestRplFileClass parent_class;
};

struct _GlobTests {
	TestRplFile parent_instance;
	GlobTestsPrivate * priv;
};

struct _GlobTestsClass {
	TestRplFileClass parent_class;
};

static gpointer test_rpl_parent_class = NULL;
static gpointer test_rpl_output_file_parent_class = NULL;
static gpointer test_rpl_file_parent_class = NULL;
static gpointer encoding_tests_parent_class = NULL;
static gpointer no_file_tests_parent_class = NULL;
static gpointer output_file_tests_parent_class = NULL;
static gpointer lorem_tests_parent_class = NULL;
static gpointer lorem_utf8_tests_parent_class = NULL;
static gpointer utf8_sig_tests_parent_class = NULL;
static gpointer mixed_case_tests_parent_class = NULL;
static gpointer backreference_tests_parent_class = NULL;
static gpointer empty_matches_tests_parent_class = NULL;
static gpointer dir_tests_parent_class = NULL;
static gpointer glob_tests_parent_class = NULL;

VALA_EXTERN gchar* slurp_file (const gchar* filename,
                   gsize* length,
                   GError** error);
VALA_EXTERN void buffer_to_file (const gchar* path,
                     guint8* buf,
                     gint buf_length1);
VALA_EXTERN GQuark test_error_quark (void);
VALA_EXTERN GType test_error_get_type (void) G_GNUC_CONST ;
VALA_EXTERN GSubprocess* start_prog (const gchar* prog,
                         gchar** args,
                         gint args_length1,
                         GError** error);
static gchar** _vala_array_dup1 (gchar** self,
                          gssize length);
static void _g_free0_ (gpointer var);
static void _vala_gchar_free_function_content_of (gpointer data);
VALA_EXTERN GType output_get_type (void) G_GNUC_CONST ;
VALA_EXTERN Output* output_dup (const Output* self);
VALA_EXTERN void output_free (Output* self);
VALA_EXTERN void output_copy (const Output* self,
                  Output* dest);
VALA_EXTERN void output_destroy (Output* self);
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (Output, output_destroy)
VALA_EXTERN GSubprocess* check_prog (const gchar* prog,
                         gchar** args,
                         gint args_length1,
                         GError** error);
VALA_EXTERN gboolean try_sudo (gchar** cmd,
                   gint cmd_length1);
static gchar** _vala_array_dup2 (gchar** self,
                          gssize length);
VALA_EXTERN void run_prog (const gchar* prog,
               gchar** args,
               gint args_length1,
               gint expected_rc,
               Output* result);
VALA_EXTERN gchar* slurp (GInputStream* stream,
              GError** error);
VALA_EXTERN GType gee_test_case_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GeeTestCase, g_object_unref)
VALA_EXTERN GType test_rpl_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (TestRpl, g_object_unref)
VALA_EXTERN void gee_test_case_set_up (GeeTestCase* self);
VALA_EXTERN void gee_test_case_tear_down (GeeTestCase* self);
VALA_EXTERN TestRpl* test_rpl_new (const gchar* bin_dir,
                       const gchar* test_files_dir);
VALA_EXTERN TestRpl* test_rpl_construct (GType object_type,
                             const gchar* bin_dir,
                             const gchar* test_files_dir);
VALA_EXTERN GeeTestCase* gee_test_case_construct (GType object_type,
                                      const gchar* name);
VALA_EXTERN void test_rpl_run (TestRpl* self,
                   gchar** args,
                   gint args_length1,
                   gint expected_rc,
                   Output* result);
static void test_rpl_real_set_up (GeeTestCase* base);
static void test_rpl_real_tear_down (GeeTestCase* base);
static void test_rpl_finalize (GObject * obj);
static GType test_rpl_get_type_once (void);
VALA_EXTERN GType test_rpl_output_file_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (TestRplOutputFile, g_object_unref)
VALA_EXTERN TestRplOutputFile* test_rpl_output_file_new (const gchar* bin_dir,
                                             const gchar* test_files_dir);
VALA_EXTERN TestRplOutputFile* test_rpl_output_file_construct (GType object_type,
                                                   const gchar* bin_dir,
                                                   const gchar* test_files_dir);
static void test_rpl_output_file_real_set_up (GeeTestCase* base);
VALA_EXTERN gboolean test_rpl_output_file_result_matches (TestRplOutputFile* self,
                                              const gchar* expected_root);
VALA_EXTERN gboolean test_rpl_output_file_result_matches_string (TestRplOutputFile* self,
                                                     const gchar* expected,
                                                     gsize length);
static void test_rpl_output_file_finalize (GObject * obj);
static GType test_rpl_output_file_get_type_once (void);
VALA_EXTERN GType test_rpl_file_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (TestRplFile, g_object_unref)
static TestRplFile* test_rpl_file_construct (GType object_type,
                                      const gchar* bin_dir,
                                      const gchar* test_files_dir,
                                      const gchar* test_data);
static void test_rpl_file_real_set_up (GeeTestCase* base);
static void test_rpl_file_finalize (GObject * obj);
static GType test_rpl_file_get_type_once (void);
VALA_EXTERN GType encoding_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (EncodingTests, g_object_unref)
VALA_EXTERN EncodingTests* encoding_tests_new (const gchar* bin_dir,
                                   const gchar* test_files_dir);
VALA_EXTERN EncodingTests* encoding_tests_construct (GType object_type,
                                         const gchar* bin_dir,
                                         const gchar* test_files_dir);
VALA_EXTERN void gee_test_case_add_test (GeeTestCase* self,
                             const gchar* name,
                             GeeTestCaseTestMethod test,
                             gpointer test_target,
                             GDestroyNotify test_target_destroy_notify);
static void encoding_tests_test_bad_encoding (EncodingTests* self);
static void _encoding_tests_test_bad_encoding_gee_test_case_test_method (gpointer self);
static void encoding_tests_test_explicit_encoding (EncodingTests* self);
static void _encoding_tests_test_explicit_encoding_gee_test_case_test_method (gpointer self);
static GType encoding_tests_get_type_once (void);
VALA_EXTERN GType no_file_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (NoFileTests, g_object_unref)
VALA_EXTERN NoFileTests* no_file_tests_new (const gchar* bin_dir,
                                const gchar* test_files_dir);
VALA_EXTERN NoFileTests* no_file_tests_construct (GType object_type,
                                      const gchar* bin_dir,
                                      const gchar* test_files_dir);
static void no_file_tests_test_no_arguments (NoFileTests* self);
static void _no_file_tests_test_no_arguments_gee_test_case_test_method (gpointer self);
static void no_file_tests_test_help (NoFileTests* self);
static void _no_file_tests_test_help_gee_test_case_test_method (gpointer self);
static void no_file_tests_test_full_help (NoFileTests* self);
static void _no_file_tests_test_full_help_gee_test_case_test_method (gpointer self);
static void no_file_tests_test_version (NoFileTests* self);
static void _no_file_tests_test_version_gee_test_case_test_method (gpointer self);
static void no_file_tests_test_nonexistent_option (NoFileTests* self);
static void _no_file_tests_test_nonexistent_option_gee_test_case_test_method (gpointer self);
static void no_file_tests_test_nonexistent_input (NoFileTests* self);
static void _no_file_tests_test_nonexistent_input_gee_test_case_test_method (gpointer self);
static void no_file_tests_test_nonexistent_patterns_file (NoFileTests* self);
static void _no_file_tests_test_nonexistent_patterns_file_gee_test_case_test_method (gpointer self);
static void no_file_tests_test_input_is_directory (NoFileTests* self);
static void _no_file_tests_test_input_is_directory_gee_test_case_test_method (gpointer self);
static GType no_file_tests_get_type_once (void);
VALA_EXTERN GType output_file_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (OutputFileTests, g_object_unref)
VALA_EXTERN OutputFileTests* output_file_tests_new (const gchar* bin_dir,
                                        const gchar* test_files_dir);
VALA_EXTERN OutputFileTests* output_file_tests_construct (GType object_type,
                                              const gchar* bin_dir,
                                              const gchar* test_files_dir);
static void output_file_tests_test_a_star_b_empty_input (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_empty_input_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_a_star_b_input_x (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_input_x_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_a_star_b_input_aaa (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_input_aaa_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_a_star_b_input_aaax (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_input_aaax_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_a_star_b_input_xaaa (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_input_xaaa_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_a_star_b_input_xaaax (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_input_xaaax_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_a_star_b_input_aaaxaaa (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_input_aaaxaaa_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_a_star_b_input_aaaxxaaa (OutputFileTests* self);
static void _output_file_tests_test_a_star_b_input_aaaxxaaa_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_multi_buffer_matches_partial_match_at_end (OutputFileTests* self);
static void _output_file_tests_test_multi_buffer_matches_partial_match_at_end_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_multi_buffer_matches_partial_empty_match_at_end (OutputFileTests* self);
static void _output_file_tests_test_multi_buffer_matches_partial_empty_match_at_end_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_multi_buffer_matches_complete_match_at_end (OutputFileTests* self);
static void _output_file_tests_test_multi_buffer_matches_complete_match_at_end_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_multi_buffer_matches_complete_empty_match_at_end (OutputFileTests* self);
static void _output_file_tests_test_multi_buffer_matches_complete_empty_match_at_end_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_multi_buffer_lookbehind (OutputFileTests* self);
static void _output_file_tests_test_multi_buffer_lookbehind_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_lookbehind_word_boundary (OutputFileTests* self);
static void _output_file_tests_test_lookbehind_word_boundary_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_lookbehind_with_NULs (OutputFileTests* self);
static void _output_file_tests_test_lookbehind_with_NULs_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_buffer_crossing_character (OutputFileTests* self);
static void _output_file_tests_test_buffer_crossing_character_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_empty_match_at_buffer_end (OutputFileTests* self);
static void _output_file_tests_test_empty_match_at_buffer_end_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_recursive_no_file_arguments (OutputFileTests* self);
static void _output_file_tests_test_recursive_no_file_arguments_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_bad_regex (OutputFileTests* self);
static void _output_file_tests_test_bad_regex_gee_test_case_test_method (gpointer self);
static void output_file_tests_test_non_file_input (OutputFileTests* self);
static void _output_file_tests_test_non_file_input_gee_test_case_test_method (gpointer self);
static GType output_file_tests_get_type_once (void);
VALA_EXTERN GType lorem_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (LoremTests, g_object_unref)
VALA_EXTERN LoremTests* lorem_tests_new (const gchar* bin_dir,
                             const gchar* test_files_dir);
VALA_EXTERN LoremTests* lorem_tests_construct (GType object_type,
                                   const gchar* bin_dir,
                                   const gchar* test_files_dir);
static void lorem_tests_test_ignore_case_verbose (LoremTests* self);
static void _lorem_tests_test_ignore_case_verbose_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_match_case (LoremTests* self);
static void _lorem_tests_test_match_case_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_no_flags (LoremTests* self);
static void _lorem_tests_test_no_flags_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_use_regexp (LoremTests* self);
static void _lorem_tests_test_use_regexp_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_dry_run (LoremTests* self);
static void _lorem_tests_test_dry_run_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_quiet (LoremTests* self);
static void _lorem_tests_test_quiet_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_ignores_dash_E (LoremTests* self);
static void _lorem_tests_test_ignores_dash_E_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_bad_replacement (LoremTests* self);
static void _lorem_tests_test_bad_replacement_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_input_on_stdin (LoremTests* self);
static void _lorem_tests_test_input_on_stdin_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_recursive_used_with_file (LoremTests* self);
static void _lorem_tests_test_recursive_used_with_file_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_bad_output_encoding (LoremTests* self);
static void _lorem_tests_test_bad_output_encoding_gee_test_case_test_method (gpointer self);
static void lorem_tests_test_bad_ascii_output (LoremTests* self);
static void _lorem_tests_test_bad_ascii_output_gee_test_case_test_method (gpointer self);
static GType lorem_tests_get_type_once (void);
VALA_EXTERN GType lorem_utf8_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (LoremUtf8Tests, g_object_unref)
VALA_EXTERN LoremUtf8Tests* lorem_utf8_tests_new (const gchar* bin_dir,
                                      const gchar* test_files_dir);
VALA_EXTERN LoremUtf8Tests* lorem_utf8_tests_construct (GType object_type,
                                            const gchar* bin_dir,
                                            const gchar* test_files_dir);
static void lorem_utf8_tests_test_utf_8 (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_utf_8_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_whole_words (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_whole_words_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_patterns_in_files (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_patterns_in_files_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_fixed_strings (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_fixed_strings_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_match_case_non_ascii (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_match_case_non_ascii_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_keep_times (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_keep_times_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_without_keep_times (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_without_keep_times_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_prompt_yes (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_prompt_yes_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_prompt_no (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_prompt_no_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_prompt_empty (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_prompt_empty_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_force (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_force_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_force_fail (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_force_fail_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_set_attributes_fail (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_set_attributes_fail_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_unreadable_input (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_unreadable_input_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_test_unwritable_input (LoremUtf8Tests* self);
static void _lorem_utf8_tests_test_unwritable_input_gee_test_case_test_method (gpointer self);
static void lorem_utf8_tests_prompt_test (LoremUtf8Tests* self,
                                   const gchar* input,
                                   const gchar* expected);
static GType lorem_utf8_tests_get_type_once (void);
VALA_EXTERN GType utf8_sig_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Utf8SigTests, g_object_unref)
VALA_EXTERN Utf8SigTests* utf8_sig_tests_new (const gchar* bin_dir,
                                  const gchar* test_files_dir);
VALA_EXTERN Utf8SigTests* utf8_sig_tests_construct (GType object_type,
                                        const gchar* bin_dir,
                                        const gchar* test_files_dir);
static void utf8_sig_tests_test_utf_8_sig (Utf8SigTests* self);
static void _utf8_sig_tests_test_utf_8_sig_gee_test_case_test_method (gpointer self);
static GType utf8_sig_tests_get_type_once (void);
VALA_EXTERN GType mixed_case_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MixedCaseTests, g_object_unref)
VALA_EXTERN MixedCaseTests* mixed_case_tests_new (const gchar* bin_dir,
                                      const gchar* test_files_dir);
VALA_EXTERN MixedCaseTests* mixed_case_tests_construct (GType object_type,
                                            const gchar* bin_dir,
                                            const gchar* test_files_dir);
static void mixed_case_tests_test_mixed_replace_lower (MixedCaseTests* self);
static void _mixed_case_tests_test_mixed_replace_lower_gee_test_case_test_method (gpointer self);
static GType mixed_case_tests_get_type_once (void);
VALA_EXTERN GType backreference_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (BackreferenceTests, g_object_unref)
VALA_EXTERN BackreferenceTests* backreference_tests_new (const gchar* bin_dir,
                                             const gchar* test_files_dir);
VALA_EXTERN BackreferenceTests* backreference_tests_construct (GType object_type,
                                                   const gchar* bin_dir,
                                                   const gchar* test_files_dir);
static void backreference_tests_test_backreference_numbering (BackreferenceTests* self);
static void _backreference_tests_test_backreference_numbering_gee_test_case_test_method (gpointer self);
static GType backreference_tests_get_type_once (void);
VALA_EXTERN GType empty_matches_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (EmptyMatchesTests, g_object_unref)
VALA_EXTERN EmptyMatchesTests* empty_matches_tests_new (const gchar* bin_dir,
                                            const gchar* test_files_dir);
VALA_EXTERN EmptyMatchesTests* empty_matches_tests_construct (GType object_type,
                                                  const gchar* bin_dir,
                                                  const gchar* test_files_dir);
static void empty_matches_tests_test_empty_matches (EmptyMatchesTests* self);
static void _empty_matches_tests_test_empty_matches_gee_test_case_test_method (gpointer self);
static GType empty_matches_tests_get_type_once (void);
VALA_EXTERN GType dir_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (DirTests, g_object_unref)
VALA_EXTERN DirTests* dir_tests_new (const gchar* bin_dir,
                         const gchar* test_files_dir);
VALA_EXTERN DirTests* dir_tests_construct (GType object_type,
                               const gchar* bin_dir,
                               const gchar* test_files_dir);
static void dir_tests_test_recursive (DirTests* self);
static void _dir_tests_test_recursive_gee_test_case_test_method (gpointer self);
static void dir_tests_test_backup (DirTests* self);
static void _dir_tests_test_backup_gee_test_case_test_method (gpointer self);
static GType dir_tests_get_type_once (void);
VALA_EXTERN GType glob_tests_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GlobTests, g_object_unref)
VALA_EXTERN GlobTests* glob_tests_new (const gchar* bin_dir,
                           const gchar* test_files_dir);
VALA_EXTERN GlobTests* glob_tests_construct (GType object_type,
                                 const gchar* bin_dir,
                                 const gchar* test_files_dir);
static void glob_tests_test_globs (GlobTests* self);
static void _glob_tests_test_globs_gee_test_case_test_method (gpointer self);
static void glob_tests_test_globs_no_match (GlobTests* self);
static void _glob_tests_test_globs_no_match_gee_test_case_test_method (gpointer self);
static GType glob_tests_get_type_once (void);
static gint _vala_main (gchar** args,
                 gint args_length1);
VALA_EXTERN GTestSuite* gee_test_case_get_suite (GeeTestCase* self);
static void _vala_array_destroy (gpointer array,
                          gssize array_length,
                          GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array,
                       gssize array_length,
                       GDestroyNotify destroy_func);

gchar*
slurp_file (const gchar* filename,
            gsize* length,
            GError** error)
{
	gsize _vala_length = 0UL;
	gchar* contents = NULL;
	gsize contents_length = 0UL;
	gchar* _tmp0_ = NULL;
	gsize _tmp1_ = 0UL;
	GError* _inner_error0_ = NULL;
	gchar* result;
#line 27 "test.vala"
	g_return_val_if_fail (filename != NULL, NULL);
#line 30 "test.vala"
	g_file_get_contents (filename, &_tmp0_, &_tmp1_, &_inner_error0_);
#line 30 "test.vala"
	_g_free0 (contents);
#line 30 "test.vala"
	contents = _tmp0_;
#line 30 "test.vala"
	contents_length = _tmp1_;
#line 30 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 30 "test.vala"
		if (_inner_error0_->domain == G_FILE_ERROR) {
#line 30 "test.vala"
			g_propagate_error (error, _inner_error0_);
#line 30 "test.vala"
			_g_free0 (contents);
#line 30 "test.vala"
			return NULL;
#line 823 "test.c"
		} else {
#line 30 "test.vala"
			_g_free0 (contents);
#line 30 "test.vala"
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 30 "test.vala"
			g_clear_error (&_inner_error0_);
#line 30 "test.vala"
			return NULL;
#line 833 "test.c"
		}
	}
#line 31 "test.vala"
	_vala_length = contents_length;
#line 32 "test.vala"
	result = contents;
#line 32 "test.vala"
	if (length) {
#line 32 "test.vala"
		*length = _vala_length;
#line 844 "test.c"
	}
#line 32 "test.vala"
	return result;
#line 848 "test.c"
}

void
buffer_to_file (const gchar* path,
                guint8* buf,
                gint buf_length1)
{
	GError* _inner_error0_ = NULL;
#line 35 "test.vala"
	g_return_if_fail (path != NULL);
#line 859 "test.c"
	{
		GFile* file = NULL;
		GFile* _tmp0_;
		GFileOutputStream* os = NULL;
		GFile* _tmp1_;
		GFileOutputStream* _tmp2_;
		GFileOutputStream* _tmp3_;
		GFileOutputStream* _tmp4_;
#line 37 "test.vala"
		_tmp0_ = g_file_new_for_path (path);
#line 37 "test.vala"
		file = _tmp0_;
#line 38 "test.vala"
		_tmp1_ = file;
#line 38 "test.vala"
		_tmp2_ = g_file_create (_tmp1_, G_FILE_CREATE_NONE, NULL, &_inner_error0_);
#line 38 "test.vala"
		os = _tmp2_;
#line 38 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 38 "test.vala"
			_g_object_unref0 (file);
#line 882 "test.c"
			goto __catch0_g_error;
		}
#line 39 "test.vala"
		_tmp3_ = os;
#line 39 "test.vala"
		g_output_stream_write ((GOutputStream*) _tmp3_, buf, (gsize) buf_length1, NULL, &_inner_error0_);
#line 39 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 39 "test.vala"
			_g_object_unref0 (os);
#line 39 "test.vala"
			_g_object_unref0 (file);
#line 895 "test.c"
			goto __catch0_g_error;
		}
#line 40 "test.vala"
		_tmp4_ = os;
#line 40 "test.vala"
		g_output_stream_close ((GOutputStream*) _tmp4_, NULL, &_inner_error0_);
#line 40 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 40 "test.vala"
			_g_object_unref0 (os);
#line 40 "test.vala"
			_g_object_unref0 (file);
#line 908 "test.c"
			goto __catch0_g_error;
		}
#line 36 "test.vala"
		_g_object_unref0 (os);
#line 36 "test.vala"
		_g_object_unref0 (file);
#line 915 "test.c"
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		GError* _tmp5_;
#line 36 "test.vala"
		e = _inner_error0_;
#line 36 "test.vala"
		_inner_error0_ = NULL;
#line 42 "test.vala"
		g_print ("error writing to temporary file\n");
#line 43 "test.vala"
		_tmp5_ = e;
#line 43 "test.vala"
		g_assert_no_error (_tmp5_);
#line 36 "test.vala"
		_g_error_free0 (e);
#line 934 "test.c"
	}
	__finally0:
#line 36 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 36 "test.vala"
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 36 "test.vala"
		g_clear_error (&_inner_error0_);
#line 36 "test.vala"
		return;
#line 945 "test.c"
	}
}

GQuark
test_error_quark (void)
{
	return g_quark_from_static_string ("test-error-quark");
}

static GType
test_error_get_type_once (void)
{
	static const GEnumValue values[] = {{TEST_ERROR_TESTERROR, "TEST_ERROR_TESTERROR", "testerror"}, {0, NULL, NULL}};
	GType test_error_type_id;
	test_error_type_id = g_enum_register_static ("TestError", values);
	return test_error_type_id;
}

GType
test_error_get_type (void)
{
	static volatile gsize test_error_type_id__once = 0;
	if (g_once_init_enter (&test_error_type_id__once)) {
		GType test_error_type_id;
		test_error_type_id = test_error_get_type_once ();
		g_once_init_leave (&test_error_type_id__once, test_error_type_id);
	}
	return test_error_type_id__once;
}

static gchar**
_vala_array_dup1 (gchar** self,
                  gssize length)
{
#line 52 "test.vala"
	if (length >= 0) {
#line 982 "test.c"
		gchar** result;
		gssize i;
#line 52 "test.vala"
		result = g_new0 (gchar*, length + 1);
#line 52 "test.vala"
		for (i = 0; i < length; i++) {
#line 989 "test.c"
			gchar* _tmp0_;
#line 52 "test.vala"
			_tmp0_ = g_strdup (self[i]);
#line 52 "test.vala"
			result[i] = _tmp0_;
#line 995 "test.c"
		}
#line 52 "test.vala"
		return result;
#line 999 "test.c"
	}
#line 52 "test.vala"
	return NULL;
#line 1003 "test.c"
}

static void
_g_free0_ (gpointer var)
{
#line 52 "test.vala"
	var = (g_free (var), NULL);
#line 1011 "test.c"
}

static void
_vala_gchar_free_function_content_of (gpointer data)
{
	gchar* self;
#line 52 "test.vala"
	self = *((gchar**) data);
#line 52 "test.vala"
	_g_free0_ (self);
#line 1022 "test.c"
}

static gchar*
_vala_g_strjoinv (const gchar* separator,
                  gchar** str_array,
                  gint str_array_length1)
{
	gboolean _tmp0_ = FALSE;
	gchar* result;
#line 1251 "glib-2.0.vapi"
	if (separator == NULL) {
#line 1252 "glib-2.0.vapi"
		separator = "";
#line 1036 "test.c"
	}
#line 1254 "glib-2.0.vapi"
	if (str_array != NULL) {
#line 1040 "test.c"
		gboolean _tmp1_ = FALSE;
#line 1254 "glib-2.0.vapi"
		if (str_array_length1 > 0) {
#line 1254 "glib-2.0.vapi"
			_tmp1_ = TRUE;
#line 1046 "test.c"
		} else {
			gboolean _tmp2_ = FALSE;
#line 1254 "glib-2.0.vapi"
			if (str_array_length1 == -1) {
#line 1051 "test.c"
				const gchar* _tmp3_;
#line 1254 "glib-2.0.vapi"
				_tmp3_ = str_array[0];
#line 1254 "glib-2.0.vapi"
				_tmp2_ = _tmp3_ != NULL;
#line 1057 "test.c"
			} else {
#line 1254 "glib-2.0.vapi"
				_tmp2_ = FALSE;
#line 1061 "test.c"
			}
#line 1254 "glib-2.0.vapi"
			_tmp1_ = _tmp2_;
#line 1065 "test.c"
		}
#line 1254 "glib-2.0.vapi"
		_tmp0_ = _tmp1_;
#line 1069 "test.c"
	} else {
#line 1254 "glib-2.0.vapi"
		_tmp0_ = FALSE;
#line 1073 "test.c"
	}
#line 1254 "glib-2.0.vapi"
	if (_tmp0_) {
#line 1077 "test.c"
		gint i = 0;
		gsize len = 0UL;
		gint _tmp16_;
		gint _tmp17_;
		const gchar* res = NULL;
		void* _tmp18_;
		const gchar* _tmp19_ = NULL;
		const gchar* _tmp20_;
		void* ptr = NULL;
		const gchar* _tmp22_;
		void* _tmp23_;
		const gchar* _tmp33_;
#line 1256 "glib-2.0.vapi"
		len = (gsize) 1;
#line 1092 "test.c"
		{
			gboolean _tmp4_ = FALSE;
#line 1257 "glib-2.0.vapi"
			i = 0;
#line 1257 "glib-2.0.vapi"
			_tmp4_ = TRUE;
#line 1257 "glib-2.0.vapi"
			while (TRUE) {
#line 1101 "test.c"
				gboolean _tmp6_ = FALSE;
				gboolean _tmp7_ = FALSE;
				gint _tmp10_ = 0;
				const gchar* _tmp11_;
#line 1257 "glib-2.0.vapi"
				if (!_tmp4_) {
#line 1108 "test.c"
					gint _tmp5_;
#line 1257 "glib-2.0.vapi"
					_tmp5_ = i;
#line 1257 "glib-2.0.vapi"
					i = _tmp5_ + 1;
#line 1114 "test.c"
				}
#line 1257 "glib-2.0.vapi"
				_tmp4_ = FALSE;
#line 1257 "glib-2.0.vapi"
				if (str_array_length1 != -1) {
#line 1257 "glib-2.0.vapi"
					_tmp7_ = i < str_array_length1;
#line 1122 "test.c"
				} else {
#line 1257 "glib-2.0.vapi"
					_tmp7_ = FALSE;
#line 1126 "test.c"
				}
#line 1257 "glib-2.0.vapi"
				if (_tmp7_) {
#line 1257 "glib-2.0.vapi"
					_tmp6_ = TRUE;
#line 1132 "test.c"
				} else {
					gboolean _tmp8_ = FALSE;
#line 1257 "glib-2.0.vapi"
					if (str_array_length1 == -1) {
#line 1137 "test.c"
						const gchar* _tmp9_;
#line 1257 "glib-2.0.vapi"
						_tmp9_ = str_array[i];
#line 1257 "glib-2.0.vapi"
						_tmp8_ = _tmp9_ != NULL;
#line 1143 "test.c"
					} else {
#line 1257 "glib-2.0.vapi"
						_tmp8_ = FALSE;
#line 1147 "test.c"
					}
#line 1257 "glib-2.0.vapi"
					_tmp6_ = _tmp8_;
#line 1151 "test.c"
				}
#line 1257 "glib-2.0.vapi"
				if (!_tmp6_) {
#line 1257 "glib-2.0.vapi"
					break;
#line 1157 "test.c"
				}
#line 1258 "glib-2.0.vapi"
				_tmp11_ = str_array[i];
#line 1258 "glib-2.0.vapi"
				if (_tmp11_ != NULL) {
#line 1163 "test.c"
					const gchar* _tmp12_;
					gint _tmp13_;
					gint _tmp14_;
#line 1258 "glib-2.0.vapi"
					_tmp12_ = str_array[i];
#line 1258 "glib-2.0.vapi"
					_tmp13_ = strlen ((const gchar*) _tmp12_);
#line 1258 "glib-2.0.vapi"
					_tmp14_ = _tmp13_;
#line 1258 "glib-2.0.vapi"
					_tmp10_ = _tmp14_;
#line 1175 "test.c"
				} else {
#line 1258 "glib-2.0.vapi"
					_tmp10_ = 0;
#line 1179 "test.c"
				}
#line 1258 "glib-2.0.vapi"
				len += (gsize) _tmp10_;
#line 1183 "test.c"
			}
		}
#line 1260 "glib-2.0.vapi"
		if (i == 0) {
#line 1188 "test.c"
			gchar* _tmp15_;
#line 1261 "glib-2.0.vapi"
			_tmp15_ = g_strdup ("");
#line 1261 "glib-2.0.vapi"
			result = _tmp15_;
#line 1261 "glib-2.0.vapi"
			return result;
#line 1196 "test.c"
		}
#line 1263 "glib-2.0.vapi"
		str_array_length1 = i;
#line 1264 "glib-2.0.vapi"
		_tmp16_ = strlen ((const gchar*) separator);
#line 1264 "glib-2.0.vapi"
		_tmp17_ = _tmp16_;
#line 1264 "glib-2.0.vapi"
		len += (gsize) (_tmp17_ * (i - 1));
#line 1266 "glib-2.0.vapi"
		_tmp18_ = g_malloc (len);
#line 1266 "glib-2.0.vapi"
		res = _tmp18_;
#line 1267 "glib-2.0.vapi"
		_tmp20_ = str_array[0];
#line 1267 "glib-2.0.vapi"
		if (_tmp20_ != NULL) {
#line 1214 "test.c"
			const gchar* _tmp21_;
#line 1267 "glib-2.0.vapi"
			_tmp21_ = str_array[0];
#line 1267 "glib-2.0.vapi"
			_tmp19_ = (const gchar*) _tmp21_;
#line 1220 "test.c"
		} else {
#line 1267 "glib-2.0.vapi"
			_tmp19_ = "";
#line 1224 "test.c"
		}
#line 1267 "glib-2.0.vapi"
		_tmp22_ = res;
#line 1267 "glib-2.0.vapi"
		_tmp23_ = g_stpcpy ((void*) _tmp22_, _tmp19_);
#line 1267 "glib-2.0.vapi"
		ptr = _tmp23_;
#line 1232 "test.c"
		{
			gboolean _tmp24_ = FALSE;
#line 1268 "glib-2.0.vapi"
			i = 1;
#line 1268 "glib-2.0.vapi"
			_tmp24_ = TRUE;
#line 1268 "glib-2.0.vapi"
			while (TRUE) {
#line 1241 "test.c"
				void* _tmp26_;
				void* _tmp27_;
				const gchar* _tmp28_ = NULL;
				const gchar* _tmp29_;
				void* _tmp31_;
				void* _tmp32_;
#line 1268 "glib-2.0.vapi"
				if (!_tmp24_) {
#line 1250 "test.c"
					gint _tmp25_;
#line 1268 "glib-2.0.vapi"
					_tmp25_ = i;
#line 1268 "glib-2.0.vapi"
					i = _tmp25_ + 1;
#line 1256 "test.c"
				}
#line 1268 "glib-2.0.vapi"
				_tmp24_ = FALSE;
#line 1268 "glib-2.0.vapi"
				if (!(i < str_array_length1)) {
#line 1268 "glib-2.0.vapi"
					break;
#line 1264 "test.c"
				}
#line 1269 "glib-2.0.vapi"
				_tmp26_ = ptr;
#line 1269 "glib-2.0.vapi"
				_tmp27_ = g_stpcpy (_tmp26_, (const gchar*) separator);
#line 1269 "glib-2.0.vapi"
				ptr = _tmp27_;
#line 1270 "glib-2.0.vapi"
				_tmp29_ = str_array[i];
#line 1270 "glib-2.0.vapi"
				if (_tmp29_ != NULL) {
#line 1276 "test.c"
					const gchar* _tmp30_;
#line 1270 "glib-2.0.vapi"
					_tmp30_ = str_array[i];
#line 1270 "glib-2.0.vapi"
					_tmp28_ = (const gchar*) _tmp30_;
#line 1282 "test.c"
				} else {
#line 1270 "glib-2.0.vapi"
					_tmp28_ = "";
#line 1286 "test.c"
				}
#line 1270 "glib-2.0.vapi"
				_tmp31_ = ptr;
#line 1270 "glib-2.0.vapi"
				_tmp32_ = g_stpcpy (_tmp31_, _tmp28_);
#line 1270 "glib-2.0.vapi"
				ptr = _tmp32_;
#line 1294 "test.c"
			}
		}
#line 1273 "glib-2.0.vapi"
		_tmp33_ = res;
#line 1273 "glib-2.0.vapi"
		res = NULL;
#line 1273 "glib-2.0.vapi"
		result = (gchar*) _tmp33_;
#line 1273 "glib-2.0.vapi"
		return result;
#line 1305 "test.c"
	} else {
		gchar* _tmp34_;
#line 1275 "glib-2.0.vapi"
		_tmp34_ = g_strdup ("");
#line 1275 "glib-2.0.vapi"
		result = _tmp34_;
#line 1275 "glib-2.0.vapi"
		return result;
#line 1314 "test.c"
	}
}

static const gchar*
string_to_string (const gchar* self)
{
	const gchar* result;
#line 1624 "glib-2.0.vapi"
	g_return_val_if_fail (self != NULL, NULL);
#line 1625 "glib-2.0.vapi"
	result = self;
#line 1625 "glib-2.0.vapi"
	return result;
#line 1328 "test.c"
}

GSubprocess*
start_prog (const gchar* prog,
            gchar** args,
            gint args_length1,
            GError** error)
{
	GArray* cmd = NULL;
	gchar** _tmp0_;
	gint _tmp0__length1;
	GArray* _tmp1_;
	GArray* _tmp2_;
	gchar* _tmp3_;
	GSubprocess* proc = NULL;
	GError* _inner_error0_ = NULL;
	GSubprocess* result;
#line 51 "test.vala"
	g_return_val_if_fail (prog != NULL, NULL);
#line 52 "test.vala"
	_tmp0_ = (args != NULL) ? _vala_array_dup1 (args, args_length1) : args;
#line 52 "test.vala"
	_tmp0__length1 = args_length1;
#line 52 "test.vala"
	_tmp1_ = g_array_new_take_zero_terminated (_tmp0_, TRUE, sizeof (gchar*));
#line 52 "test.vala"
	g_array_set_clear_func (_tmp1_, (GDestroyNotify) _vala_gchar_free_function_content_of);
#line 52 "test.vala"
	cmd = _tmp1_;
#line 53 "test.vala"
	_tmp2_ = cmd;
#line 53 "test.vala"
	_tmp3_ = g_strdup (prog);
#line 53 "test.vala"
	g_array_prepend_val (_tmp2_, _tmp3_);
#line 54 "test.vala"
	proc = NULL;
#line 1366 "test.c"
	{
		GSubprocess* _tmp4_ = NULL;
		GArray* _tmp5_;
		gpointer* _tmp6_;
		gint _tmp6__length1;
		GSubprocess* _tmp7_;
		GSubprocess* _tmp8_;
#line 56 "test.vala"
		_tmp5_ = cmd;
#line 56 "test.vala"
		_tmp6_ = _tmp5_->data;
#line 56 "test.vala"
		_tmp6__length1 = _tmp5_->len;
#line 56 "test.vala"
		_tmp7_ = g_subprocess_newv (_tmp6_, ((G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP | G_SUBPROCESS_FLAGS_STDIN_PIPE) | G_SUBPROCESS_FLAGS_STDOUT_PIPE) | G_SUBPROCESS_FLAGS_STDERR_PIPE, &_inner_error0_);
#line 56 "test.vala"
		_tmp4_ = _tmp7_;
#line 56 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 1386 "test.c"
			goto __catch0_g_error;
		}
#line 56 "test.vala"
		_tmp8_ = _tmp4_;
#line 56 "test.vala"
		_tmp4_ = NULL;
#line 56 "test.vala"
		_g_object_unref0 (proc);
#line 56 "test.vala"
		proc = _tmp8_;
#line 55 "test.vala"
		_g_object_unref0 (_tmp4_);
#line 1399 "test.c"
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		GArray* _tmp9_;
		gpointer* _tmp10_;
		gint _tmp10__length1;
		gchar* _tmp11_;
		gchar* _tmp12_;
		const gchar* _tmp13_;
		GError* _tmp14_;
		const gchar* _tmp15_;
		const gchar* _tmp16_;
		gchar* _tmp17_;
		gchar* _tmp18_;
		GError* _tmp19_;
#line 55 "test.vala"
		e = _inner_error0_;
#line 55 "test.vala"
		_inner_error0_ = NULL;
#line 62 "test.vala"
		_tmp9_ = cmd;
#line 62 "test.vala"
		_tmp10_ = _tmp9_->data;
#line 62 "test.vala"
		_tmp10__length1 = _tmp9_->len;
#line 62 "test.vala"
		_tmp11_ = _vala_g_strjoinv (" ", _tmp10_, (gint) _tmp10__length1);
#line 62 "test.vala"
		_tmp12_ = _tmp11_;
#line 62 "test.vala"
		_tmp13_ = string_to_string (_tmp12_);
#line 62 "test.vala"
		_tmp14_ = e;
#line 62 "test.vala"
		_tmp15_ = _tmp14_->message;
#line 62 "test.vala"
		_tmp16_ = string_to_string (_tmp15_);
#line 62 "test.vala"
		_tmp17_ = g_strconcat ("error starting command ", _tmp13_, ": ", _tmp16_, "\n", NULL);
#line 62 "test.vala"
		_tmp18_ = _tmp17_;
#line 62 "test.vala"
		g_print ("%s", _tmp18_);
#line 62 "test.vala"
		_g_free0 (_tmp18_);
#line 62 "test.vala"
		_g_free0 (_tmp12_);
#line 63 "test.vala"
		_tmp19_ = g_error_new_literal (TEST_ERROR, TEST_ERROR_TESTERROR, "could not run command");
#line 63 "test.vala"
		_inner_error0_ = _tmp19_;
#line 63 "test.vala"
		_g_error_free0 (e);
#line 1455 "test.c"
		goto __finally0;
	}
	__finally0:
#line 55 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 55 "test.vala"
		if (_inner_error0_->domain == TEST_ERROR) {
#line 55 "test.vala"
			g_propagate_error (error, _inner_error0_);
#line 55 "test.vala"
			_g_object_unref0 (proc);
#line 55 "test.vala"
			_g_array_unref0 (cmd);
#line 55 "test.vala"
			return NULL;
#line 1471 "test.c"
		} else {
#line 55 "test.vala"
			_g_object_unref0 (proc);
#line 55 "test.vala"
			_g_array_unref0 (cmd);
#line 55 "test.vala"
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 55 "test.vala"
			g_clear_error (&_inner_error0_);
#line 55 "test.vala"
			return NULL;
#line 1483 "test.c"
		}
	}
#line 65 "test.vala"
	result = proc;
#line 65 "test.vala"
	_g_array_unref0 (cmd);
#line 65 "test.vala"
	return result;
#line 1492 "test.c"
}

void
output_copy (const Output* self,
             Output* dest)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
#line 68 "test.vala"
	_tmp0_ = (*self).std_out;
#line 68 "test.vala"
	_tmp1_ = g_strdup (_tmp0_);
#line 68 "test.vala"
	_g_free0 ((*dest).std_out);
#line 68 "test.vala"
	(*dest).std_out = _tmp1_;
#line 68 "test.vala"
	_tmp2_ = (*self).std_err;
#line 68 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 68 "test.vala"
	_g_free0 ((*dest).std_err);
#line 68 "test.vala"
	(*dest).std_err = _tmp3_;
#line 1519 "test.c"
}

void
output_destroy (Output* self)
{
#line 69 "test.vala"
	_g_free0 ((*self).std_out);
#line 70 "test.vala"
	_g_free0 ((*self).std_err);
#line 1529 "test.c"
}

Output*
output_dup (const Output* self)
{
	Output* dup;
#line 68 "test.vala"
	dup = g_new0 (Output, 1);
#line 68 "test.vala"
	output_copy (self, dup);
#line 68 "test.vala"
	return dup;
#line 1542 "test.c"
}

void
output_free (Output* self)
{
#line 68 "test.vala"
	output_destroy (self);
#line 68 "test.vala"
	g_free (self);
#line 1552 "test.c"
}

static GType
output_get_type_once (void)
{
	GType output_type_id;
	output_type_id = g_boxed_type_register_static ("Output", (GBoxedCopyFunc) output_dup, (GBoxedFreeFunc) output_free);
	return output_type_id;
}

GType
output_get_type (void)
{
	static volatile gsize output_type_id__once = 0;
	if (g_once_init_enter (&output_type_id__once)) {
		GType output_type_id;
		output_type_id = output_get_type_once ();
		g_once_init_leave (&output_type_id__once, output_type_id);
	}
	return output_type_id__once;
}

GSubprocess*
check_prog (const gchar* prog,
            gchar** args,
            gint args_length1,
            GError** error)
{
	GSubprocess* proc = NULL;
	GSubprocess* _tmp0_;
	GSubprocess* _tmp1_;
	GError* _inner_error0_ = NULL;
	GSubprocess* result;
#line 73 "test.vala"
	g_return_val_if_fail (prog != NULL, NULL);
#line 74 "test.vala"
	_tmp0_ = start_prog (prog, args, (gint) args_length1, &_inner_error0_);
#line 74 "test.vala"
	proc = _tmp0_;
#line 74 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 74 "test.vala"
		g_propagate_error (error, _inner_error0_);
#line 74 "test.vala"
		return NULL;
#line 1598 "test.c"
	}
#line 75 "test.vala"
	_tmp1_ = proc;
#line 75 "test.vala"
	g_subprocess_wait_check (_tmp1_, NULL, &_inner_error0_);
#line 75 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 75 "test.vala"
		g_propagate_error (error, _inner_error0_);
#line 75 "test.vala"
		_g_object_unref0 (proc);
#line 75 "test.vala"
		return NULL;
#line 1612 "test.c"
	}
#line 76 "test.vala"
	result = proc;
#line 76 "test.vala"
	return result;
#line 1618 "test.c"
}

static gchar**
_vala_array_dup2 (gchar** self,
                  gssize length)
{
#line 81 "test.vala"
	if (length >= 0) {
#line 1627 "test.c"
		gchar** result;
		gssize i;
#line 81 "test.vala"
		result = g_new0 (gchar*, length + 1);
#line 81 "test.vala"
		for (i = 0; i < length; i++) {
#line 1634 "test.c"
			gchar* _tmp0_;
#line 81 "test.vala"
			_tmp0_ = g_strdup (self[i]);
#line 81 "test.vala"
			result[i] = _tmp0_;
#line 1640 "test.c"
		}
#line 81 "test.vala"
		return result;
#line 1644 "test.c"
	}
#line 81 "test.vala"
	return NULL;
#line 1648 "test.c"
}

gboolean
try_sudo (gchar** cmd,
          gint cmd_length1)
{
	gboolean _tmp6_ = FALSE;
	GError* _inner_error0_ = NULL;
	gboolean result;
	{
		GArray* cmd_args = NULL;
		gchar** _tmp0_;
		gint _tmp0__length1;
		GArray* _tmp1_;
		gchar* _tmp2_;
		gpointer* _tmp3_;
		gint _tmp3__length1;
		GSubprocess* _tmp4_;
		GSubprocess* _tmp5_;
#line 81 "test.vala"
		_tmp0_ = (cmd != NULL) ? _vala_array_dup2 (cmd, cmd_length1) : cmd;
#line 81 "test.vala"
		_tmp0__length1 = cmd_length1;
#line 81 "test.vala"
		_tmp1_ = g_array_new_take_zero_terminated (_tmp0_, TRUE, sizeof (gchar*));
#line 81 "test.vala"
		g_array_set_clear_func (_tmp1_, (GDestroyNotify) _vala_gchar_free_function_content_of);
#line 81 "test.vala"
		cmd_args = _tmp1_;
#line 82 "test.vala"
		_tmp2_ = g_strdup ("-n");
#line 82 "test.vala"
		g_array_prepend_val (cmd_args, _tmp2_);
#line 83 "test.vala"
		_tmp3_ = cmd_args->data;
#line 83 "test.vala"
		_tmp3__length1 = cmd_args->len;
#line 83 "test.vala"
		_tmp4_ = check_prog ("sudo", _tmp3_, (gint) _tmp3__length1, &_inner_error0_);
#line 83 "test.vala"
		_tmp5_ = _tmp4_;
#line 83 "test.vala"
		_g_object_unref0 (_tmp5_);
#line 83 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 83 "test.vala"
			_g_array_unref0 (cmd_args);
#line 1696 "test.c"
			goto __catch0_g_error;
		}
#line 84 "test.vala"
		result = TRUE;
#line 84 "test.vala"
		_g_array_unref0 (cmd_args);
#line 84 "test.vala"
		return result;
#line 1705 "test.c"
	}
	goto __finally0;
	__catch0_g_error:
	{
#line 80 "test.vala"
		g_clear_error (&_inner_error0_);
#line 86 "test.vala"
		g_print ("cannot sudo, skipping test\n");
#line 87 "test.vala"
		g_test_skip (NULL);
#line 88 "test.vala"
		result = FALSE;
#line 88 "test.vala"
		return result;
#line 1720 "test.c"
	}
	__finally0:
#line 80 "test.vala"
	g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 80 "test.vala"
	g_clear_error (&_inner_error0_);
#line 80 "test.vala"
	return _tmp6_;
#line 1729 "test.c"
}

static gpointer
_g_object_ref0 (gpointer self)
{
#line 103 "test.vala"
	return self ? g_object_ref (self) : NULL;
#line 1737 "test.c"
}

void
run_prog (const gchar* prog,
          gchar** args,
          gint args_length1,
          gint expected_rc,
          Output* result)
{
	gchar* std_out = NULL;
	gchar* _tmp0_;
	gchar* std_err = NULL;
	gchar* _tmp1_;
	const gchar* _tmp29_;
	gchar* _tmp30_;
	const gchar* _tmp31_;
	gchar* _tmp32_;
	Output _tmp33_ = {0};
	GError* _inner_error0_ = NULL;
#line 92 "test.vala"
	g_return_if_fail (prog != NULL);
#line 93 "test.vala"
	_tmp0_ = g_strdup ("");
#line 93 "test.vala"
	std_out = _tmp0_;
#line 94 "test.vala"
	_tmp1_ = g_strdup ("");
#line 94 "test.vala"
	std_err = _tmp1_;
#line 1767 "test.c"
	{
		GSubprocess* proc = NULL;
		GSubprocess* _tmp2_;
		GSubprocess* _tmp4_;
		GInputStream* stdout_pipe = NULL;
		GSubprocess* _tmp6_;
		GInputStream* _tmp7_;
		GInputStream* _tmp8_;
		GInputStream* stderr_pipe = NULL;
		GSubprocess* _tmp9_;
		GInputStream* _tmp10_;
		GInputStream* _tmp11_;
		gchar* _tmp12_ = NULL;
		GInputStream* _tmp13_;
		gchar* _tmp14_;
		gchar* _tmp15_;
		gchar* _tmp16_ = NULL;
		GInputStream* _tmp17_;
		gchar* _tmp18_;
		gchar* _tmp19_;
#line 96 "test.vala"
		_tmp2_ = start_prog (prog, args, (gint) args_length1, &_inner_error0_);
#line 96 "test.vala"
		proc = _tmp2_;
#line 96 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 1794 "test.c"
			goto __catch0_g_error;
		}
		{
			GSubprocess* _tmp3_;
#line 98 "test.vala"
			_tmp3_ = proc;
#line 98 "test.vala"
			g_subprocess_wait (_tmp3_, NULL, &_inner_error0_);
#line 98 "test.vala"
			if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 1805 "test.c"
				goto __catch1_g_error;
			}
		}
		goto __finally1;
		__catch1_g_error:
		{
#line 97 "test.vala"
			g_clear_error (&_inner_error0_);
#line 1814 "test.c"
		}
		__finally1:
#line 97 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 97 "test.vala"
			_g_object_unref0 (proc);
#line 1821 "test.c"
			goto __catch0_g_error;
		}
#line 100 "test.vala"
		_tmp4_ = proc;
#line 100 "test.vala"
		if (g_subprocess_get_if_exited (_tmp4_)) {
#line 1828 "test.c"
			GSubprocess* _tmp5_;
#line 101 "test.vala"
			_tmp5_ = proc;
#line 101 "test.vala"
			g_assert_true (g_subprocess_get_exit_status (_tmp5_) == expected_rc);
#line 1834 "test.c"
		}
#line 103 "test.vala"
		_tmp6_ = proc;
#line 103 "test.vala"
		_tmp7_ = g_subprocess_get_stdout_pipe (_tmp6_);
#line 103 "test.vala"
		_tmp8_ = _g_object_ref0 (_tmp7_);
#line 103 "test.vala"
		stdout_pipe = _tmp8_;
#line 104 "test.vala"
		_tmp9_ = proc;
#line 104 "test.vala"
		_tmp10_ = g_subprocess_get_stderr_pipe (_tmp9_);
#line 104 "test.vala"
		_tmp11_ = _g_object_ref0 (_tmp10_);
#line 104 "test.vala"
		stderr_pipe = _tmp11_;
#line 105 "test.vala"
		_tmp13_ = stdout_pipe;
#line 105 "test.vala"
		_tmp14_ = slurp (_tmp13_, &_inner_error0_);
#line 105 "test.vala"
		_tmp12_ = _tmp14_;
#line 105 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 105 "test.vala"
			_g_object_unref0 (stderr_pipe);
#line 105 "test.vala"
			_g_object_unref0 (stdout_pipe);
#line 105 "test.vala"
			_g_object_unref0 (proc);
#line 1866 "test.c"
			goto __catch0_g_error;
		}
#line 105 "test.vala"
		_tmp15_ = _tmp12_;
#line 105 "test.vala"
		_tmp12_ = NULL;
#line 105 "test.vala"
		_g_free0 (std_out);
#line 105 "test.vala"
		std_out = _tmp15_;
#line 106 "test.vala"
		_tmp17_ = stderr_pipe;
#line 106 "test.vala"
		_tmp18_ = slurp (_tmp17_, &_inner_error0_);
#line 106 "test.vala"
		_tmp16_ = _tmp18_;
#line 106 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 106 "test.vala"
			_g_free0 (_tmp12_);
#line 106 "test.vala"
			_g_object_unref0 (stderr_pipe);
#line 106 "test.vala"
			_g_object_unref0 (stdout_pipe);
#line 106 "test.vala"
			_g_object_unref0 (proc);
#line 1893 "test.c"
			goto __catch0_g_error;
		}
#line 106 "test.vala"
		_tmp19_ = _tmp16_;
#line 106 "test.vala"
		_tmp16_ = NULL;
#line 106 "test.vala"
		_g_free0 (std_err);
#line 106 "test.vala"
		std_err = _tmp19_;
#line 95 "test.vala"
		_g_free0 (_tmp16_);
#line 95 "test.vala"
		_g_free0 (_tmp12_);
#line 95 "test.vala"
		_g_object_unref0 (stderr_pipe);
#line 95 "test.vala"
		_g_object_unref0 (stdout_pipe);
#line 95 "test.vala"
		_g_object_unref0 (proc);
#line 1914 "test.c"
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		const gchar* _tmp20_;
		gchar* _tmp21_;
		gchar* _tmp22_;
		const gchar* _tmp23_;
		GError* _tmp24_;
		const gchar* _tmp25_;
		const gchar* _tmp26_;
		gchar* _tmp27_;
		gchar* _tmp28_;
#line 95 "test.vala"
		e = _inner_error0_;
#line 95 "test.vala"
		_inner_error0_ = NULL;
#line 108 "test.vala"
		_tmp20_ = string_to_string (prog);
#line 108 "test.vala"
		_tmp21_ = _vala_g_strjoinv (" ", args, (gint) args_length1);
#line 108 "test.vala"
		_tmp22_ = _tmp21_;
#line 108 "test.vala"
		_tmp23_ = string_to_string (_tmp22_);
#line 108 "test.vala"
		_tmp24_ = e;
#line 108 "test.vala"
		_tmp25_ = _tmp24_->message;
#line 108 "test.vala"
		_tmp26_ = string_to_string (_tmp25_);
#line 108 "test.vala"
		_tmp27_ = g_strconcat ("error in command ", _tmp20_, " ", _tmp23_, ": ", _tmp26_, "\n", NULL);
#line 108 "test.vala"
		_tmp28_ = _tmp27_;
#line 108 "test.vala"
		g_print ("%s", _tmp28_);
#line 108 "test.vala"
		_g_free0 (_tmp28_);
#line 108 "test.vala"
		_g_free0 (_tmp22_);
#line 95 "test.vala"
		_g_error_free0 (e);
#line 1959 "test.c"
	}
	__finally0:
#line 95 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 95 "test.vala"
		_g_free0 (std_err);
#line 95 "test.vala"
		_g_free0 (std_out);
#line 95 "test.vala"
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 95 "test.vala"
		g_clear_error (&_inner_error0_);
#line 95 "test.vala"
		return;
#line 1974 "test.c"
	}
#line 110 "test.vala"
	_tmp29_ = std_out;
#line 110 "test.vala"
	_tmp30_ = g_strdup (_tmp29_);
#line 110 "test.vala"
	_tmp31_ = std_err;
#line 110 "test.vala"
	_tmp32_ = g_strdup (_tmp31_);
#line 110 "test.vala"
	memset (&_tmp33_, 0, sizeof (Output));
#line 110 "test.vala"
	_g_free0 (_tmp33_.std_out);
#line 110 "test.vala"
	_tmp33_.std_out = _tmp30_;
#line 110 "test.vala"
	_g_free0 (_tmp33_.std_err);
#line 110 "test.vala"
	_tmp33_.std_err = _tmp32_;
#line 110 "test.vala"
	*result = _tmp33_;
#line 110 "test.vala"
	_g_free0 (std_err);
#line 110 "test.vala"
	_g_free0 (std_out);
#line 110 "test.vala"
	return;
#line 2002 "test.c"
}

TestRpl*
test_rpl_construct (GType object_type,
                    const gchar* bin_dir,
                    const gchar* test_files_dir)
{
	TestRpl * self = NULL;
	gchar* _tmp0_;
	gchar* _tmp1_;
#line 121 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 121 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 122 "test.vala"
	self = (TestRpl*) gee_test_case_construct (object_type, "TestRpl");
#line 123 "test.vala"
	_tmp0_ = g_build_filename (bin_dir, "rpl", NULL);
#line 123 "test.vala"
	_g_free0 (self->rpl);
#line 123 "test.vala"
	self->rpl = _tmp0_;
#line 124 "test.vala"
	_tmp1_ = g_strdup (test_files_dir);
#line 124 "test.vala"
	_g_free0 (self->test_files_dir);
#line 124 "test.vala"
	self->test_files_dir = _tmp1_;
#line 121 "test.vala"
	return self;
#line 2033 "test.c"
}

TestRpl*
test_rpl_new (const gchar* bin_dir,
              const gchar* test_files_dir)
{
#line 121 "test.vala"
	return test_rpl_construct (TYPE_TEST_RPL, bin_dir, test_files_dir);
#line 2042 "test.c"
}

void
test_rpl_run (TestRpl* self,
              gchar** args,
              gint args_length1,
              gint expected_rc,
              Output* result)
{
	const gchar* _tmp0_;
	Output _tmp1_ = {0};
#line 127 "test.vala"
	g_return_if_fail (self != NULL);
#line 128 "test.vala"
	_tmp0_ = self->rpl;
#line 128 "test.vala"
	run_prog (_tmp0_, args, (gint) args_length1, expected_rc, &_tmp1_);
#line 128 "test.vala"
	*result = _tmp1_;
#line 128 "test.vala"
	return;
#line 2064 "test.c"
}

static void
test_rpl_real_set_up (GeeTestCase* base)
{
	TestRpl * self;
	GError* _inner_error0_ = NULL;
#line 131 "test.vala"
	self = (TestRpl*) base;
#line 2074 "test.c"
	{
		gchar* _tmp0_ = NULL;
		gchar* _tmp1_;
		gchar* _tmp2_;
#line 133 "test.vala"
		_tmp1_ = g_dir_make_tmp ("rpl.test.XXXXXX", &_inner_error0_);
#line 133 "test.vala"
		_tmp0_ = _tmp1_;
#line 133 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 133 "test.vala"
			if (_inner_error0_->domain == G_FILE_ERROR) {
#line 2087 "test.c"
				goto __catch0_g_file_error;
			}
#line 133 "test.vala"
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 133 "test.vala"
			g_clear_error (&_inner_error0_);
#line 133 "test.vala"
			return;
#line 2096 "test.c"
		}
#line 133 "test.vala"
		_tmp2_ = _tmp0_;
#line 133 "test.vala"
		_tmp0_ = NULL;
#line 133 "test.vala"
		_g_free0 (self->test_result_dir);
#line 133 "test.vala"
		self->test_result_dir = _tmp2_;
#line 132 "test.vala"
		_g_free0 (_tmp0_);
#line 2108 "test.c"
	}
	goto __finally0;
	__catch0_g_file_error:
	{
		GError* e = NULL;
		GError* _tmp3_;
#line 132 "test.vala"
		e = _inner_error0_;
#line 132 "test.vala"
		_inner_error0_ = NULL;
#line 135 "test.vala"
		g_print ("error creating temporary directory\n");
#line 136 "test.vala"
		_tmp3_ = e;
#line 136 "test.vala"
		g_assert_no_error (_tmp3_);
#line 132 "test.vala"
		_g_error_free0 (e);
#line 2127 "test.c"
	}
	__finally0:
#line 132 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 132 "test.vala"
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 132 "test.vala"
		g_clear_error (&_inner_error0_);
#line 132 "test.vala"
		return;
#line 2138 "test.c"
	}
}

static void
test_rpl_real_tear_down (GeeTestCase* base)
{
	TestRpl * self;
	gchar* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gchar** _tmp3_;
	gchar** _tmp4_;
	gint _tmp4__length1;
	Output _tmp5_ = {0};
	Output _tmp6_;
#line 140 "test.vala"
	self = (TestRpl*) base;
#line 141 "test.vala"
	_tmp0_ = g_strdup ("-rf");
#line 141 "test.vala"
	_tmp1_ = self->test_result_dir;
#line 141 "test.vala"
	_tmp2_ = g_strdup (_tmp1_);
#line 141 "test.vala"
	_tmp3_ = g_new0 (gchar*, 2 + 1);
#line 141 "test.vala"
	_tmp3_[0] = _tmp0_;
#line 141 "test.vala"
	_tmp3_[1] = _tmp2_;
#line 141 "test.vala"
	_tmp4_ = _tmp3_;
#line 141 "test.vala"
	_tmp4__length1 = 2;
#line 141 "test.vala"
	run_prog ("rm", _tmp4_, (gint) 2, 0, &_tmp5_);
#line 141 "test.vala"
	_tmp6_ = _tmp5_;
#line 141 "test.vala"
	output_destroy (&_tmp6_);
#line 141 "test.vala"
	_tmp4_ = (_vala_array_free (_tmp4_, _tmp4__length1, (GDestroyNotify) g_free), NULL);
#line 2180 "test.c"
}

static void
test_rpl_class_init (TestRplClass * klass,
                     gpointer klass_data)
{
#line 116 "test.vala"
	test_rpl_parent_class = g_type_class_peek_parent (klass);
#line 116 "test.vala"
	((GeeTestCaseClass *) klass)->set_up = (void (*) (GeeTestCase*)) test_rpl_real_set_up;
#line 116 "test.vala"
	((GeeTestCaseClass *) klass)->tear_down = (void (*) (GeeTestCase*)) test_rpl_real_tear_down;
#line 116 "test.vala"
	G_OBJECT_CLASS (klass)->finalize = test_rpl_finalize;
#line 2195 "test.c"
}

static void
test_rpl_instance_init (TestRpl * self,
                        gpointer klass)
{
}

static void
test_rpl_finalize (GObject * obj)
{
	TestRpl * self;
#line 116 "test.vala"
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST_RPL, TestRpl);
#line 117 "test.vala"
	_g_free0 (self->rpl);
#line 118 "test.vala"
	_g_free0 (self->test_files_dir);
#line 119 "test.vala"
	_g_free0 (self->test_result_dir);
#line 116 "test.vala"
	G_OBJECT_CLASS (test_rpl_parent_class)->finalize (obj);
#line 2218 "test.c"
}

static GType
test_rpl_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (TestRplClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_rpl_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TestRpl), 0, (GInstanceInitFunc) test_rpl_instance_init, NULL };
	GType test_rpl_type_id;
	test_rpl_type_id = g_type_register_static (TYPE_GEE_TEST_CASE, "TestRpl", &g_define_type_info, 0);
	return test_rpl_type_id;
}

GType
test_rpl_get_type (void)
{
	static volatile gsize test_rpl_type_id__once = 0;
	if (g_once_init_enter (&test_rpl_type_id__once)) {
		GType test_rpl_type_id;
		test_rpl_type_id = test_rpl_get_type_once ();
		g_once_init_leave (&test_rpl_type_id__once, test_rpl_type_id);
	}
	return test_rpl_type_id__once;
}

TestRplOutputFile*
test_rpl_output_file_construct (GType object_type,
                                const gchar* bin_dir,
                                const gchar* test_files_dir)
{
	TestRplOutputFile * self = NULL;
#line 148 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 148 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 149 "test.vala"
	self = (TestRplOutputFile*) test_rpl_construct (object_type, bin_dir, test_files_dir);
#line 148 "test.vala"
	return self;
#line 2256 "test.c"
}

TestRplOutputFile*
test_rpl_output_file_new (const gchar* bin_dir,
                          const gchar* test_files_dir)
{
#line 148 "test.vala"
	return test_rpl_output_file_construct (TYPE_TEST_RPL_OUTPUT_FILE, bin_dir, test_files_dir);
#line 2265 "test.c"
}

static void
test_rpl_output_file_real_set_up (GeeTestCase* base)
{
	TestRplOutputFile * self;
	const gchar* _tmp0_;
	gchar* _tmp1_;
#line 152 "test.vala"
	self = (TestRplOutputFile*) base;
#line 153 "test.vala"
	GEE_TEST_CASE_CLASS (test_rpl_output_file_parent_class)->set_up ((GeeTestCase*) G_TYPE_CHECK_INSTANCE_CAST (self, TYPE_TEST_RPL, TestRpl));
#line 154 "test.vala"
	_tmp0_ = ((TestRpl*) self)->test_result_dir;
#line 154 "test.vala"
	_tmp1_ = g_build_filename (_tmp0_, "test.txt", NULL);
#line 154 "test.vala"
	_g_free0 (self->test_result_root);
#line 154 "test.vala"
	self->test_result_root = _tmp1_;
#line 2286 "test.c"
}

gboolean
test_rpl_output_file_result_matches (TestRplOutputFile* self,
                                     const gchar* expected_root)
{
	GError* _inner_error0_ = NULL;
	gboolean result;
#line 157 "test.vala"
	g_return_val_if_fail (self != NULL, FALSE);
#line 157 "test.vala"
	g_return_val_if_fail (expected_root != NULL, FALSE);
#line 2299 "test.c"
	{
		gchar* _tmp0_;
		gchar* _tmp1_;
		const gchar* _tmp2_;
		gchar* _tmp3_;
		gchar** _tmp4_;
		gchar** _tmp5_;
		gint _tmp5__length1;
		GSubprocess* _tmp6_;
		GSubprocess* _tmp7_;
#line 159 "test.vala"
		_tmp0_ = g_strdup ("-r");
#line 159 "test.vala"
		_tmp1_ = g_strdup (expected_root);
#line 159 "test.vala"
		_tmp2_ = self->test_result_root;
#line 159 "test.vala"
		_tmp3_ = g_strdup (_tmp2_);
#line 159 "test.vala"
		_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 159 "test.vala"
		_tmp4_[0] = _tmp0_;
#line 159 "test.vala"
		_tmp4_[1] = _tmp1_;
#line 159 "test.vala"
		_tmp4_[2] = _tmp3_;
#line 159 "test.vala"
		_tmp5_ = _tmp4_;
#line 159 "test.vala"
		_tmp5__length1 = 3;
#line 159 "test.vala"
		_tmp6_ = check_prog ("diff", _tmp5_, (gint) 3, &_inner_error0_);
#line 159 "test.vala"
		_tmp7_ = _tmp6_;
#line 159 "test.vala"
		_g_object_unref0 (_tmp7_);
#line 159 "test.vala"
		_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 159 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 2340 "test.c"
			goto __catch0_g_error;
		}
	}
	goto __finally0;
	__catch0_g_error:
	{
#line 158 "test.vala"
		g_clear_error (&_inner_error0_);
#line 161 "test.vala"
		result = FALSE;
#line 161 "test.vala"
		return result;
#line 2353 "test.c"
	}
	__finally0:
#line 158 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 2358 "test.c"
		gboolean _tmp8_ = FALSE;
#line 158 "test.vala"
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 158 "test.vala"
		g_clear_error (&_inner_error0_);
#line 158 "test.vala"
		return _tmp8_;
#line 2366 "test.c"
	}
#line 163 "test.vala"
	result = TRUE;
#line 163 "test.vala"
	return result;
#line 2372 "test.c"
}

gboolean
test_rpl_output_file_result_matches_string (TestRplOutputFile* self,
                                            const gchar* expected,
                                            gsize length)
{
	gboolean _tmp5_ = FALSE;
	GError* _inner_error0_ = NULL;
	gboolean result;
#line 166 "test.vala"
	g_return_val_if_fail (self != NULL, FALSE);
#line 166 "test.vala"
	g_return_val_if_fail (expected != NULL, FALSE);
#line 2387 "test.c"
	{
		gchar* s = NULL;
		const gchar* _tmp0_;
		gchar* _tmp1_;
		const gchar* _tmp4_;
#line 168 "test.vala"
		_tmp0_ = self->test_result_root;
#line 168 "test.vala"
		_tmp1_ = slurp_file (_tmp0_, NULL, &_inner_error0_);
#line 168 "test.vala"
		s = _tmp1_;
#line 168 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 2401 "test.c"
			gboolean _tmp2_ = FALSE;
#line 168 "test.vala"
			if (_inner_error0_->domain == G_FILE_ERROR) {
#line 2405 "test.c"
				goto __catch0_g_file_error;
			}
#line 168 "test.vala"
			g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 168 "test.vala"
			g_clear_error (&_inner_error0_);
#line 168 "test.vala"
			return _tmp2_;
#line 2414 "test.c"
		}
#line 169 "test.vala"
		if (length == ((gsize) -1)) {
#line 2418 "test.c"
			const gchar* _tmp3_;
#line 170 "test.vala"
			_tmp3_ = s;
#line 170 "test.vala"
			result = g_strcmp0 (_tmp3_, expected) == 0;
#line 170 "test.vala"
			_g_free0 (s);
#line 170 "test.vala"
			return result;
#line 2428 "test.c"
		}
#line 171 "test.vala"
		_tmp4_ = s;
#line 171 "test.vala"
		result = memcmp (_tmp4_, expected, length) == 0;
#line 171 "test.vala"
		_g_free0 (s);
#line 171 "test.vala"
		return result;
#line 2438 "test.c"
	}
	goto __finally0;
	__catch0_g_file_error:
	{
#line 167 "test.vala"
		g_clear_error (&_inner_error0_);
#line 173 "test.vala"
		result = FALSE;
#line 173 "test.vala"
		return result;
#line 2449 "test.c"
	}
	__finally0:
#line 167 "test.vala"
	g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 167 "test.vala"
	g_clear_error (&_inner_error0_);
#line 167 "test.vala"
	return _tmp5_;
#line 2458 "test.c"
}

static void
test_rpl_output_file_class_init (TestRplOutputFileClass * klass,
                                 gpointer klass_data)
{
#line 145 "test.vala"
	test_rpl_output_file_parent_class = g_type_class_peek_parent (klass);
#line 145 "test.vala"
	((GeeTestCaseClass *) klass)->set_up = (void (*) (GeeTestCase*)) test_rpl_output_file_real_set_up;
#line 145 "test.vala"
	G_OBJECT_CLASS (klass)->finalize = test_rpl_output_file_finalize;
#line 2471 "test.c"
}

static void
test_rpl_output_file_instance_init (TestRplOutputFile * self,
                                    gpointer klass)
{
}

static void
test_rpl_output_file_finalize (GObject * obj)
{
	TestRplOutputFile * self;
#line 145 "test.vala"
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST_RPL_OUTPUT_FILE, TestRplOutputFile);
#line 146 "test.vala"
	_g_free0 (self->test_result_root);
#line 145 "test.vala"
	G_OBJECT_CLASS (test_rpl_output_file_parent_class)->finalize (obj);
#line 2490 "test.c"
}

static GType
test_rpl_output_file_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (TestRplOutputFileClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_rpl_output_file_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TestRplOutputFile), 0, (GInstanceInitFunc) test_rpl_output_file_instance_init, NULL };
	GType test_rpl_output_file_type_id;
	test_rpl_output_file_type_id = g_type_register_static (TYPE_TEST_RPL, "TestRplOutputFile", &g_define_type_info, 0);
	return test_rpl_output_file_type_id;
}

GType
test_rpl_output_file_get_type (void)
{
	static volatile gsize test_rpl_output_file_type_id__once = 0;
	if (g_once_init_enter (&test_rpl_output_file_type_id__once)) {
		GType test_rpl_output_file_type_id;
		test_rpl_output_file_type_id = test_rpl_output_file_get_type_once ();
		g_once_init_leave (&test_rpl_output_file_type_id__once, test_rpl_output_file_type_id);
	}
	return test_rpl_output_file_type_id__once;
}

static TestRplFile*
test_rpl_file_construct (GType object_type,
                         const gchar* bin_dir,
                         const gchar* test_files_dir,
                         const gchar* test_data)
{
	TestRplFile * self = NULL;
	gchar* _tmp0_;
	gchar* _tmp1_;
#line 184 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 184 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 184 "test.vala"
	g_return_val_if_fail (test_data != NULL, NULL);
#line 185 "test.vala"
	self = (TestRplFile*) test_rpl_output_file_construct (object_type, bin_dir, test_files_dir);
#line 186 "test.vala"
	_tmp0_ = g_strdup (test_data);
#line 186 "test.vala"
	_g_free0 (self->test_data);
#line 186 "test.vala"
	self->test_data = _tmp0_;
#line 187 "test.vala"
	_tmp1_ = g_build_filename (test_files_dir, test_data, NULL);
#line 187 "test.vala"
	_g_free0 (self->test_data_root);
#line 187 "test.vala"
	self->test_data_root = _tmp1_;
#line 184 "test.vala"
	return self;
#line 2545 "test.c"
}

static void
test_rpl_file_real_set_up (GeeTestCase* base)
{
	TestRplFile * self;
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
	gchar* _tmp12_;
	gchar* _tmp13_;
	const gchar* _tmp14_;
	gchar* _tmp15_;
	gchar** _tmp16_;
	gchar** _tmp17_;
	gint _tmp17__length1;
	Output _tmp18_ = {0};
	Output _tmp19_;
#line 190 "test.vala"
	self = (TestRplFile*) base;
#line 191 "test.vala"
	GEE_TEST_CASE_CLASS (test_rpl_file_parent_class)->set_up ((GeeTestCase*) G_TYPE_CHECK_INSTANCE_CAST (self, TYPE_TEST_RPL_OUTPUT_FILE, TestRplOutputFile));
#line 192 "test.vala"
	_tmp0_ = ((TestRpl*) self)->test_result_dir;
#line 192 "test.vala"
	_tmp1_ = self->test_data;
#line 192 "test.vala"
	_tmp2_ = g_build_filename (_tmp0_, _tmp1_, NULL);
#line 192 "test.vala"
	_g_free0 (((TestRplOutputFile*) self)->test_result_root);
#line 192 "test.vala"
	((TestRplOutputFile*) self)->test_result_root = _tmp2_;
#line 193 "test.vala"
	_tmp3_ = g_strdup ("-r");
#line 193 "test.vala"
	_tmp4_ = self->test_data_root;
#line 193 "test.vala"
	_tmp5_ = g_strdup (_tmp4_);
#line 193 "test.vala"
	_tmp6_ = ((TestRpl*) self)->test_result_dir;
#line 193 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 193 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 193 "test.vala"
	_tmp8_[0] = _tmp3_;
#line 193 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 193 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 193 "test.vala"
	_tmp9_ = _tmp8_;
#line 193 "test.vala"
	_tmp9__length1 = 3;
#line 193 "test.vala"
	run_prog ("cp", _tmp9_, (gint) 3, 0, &_tmp10_);
#line 193 "test.vala"
	_tmp11_ = _tmp10_;
#line 193 "test.vala"
	output_destroy (&_tmp11_);
#line 193 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 194 "test.vala"
	_tmp12_ = g_strdup ("-R");
#line 194 "test.vala"
	_tmp13_ = g_strdup ("u+w");
#line 194 "test.vala"
	_tmp14_ = ((TestRpl*) self)->test_result_dir;
#line 194 "test.vala"
	_tmp15_ = g_strdup (_tmp14_);
#line 194 "test.vala"
	_tmp16_ = g_new0 (gchar*, 3 + 1);
#line 194 "test.vala"
	_tmp16_[0] = _tmp12_;
#line 194 "test.vala"
	_tmp16_[1] = _tmp13_;
#line 194 "test.vala"
	_tmp16_[2] = _tmp15_;
#line 194 "test.vala"
	_tmp17_ = _tmp16_;
#line 194 "test.vala"
	_tmp17__length1 = 3;
#line 194 "test.vala"
	run_prog ("chmod", _tmp17_, (gint) 3, 0, &_tmp18_);
#line 194 "test.vala"
	_tmp19_ = _tmp18_;
#line 194 "test.vala"
	output_destroy (&_tmp19_);
#line 194 "test.vala"
	_tmp17_ = (_vala_array_free (_tmp17_, _tmp17__length1, (GDestroyNotify) g_free), NULL);
#line 2646 "test.c"
}

static void
test_rpl_file_class_init (TestRplFileClass * klass,
                          gpointer klass_data)
{
#line 180 "test.vala"
	test_rpl_file_parent_class = g_type_class_peek_parent (klass);
#line 180 "test.vala"
	((GeeTestCaseClass *) klass)->set_up = (void (*) (GeeTestCase*)) test_rpl_file_real_set_up;
#line 180 "test.vala"
	G_OBJECT_CLASS (klass)->finalize = test_rpl_file_finalize;
#line 2659 "test.c"
}

static void
test_rpl_file_instance_init (TestRplFile * self,
                             gpointer klass)
{
}

static void
test_rpl_file_finalize (GObject * obj)
{
	TestRplFile * self;
#line 180 "test.vala"
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST_RPL_FILE, TestRplFile);
#line 181 "test.vala"
	_g_free0 (self->test_data_root);
#line 182 "test.vala"
	_g_free0 (self->test_data);
#line 180 "test.vala"
	G_OBJECT_CLASS (test_rpl_file_parent_class)->finalize (obj);
#line 2680 "test.c"
}

static GType
test_rpl_file_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (TestRplFileClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_rpl_file_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TestRplFile), 0, (GInstanceInitFunc) test_rpl_file_instance_init, NULL };
	GType test_rpl_file_type_id;
	test_rpl_file_type_id = g_type_register_static (TYPE_TEST_RPL_OUTPUT_FILE, "TestRplFile", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
	return test_rpl_file_type_id;
}

GType
test_rpl_file_get_type (void)
{
	static volatile gsize test_rpl_file_type_id__once = 0;
	if (g_once_init_enter (&test_rpl_file_type_id__once)) {
		GType test_rpl_file_type_id;
		test_rpl_file_type_id = test_rpl_file_get_type_once ();
		g_once_init_leave (&test_rpl_file_type_id__once, test_rpl_file_type_id);
	}
	return test_rpl_file_type_id__once;
}

static void
_encoding_tests_test_bad_encoding_gee_test_case_test_method (gpointer self)
{
#line 201 "test.vala"
	encoding_tests_test_bad_encoding ((EncodingTests*) self);
#line 2709 "test.c"
}

static void
_encoding_tests_test_explicit_encoding_gee_test_case_test_method (gpointer self)
{
#line 202 "test.vala"
	encoding_tests_test_explicit_encoding ((EncodingTests*) self);
#line 2717 "test.c"
}

EncodingTests*
encoding_tests_construct (GType object_type,
                          const gchar* bin_dir,
                          const gchar* test_files_dir)
{
	EncodingTests * self = NULL;
#line 199 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 199 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 200 "test.vala"
	self = (EncodingTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "lorem-iso-8859-1.txt");
#line 201 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_bad_encoding", _encoding_tests_test_bad_encoding_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 202 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_explicit_encoding", _encoding_tests_test_explicit_encoding_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 199 "test.vala"
	return self;
#line 2738 "test.c"
}

EncodingTests*
encoding_tests_new (const gchar* bin_dir,
                    const gchar* test_files_dir)
{
#line 199 "test.vala"
	return encoding_tests_construct (TYPE_ENCODING_TESTS, bin_dir, test_files_dir);
#line 2747 "test.c"
}

static gboolean
string_contains (const gchar* self,
                 const gchar* needle)
{
	gchar* _tmp0_;
	gboolean result;
#line 1584 "glib-2.0.vapi"
	g_return_val_if_fail (self != NULL, FALSE);
#line 1584 "glib-2.0.vapi"
	g_return_val_if_fail (needle != NULL, FALSE);
#line 1585 "glib-2.0.vapi"
	_tmp0_ = strstr ((gchar*) self, (gchar*) needle);
#line 1585 "glib-2.0.vapi"
	result = _tmp0_ != NULL;
#line 1585 "glib-2.0.vapi"
	return result;
#line 2766 "test.c"
}

static void
encoding_tests_test_bad_encoding (EncodingTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	Output _tmp9_;
	const gchar* _tmp10_;
#line 205 "test.vala"
	g_return_if_fail (self != NULL);
#line 206 "test.vala"
	_tmp0_ = g_strdup ("--encoding=utf-8");
#line 206 "test.vala"
	_tmp1_ = g_strdup ("Lorem");
#line 206 "test.vala"
	_tmp2_ = g_strdup ("L-O-R-E-M");
#line 206 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 206 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 206 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 206 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 206 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 206 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 206 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 206 "test.vala"
	_tmp6_ = _tmp5_;
#line 206 "test.vala"
	_tmp6__length1 = 4;
#line 206 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 206 "test.vala"
	_tmp8_ = _tmp7_;
#line 206 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 206 "test.vala"
	output = _tmp8_;
#line 207 "test.vala"
	_tmp9_ = output;
#line 207 "test.vala"
	_tmp10_ = _tmp9_.std_err;
#line 207 "test.vala"
	g_assert_true (string_contains (_tmp10_, "error decoding"));
#line 205 "test.vala"
	output_destroy (&output);
#line 2827 "test.c"
}

static void
encoding_tests_test_explicit_encoding (EncodingTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 210 "test.vala"
	g_return_if_fail (self != NULL);
#line 211 "test.vala"
	_tmp0_ = g_strdup ("--encoding=iso-8859-1");
#line 211 "test.vala"
	_tmp1_ = g_strdup ("Lorem");
#line 211 "test.vala"
	_tmp2_ = g_strdup ("L-O-R-E-M");
#line 211 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 211 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 211 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 211 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 211 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 211 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 211 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 211 "test.vala"
	_tmp6_ = _tmp5_;
#line 211 "test.vala"
	_tmp6__length1 = 4;
#line 211 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 211 "test.vala"
	_tmp8_ = _tmp7_;
#line 211 "test.vala"
	output_destroy (&_tmp8_);
#line 211 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 212 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 212 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "lorem-iso-8859-1_explicit-encoding_expected.txt", NULL);
#line 212 "test.vala"
	_tmp11_ = _tmp10_;
#line 212 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 212 "test.vala"
	_g_free0 (_tmp11_);
#line 2890 "test.c"
}

static void
encoding_tests_class_init (EncodingTestsClass * klass,
                           gpointer klass_data)
{
#line 198 "test.vala"
	encoding_tests_parent_class = g_type_class_peek_parent (klass);
#line 2899 "test.c"
}

static void
encoding_tests_instance_init (EncodingTests * self,
                              gpointer klass)
{
}

static GType
encoding_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (EncodingTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) encoding_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EncodingTests), 0, (GInstanceInitFunc) encoding_tests_instance_init, NULL };
	GType encoding_tests_type_id;
	encoding_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "EncodingTests", &g_define_type_info, 0);
	return encoding_tests_type_id;
}

GType
encoding_tests_get_type (void)
{
	static volatile gsize encoding_tests_type_id__once = 0;
	if (g_once_init_enter (&encoding_tests_type_id__once)) {
		GType encoding_tests_type_id;
		encoding_tests_type_id = encoding_tests_get_type_once ();
		g_once_init_leave (&encoding_tests_type_id__once, encoding_tests_type_id);
	}
	return encoding_tests_type_id__once;
}

static void
_no_file_tests_test_no_arguments_gee_test_case_test_method (gpointer self)
{
#line 221 "test.vala"
	no_file_tests_test_no_arguments ((NoFileTests*) self);
#line 2934 "test.c"
}

static void
_no_file_tests_test_help_gee_test_case_test_method (gpointer self)
{
#line 222 "test.vala"
	no_file_tests_test_help ((NoFileTests*) self);
#line 2942 "test.c"
}

static void
_no_file_tests_test_full_help_gee_test_case_test_method (gpointer self)
{
#line 223 "test.vala"
	no_file_tests_test_full_help ((NoFileTests*) self);
#line 2950 "test.c"
}

static void
_no_file_tests_test_version_gee_test_case_test_method (gpointer self)
{
#line 224 "test.vala"
	no_file_tests_test_version ((NoFileTests*) self);
#line 2958 "test.c"
}

static void
_no_file_tests_test_nonexistent_option_gee_test_case_test_method (gpointer self)
{
#line 225 "test.vala"
	no_file_tests_test_nonexistent_option ((NoFileTests*) self);
#line 2966 "test.c"
}

static void
_no_file_tests_test_nonexistent_input_gee_test_case_test_method (gpointer self)
{
#line 226 "test.vala"
	no_file_tests_test_nonexistent_input ((NoFileTests*) self);
#line 2974 "test.c"
}

static void
_no_file_tests_test_nonexistent_patterns_file_gee_test_case_test_method (gpointer self)
{
#line 227 "test.vala"
	no_file_tests_test_nonexistent_patterns_file ((NoFileTests*) self);
#line 2982 "test.c"
}

static void
_no_file_tests_test_input_is_directory_gee_test_case_test_method (gpointer self)
{
#line 228 "test.vala"
	no_file_tests_test_input_is_directory ((NoFileTests*) self);
#line 2990 "test.c"
}

NoFileTests*
no_file_tests_construct (GType object_type,
                         const gchar* bin_dir,
                         const gchar* test_files_dir)
{
	NoFileTests * self = NULL;
#line 218 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 218 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 219 "test.vala"
	self = (NoFileTests*) test_rpl_construct (object_type, bin_dir, test_files_dir);
#line 221 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_no_arguments", _no_file_tests_test_no_arguments_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 222 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_help", _no_file_tests_test_help_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 223 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_full_help", _no_file_tests_test_full_help_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 224 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_version", _no_file_tests_test_version_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 225 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_nonexistent_option", _no_file_tests_test_nonexistent_option_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 226 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_nonexistent_input", _no_file_tests_test_nonexistent_input_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 227 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_nonexistent_patterns_file", _no_file_tests_test_nonexistent_patterns_file_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 228 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_input_is_directory", _no_file_tests_test_input_is_directory_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 218 "test.vala"
	return self;
#line 3023 "test.c"
}

NoFileTests*
no_file_tests_new (const gchar* bin_dir,
                   const gchar* test_files_dir)
{
#line 218 "test.vala"
	return no_file_tests_construct (TYPE_NO_FILE_TESTS, bin_dir, test_files_dir);
#line 3032 "test.c"
}

static void
no_file_tests_test_no_arguments (NoFileTests* self)
{
	Output output = {0};
	gchar** _tmp0_;
	gchar** _tmp1_;
	gint _tmp1__length1;
	Output _tmp2_ = {0};
	Output _tmp3_;
	Output _tmp4_;
	const gchar* _tmp5_;
#line 231 "test.vala"
	g_return_if_fail (self != NULL);
#line 232 "test.vala"
	_tmp0_ = g_new0 (gchar*, 0 + 1);
#line 232 "test.vala"
	_tmp1_ = _tmp0_;
#line 232 "test.vala"
	_tmp1__length1 = 0;
#line 232 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp1_, (gint) 0, 1, &_tmp2_);
#line 232 "test.vala"
	_tmp3_ = _tmp2_;
#line 232 "test.vala"
	_tmp1_ = (_vala_array_free (_tmp1_, _tmp1__length1, (GDestroyNotify) g_free), NULL);
#line 232 "test.vala"
	output = _tmp3_;
#line 233 "test.vala"
	_tmp4_ = output;
#line 233 "test.vala"
	_tmp5_ = _tmp4_.std_out;
#line 233 "test.vala"
	g_assert_true (string_contains (_tmp5_, "Search and replace text in files."));
#line 231 "test.vala"
	output_destroy (&output);
#line 3070 "test.c"
}

static void
no_file_tests_test_help (NoFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar** _tmp1_;
	gchar** _tmp2_;
	gint _tmp2__length1;
	Output _tmp3_ = {0};
	Output _tmp4_;
	Output _tmp5_;
	const gchar* _tmp6_;
#line 236 "test.vala"
	g_return_if_fail (self != NULL);
#line 237 "test.vala"
	_tmp0_ = g_strdup ("--help");
#line 237 "test.vala"
	_tmp1_ = g_new0 (gchar*, 1 + 1);
#line 237 "test.vala"
	_tmp1_[0] = _tmp0_;
#line 237 "test.vala"
	_tmp2_ = _tmp1_;
#line 237 "test.vala"
	_tmp2__length1 = 1;
#line 237 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp2_, (gint) 1, 0, &_tmp3_);
#line 237 "test.vala"
	_tmp4_ = _tmp3_;
#line 237 "test.vala"
	_tmp2_ = (_vala_array_free (_tmp2_, _tmp2__length1, (GDestroyNotify) g_free), NULL);
#line 237 "test.vala"
	output = _tmp4_;
#line 238 "test.vala"
	_tmp5_ = output;
#line 238 "test.vala"
	_tmp6_ = _tmp5_.std_out;
#line 238 "test.vala"
	g_assert_true (string_contains (_tmp6_, "Search and replace text in files."));
#line 236 "test.vala"
	output_destroy (&output);
#line 3113 "test.c"
}

static void
no_file_tests_test_full_help (NoFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar** _tmp1_;
	gchar** _tmp2_;
	gint _tmp2__length1;
	Output _tmp3_ = {0};
	Output _tmp4_;
	Output _tmp5_;
	const gchar* _tmp6_;
#line 241 "test.vala"
	g_return_if_fail (self != NULL);
#line 242 "test.vala"
	_tmp0_ = g_strdup ("--full-help");
#line 242 "test.vala"
	_tmp1_ = g_new0 (gchar*, 1 + 1);
#line 242 "test.vala"
	_tmp1_[0] = _tmp0_;
#line 242 "test.vala"
	_tmp2_ = _tmp1_;
#line 242 "test.vala"
	_tmp2__length1 = 1;
#line 242 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp2_, (gint) 1, 0, &_tmp3_);
#line 242 "test.vala"
	_tmp4_ = _tmp3_;
#line 242 "test.vala"
	_tmp2_ = (_vala_array_free (_tmp2_, _tmp2__length1, (GDestroyNotify) g_free), NULL);
#line 242 "test.vala"
	output = _tmp4_;
#line 243 "test.vala"
	_tmp5_ = output;
#line 243 "test.vala"
	_tmp6_ = _tmp5_.std_out;
#line 243 "test.vala"
	g_assert_true (string_contains (_tmp6_, "use extended regex syntax [IGNORED]"));
#line 241 "test.vala"
	output_destroy (&output);
#line 3156 "test.c"
}

static void
no_file_tests_test_version (NoFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar** _tmp1_;
	gchar** _tmp2_;
	gint _tmp2__length1;
	Output _tmp3_ = {0};
	Output _tmp4_;
	Output _tmp5_;
	const gchar* _tmp6_;
#line 246 "test.vala"
	g_return_if_fail (self != NULL);
#line 247 "test.vala"
	_tmp0_ = g_strdup ("--version");
#line 247 "test.vala"
	_tmp1_ = g_new0 (gchar*, 1 + 1);
#line 247 "test.vala"
	_tmp1_[0] = _tmp0_;
#line 247 "test.vala"
	_tmp2_ = _tmp1_;
#line 247 "test.vala"
	_tmp2__length1 = 1;
#line 247 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp2_, (gint) 1, 0, &_tmp3_);
#line 247 "test.vala"
	_tmp4_ = _tmp3_;
#line 247 "test.vala"
	_tmp2_ = (_vala_array_free (_tmp2_, _tmp2__length1, (GDestroyNotify) g_free), NULL);
#line 247 "test.vala"
	output = _tmp4_;
#line 248 "test.vala"
	_tmp5_ = output;
#line 248 "test.vala"
	_tmp6_ = _tmp5_.std_out;
#line 248 "test.vala"
	g_assert_true (string_contains (_tmp6_, "NO WARRANTY, to the extent"));
#line 246 "test.vala"
	output_destroy (&output);
#line 3199 "test.c"
}

static void
no_file_tests_test_nonexistent_option (NoFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar** _tmp1_;
	gchar** _tmp2_;
	gint _tmp2__length1;
	Output _tmp3_ = {0};
	Output _tmp4_;
	Output _tmp5_;
	const gchar* _tmp6_;
#line 251 "test.vala"
	g_return_if_fail (self != NULL);
#line 252 "test.vala"
	_tmp0_ = g_strdup ("--foo");
#line 252 "test.vala"
	_tmp1_ = g_new0 (gchar*, 1 + 1);
#line 252 "test.vala"
	_tmp1_[0] = _tmp0_;
#line 252 "test.vala"
	_tmp2_ = _tmp1_;
#line 252 "test.vala"
	_tmp2__length1 = 1;
#line 252 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp2_, (gint) 1, 1, &_tmp3_);
#line 252 "test.vala"
	_tmp4_ = _tmp3_;
#line 252 "test.vala"
	_tmp2_ = (_vala_array_free (_tmp2_, _tmp2__length1, (GDestroyNotify) g_free), NULL);
#line 252 "test.vala"
	output = _tmp4_;
#line 255 "test.vala"
	_tmp5_ = output;
#line 255 "test.vala"
	_tmp6_ = _tmp5_.std_err;
#line 255 "test.vala"
	g_assert_true (string_contains (_tmp6_, "foo"));
#line 251 "test.vala"
	output_destroy (&output);
#line 3242 "test.c"
}

static void
no_file_tests_test_nonexistent_input (NoFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar** _tmp3_;
	gchar** _tmp4_;
	gint _tmp4__length1;
	Output _tmp5_ = {0};
	Output _tmp6_;
	Output _tmp7_;
	const gchar* _tmp8_;
#line 258 "test.vala"
	g_return_if_fail (self != NULL);
#line 259 "test.vala"
	_tmp0_ = g_strdup ("in");
#line 259 "test.vala"
	_tmp1_ = g_strdup ("out");
#line 259 "test.vala"
	_tmp2_ = g_strdup ("nonexistent.txt");
#line 259 "test.vala"
	_tmp3_ = g_new0 (gchar*, 3 + 1);
#line 259 "test.vala"
	_tmp3_[0] = _tmp0_;
#line 259 "test.vala"
	_tmp3_[1] = _tmp1_;
#line 259 "test.vala"
	_tmp3_[2] = _tmp2_;
#line 259 "test.vala"
	_tmp4_ = _tmp3_;
#line 259 "test.vala"
	_tmp4__length1 = 3;
#line 259 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp4_, (gint) 3, 0, &_tmp5_);
#line 259 "test.vala"
	_tmp6_ = _tmp5_;
#line 259 "test.vala"
	_tmp4_ = (_vala_array_free (_tmp4_, _tmp4__length1, (GDestroyNotify) g_free), NULL);
#line 259 "test.vala"
	output = _tmp6_;
#line 260 "test.vala"
	_tmp7_ = output;
#line 260 "test.vala"
	_tmp8_ = _tmp7_.std_err;
#line 260 "test.vala"
	g_assert_true (string_contains (_tmp8_, "skipping nonexistent.txt: "));
#line 258 "test.vala"
	output_destroy (&output);
#line 3295 "test.c"
}

static void
no_file_tests_test_nonexistent_patterns_file (NoFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	Output _tmp8_;
	const gchar* _tmp9_;
#line 263 "test.vala"
	g_return_if_fail (self != NULL);
#line 264 "test.vala"
	_tmp0_ = g_strdup ("--files");
#line 264 "test.vala"
	_tmp1_ = g_strdup ("in");
#line 264 "test.vala"
	_tmp2_ = g_strdup ("out");
#line 264 "test.vala"
	_tmp3_ = g_strdup ("nonexistent.txt");
#line 264 "test.vala"
	_tmp4_ = g_new0 (gchar*, 4 + 1);
#line 264 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 264 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 264 "test.vala"
	_tmp4_[2] = _tmp2_;
#line 264 "test.vala"
	_tmp4_[3] = _tmp3_;
#line 264 "test.vala"
	_tmp5_ = _tmp4_;
#line 264 "test.vala"
	_tmp5__length1 = 4;
#line 264 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 4, 1, &_tmp6_);
#line 264 "test.vala"
	_tmp7_ = _tmp6_;
#line 264 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 264 "test.vala"
	output = _tmp7_;
#line 265 "test.vala"
	_tmp8_ = output;
#line 265 "test.vala"
	_tmp9_ = _tmp8_.std_err;
#line 265 "test.vala"
	g_assert_true (string_contains (_tmp9_, "error reading pattern file"));
#line 263 "test.vala"
	output_destroy (&output);
#line 3353 "test.c"
}

static void
no_file_tests_test_input_is_directory (NoFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	Output _tmp8_;
	const gchar* _tmp9_;
#line 268 "test.vala"
	g_return_if_fail (self != NULL);
#line 269 "test.vala"
	_tmp0_ = g_strdup ("amét");
#line 269 "test.vala"
	_tmp1_ = g_strdup ("amèt");
#line 269 "test.vala"
	_tmp2_ = ((TestRpl*) self)->test_result_dir;
#line 269 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 269 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 269 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 269 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 269 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 269 "test.vala"
	_tmp5_ = _tmp4_;
#line 269 "test.vala"
	_tmp5__length1 = 3;
#line 269 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 269 "test.vala"
	_tmp7_ = _tmp6_;
#line 269 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 269 "test.vala"
	output = _tmp7_;
#line 270 "test.vala"
	_tmp8_ = output;
#line 270 "test.vala"
	_tmp9_ = _tmp8_.std_err;
#line 270 "test.vala"
	g_assert_true (string_contains (_tmp9_, "skipping directory"));
#line 268 "test.vala"
	output_destroy (&output);
#line 3409 "test.c"
}

static void
no_file_tests_class_init (NoFileTestsClass * klass,
                          gpointer klass_data)
{
#line 217 "test.vala"
	no_file_tests_parent_class = g_type_class_peek_parent (klass);
#line 3418 "test.c"
}

static void
no_file_tests_instance_init (NoFileTests * self,
                             gpointer klass)
{
}

static GType
no_file_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (NoFileTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) no_file_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NoFileTests), 0, (GInstanceInitFunc) no_file_tests_instance_init, NULL };
	GType no_file_tests_type_id;
	no_file_tests_type_id = g_type_register_static (TYPE_TEST_RPL, "NoFileTests", &g_define_type_info, 0);
	return no_file_tests_type_id;
}

GType
no_file_tests_get_type (void)
{
	static volatile gsize no_file_tests_type_id__once = 0;
	if (g_once_init_enter (&no_file_tests_type_id__once)) {
		GType no_file_tests_type_id;
		no_file_tests_type_id = no_file_tests_get_type_once ();
		g_once_init_leave (&no_file_tests_type_id__once, no_file_tests_type_id);
	}
	return no_file_tests_type_id__once;
}

static void
_output_file_tests_test_a_star_b_empty_input_gee_test_case_test_method (gpointer self)
{
#line 282 "test.vala"
	output_file_tests_test_a_star_b_empty_input ((OutputFileTests*) self);
#line 3453 "test.c"
}

static void
_output_file_tests_test_a_star_b_input_x_gee_test_case_test_method (gpointer self)
{
#line 283 "test.vala"
	output_file_tests_test_a_star_b_input_x ((OutputFileTests*) self);
#line 3461 "test.c"
}

static void
_output_file_tests_test_a_star_b_input_aaa_gee_test_case_test_method (gpointer self)
{
#line 284 "test.vala"
	output_file_tests_test_a_star_b_input_aaa ((OutputFileTests*) self);
#line 3469 "test.c"
}

static void
_output_file_tests_test_a_star_b_input_aaax_gee_test_case_test_method (gpointer self)
{
#line 285 "test.vala"
	output_file_tests_test_a_star_b_input_aaax ((OutputFileTests*) self);
#line 3477 "test.c"
}

static void
_output_file_tests_test_a_star_b_input_xaaa_gee_test_case_test_method (gpointer self)
{
#line 286 "test.vala"
	output_file_tests_test_a_star_b_input_xaaa ((OutputFileTests*) self);
#line 3485 "test.c"
}

static void
_output_file_tests_test_a_star_b_input_xaaax_gee_test_case_test_method (gpointer self)
{
#line 287 "test.vala"
	output_file_tests_test_a_star_b_input_xaaax ((OutputFileTests*) self);
#line 3493 "test.c"
}

static void
_output_file_tests_test_a_star_b_input_aaaxaaa_gee_test_case_test_method (gpointer self)
{
#line 288 "test.vala"
	output_file_tests_test_a_star_b_input_aaaxaaa ((OutputFileTests*) self);
#line 3501 "test.c"
}

static void
_output_file_tests_test_a_star_b_input_aaaxxaaa_gee_test_case_test_method (gpointer self)
{
#line 289 "test.vala"
	output_file_tests_test_a_star_b_input_aaaxxaaa ((OutputFileTests*) self);
#line 3509 "test.c"
}

static void
_output_file_tests_test_multi_buffer_matches_partial_match_at_end_gee_test_case_test_method (gpointer self)
{
#line 292 "test.vala"
	output_file_tests_test_multi_buffer_matches_partial_match_at_end ((OutputFileTests*) self);
#line 3517 "test.c"
}

static void
_output_file_tests_test_multi_buffer_matches_partial_empty_match_at_end_gee_test_case_test_method (gpointer self)
{
#line 293 "test.vala"
	output_file_tests_test_multi_buffer_matches_partial_empty_match_at_end ((OutputFileTests*) self);
#line 3525 "test.c"
}

static void
_output_file_tests_test_multi_buffer_matches_complete_match_at_end_gee_test_case_test_method (gpointer self)
{
#line 294 "test.vala"
	output_file_tests_test_multi_buffer_matches_complete_match_at_end ((OutputFileTests*) self);
#line 3533 "test.c"
}

static void
_output_file_tests_test_multi_buffer_matches_complete_empty_match_at_end_gee_test_case_test_method (gpointer self)
{
#line 295 "test.vala"
	output_file_tests_test_multi_buffer_matches_complete_empty_match_at_end ((OutputFileTests*) self);
#line 3541 "test.c"
}

static void
_output_file_tests_test_multi_buffer_lookbehind_gee_test_case_test_method (gpointer self)
{
#line 296 "test.vala"
	output_file_tests_test_multi_buffer_lookbehind ((OutputFileTests*) self);
#line 3549 "test.c"
}

static void
_output_file_tests_test_lookbehind_word_boundary_gee_test_case_test_method (gpointer self)
{
#line 297 "test.vala"
	output_file_tests_test_lookbehind_word_boundary ((OutputFileTests*) self);
#line 3557 "test.c"
}

static void
_output_file_tests_test_lookbehind_with_NULs_gee_test_case_test_method (gpointer self)
{
#line 298 "test.vala"
	output_file_tests_test_lookbehind_with_NULs ((OutputFileTests*) self);
#line 3565 "test.c"
}

static void
_output_file_tests_test_buffer_crossing_character_gee_test_case_test_method (gpointer self)
{
#line 299 "test.vala"
	output_file_tests_test_buffer_crossing_character ((OutputFileTests*) self);
#line 3573 "test.c"
}

static void
_output_file_tests_test_empty_match_at_buffer_end_gee_test_case_test_method (gpointer self)
{
#line 300 "test.vala"
	output_file_tests_test_empty_match_at_buffer_end ((OutputFileTests*) self);
#line 3581 "test.c"
}

static void
_output_file_tests_test_recursive_no_file_arguments_gee_test_case_test_method (gpointer self)
{
#line 301 "test.vala"
	output_file_tests_test_recursive_no_file_arguments ((OutputFileTests*) self);
#line 3589 "test.c"
}

static void
_output_file_tests_test_bad_regex_gee_test_case_test_method (gpointer self)
{
#line 302 "test.vala"
	output_file_tests_test_bad_regex ((OutputFileTests*) self);
#line 3597 "test.c"
}

static void
_output_file_tests_test_non_file_input_gee_test_case_test_method (gpointer self)
{
#line 303 "test.vala"
	output_file_tests_test_non_file_input ((OutputFileTests*) self);
#line 3605 "test.c"
}

OutputFileTests*
output_file_tests_construct (GType object_type,
                             const gchar* bin_dir,
                             const gchar* test_files_dir)
{
	OutputFileTests * self = NULL;
#line 279 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 279 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 280 "test.vala"
	self = (OutputFileTests*) test_rpl_output_file_construct (object_type, bin_dir, test_files_dir);
#line 282 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_empty_input", _output_file_tests_test_a_star_b_empty_input_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 283 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_input_x", _output_file_tests_test_a_star_b_input_x_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 284 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_input_aaa", _output_file_tests_test_a_star_b_input_aaa_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 285 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_input_aaax", _output_file_tests_test_a_star_b_input_aaax_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 286 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_input_xaaa", _output_file_tests_test_a_star_b_input_xaaa_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 287 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_input_xaaax", _output_file_tests_test_a_star_b_input_xaaax_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 288 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_input_aaaxaaa", _output_file_tests_test_a_star_b_input_aaaxaaa_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 289 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_a_star_b_input_aaaxxaaa", _output_file_tests_test_a_star_b_input_aaaxxaaa_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 292 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_multi_buffer_matches_partial_match_at_end", _output_file_tests_test_multi_buffer_matches_partial_match_at_end_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 293 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_multi_buffer_matches_partial_empty_match_at_end", _output_file_tests_test_multi_buffer_matches_partial_empty_match_at_end_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 294 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_multi_buffer_matches_complete_match_at_end", _output_file_tests_test_multi_buffer_matches_complete_match_at_end_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 295 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_multi_buffer_matches_complete_empty_match_at_end", _output_file_tests_test_multi_buffer_matches_complete_empty_match_at_end_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 296 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_multi_buffer_lookbehind", _output_file_tests_test_multi_buffer_lookbehind_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 297 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_lookbehind_word_boundary", _output_file_tests_test_lookbehind_word_boundary_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 298 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_lookbehind_with_NULs", _output_file_tests_test_lookbehind_with_NULs_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 299 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_buffer_crossing_character", _output_file_tests_test_buffer_crossing_character_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 300 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_empty_match_at_buffer_end", _output_file_tests_test_empty_match_at_buffer_end_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 301 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_recursive_no_file_arguments", _output_file_tests_test_recursive_no_file_arguments_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 302 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_bad_regex", _output_file_tests_test_bad_regex_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 303 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_non_file_input", _output_file_tests_test_non_file_input_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 279 "test.vala"
	return self;
#line 3662 "test.c"
}

OutputFileTests*
output_file_tests_new (const gchar* bin_dir,
                       const gchar* test_files_dir)
{
#line 279 "test.vala"
	return output_file_tests_construct (TYPE_OUTPUT_FILE_TESTS, bin_dir, test_files_dir);
#line 3671 "test.c"
}

static guint8*
string_get_data (const gchar* self,
                 gint* result_length1)
{
	guint8* result;
	guint8* res = NULL;
	gint res_length1;
	gint _res_size_;
	gint _tmp0_;
	gint _tmp1_;
	guint8* _tmp2_;
	gint _tmp2__length1;
#line 1609 "glib-2.0.vapi"
	g_return_val_if_fail (self != NULL, NULL);
#line 1610 "glib-2.0.vapi"
	res = (guint8*) self;
#line 1610 "glib-2.0.vapi"
	res_length1 = -1;
#line 1610 "glib-2.0.vapi"
	_res_size_ = res_length1;
#line 1611 "glib-2.0.vapi"
	_tmp0_ = strlen (self);
#line 1611 "glib-2.0.vapi"
	_tmp1_ = _tmp0_;
#line 1611 "glib-2.0.vapi"
	res_length1 = (gint) _tmp1_;
#line 1612 "glib-2.0.vapi"
	_tmp2_ = res;
#line 1612 "glib-2.0.vapi"
	_tmp2__length1 = res_length1;
#line 1612 "glib-2.0.vapi"
	if (result_length1) {
#line 1612 "glib-2.0.vapi"
		*result_length1 = _tmp2__length1;
#line 3708 "test.c"
	}
#line 1612 "glib-2.0.vapi"
	result = _tmp2_;
#line 1612 "glib-2.0.vapi"
	return result;
#line 3714 "test.c"
}

static void
output_file_tests_test_a_star_b_empty_input (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 306 "test.vala"
	g_return_if_fail (self != NULL);
#line 307 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 307 "test.vala"
	_tmp1_ = string_get_data ("", &_tmp2_);
#line 307 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 307 "test.vala"
	_tmp3_ = _tmp1_;
#line 307 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 307 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 308 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 308 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 308 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 308 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 308 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 308 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 308 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 308 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 308 "test.vala"
	_tmp9_ = _tmp8_;
#line 308 "test.vala"
	_tmp9__length1 = 3;
#line 308 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 308 "test.vala"
	_tmp11_ = _tmp10_;
#line 308 "test.vala"
	output_destroy (&_tmp11_);
#line 308 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 309 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "b", (gsize) -1));
#line 3779 "test.c"
}

static void
output_file_tests_test_a_star_b_input_x (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 312 "test.vala"
	g_return_if_fail (self != NULL);
#line 313 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 313 "test.vala"
	_tmp1_ = string_get_data ("x", &_tmp2_);
#line 313 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 313 "test.vala"
	_tmp3_ = _tmp1_;
#line 313 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 313 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 314 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 314 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 314 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 314 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 314 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 314 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 314 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 314 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 314 "test.vala"
	_tmp9_ = _tmp8_;
#line 314 "test.vala"
	_tmp9__length1 = 3;
#line 314 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 314 "test.vala"
	_tmp11_ = _tmp10_;
#line 314 "test.vala"
	output_destroy (&_tmp11_);
#line 314 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 315 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bxb", (gsize) -1));
#line 3844 "test.c"
}

static void
output_file_tests_test_a_star_b_input_aaa (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 318 "test.vala"
	g_return_if_fail (self != NULL);
#line 319 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 319 "test.vala"
	_tmp1_ = string_get_data ("aaa", &_tmp2_);
#line 319 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 319 "test.vala"
	_tmp3_ = _tmp1_;
#line 319 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 319 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 320 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 320 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 320 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 320 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 320 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 320 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 320 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 320 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 320 "test.vala"
	_tmp9_ = _tmp8_;
#line 320 "test.vala"
	_tmp9__length1 = 3;
#line 320 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 320 "test.vala"
	_tmp11_ = _tmp10_;
#line 320 "test.vala"
	output_destroy (&_tmp11_);
#line 320 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 321 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bb", (gsize) -1));
#line 3909 "test.c"
}

static void
output_file_tests_test_a_star_b_input_aaax (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 324 "test.vala"
	g_return_if_fail (self != NULL);
#line 325 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 325 "test.vala"
	_tmp1_ = string_get_data ("aaax", &_tmp2_);
#line 325 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 325 "test.vala"
	_tmp3_ = _tmp1_;
#line 325 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 325 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 326 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 326 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 326 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 326 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 326 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 326 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 326 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 326 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 326 "test.vala"
	_tmp9_ = _tmp8_;
#line 326 "test.vala"
	_tmp9__length1 = 3;
#line 326 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 326 "test.vala"
	_tmp11_ = _tmp10_;
#line 326 "test.vala"
	output_destroy (&_tmp11_);
#line 326 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 327 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bbxb", (gsize) -1));
#line 3974 "test.c"
}

static void
output_file_tests_test_a_star_b_input_xaaa (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 330 "test.vala"
	g_return_if_fail (self != NULL);
#line 331 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 331 "test.vala"
	_tmp1_ = string_get_data ("xaaa", &_tmp2_);
#line 331 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 331 "test.vala"
	_tmp3_ = _tmp1_;
#line 331 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 331 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 332 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 332 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 332 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 332 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 332 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 332 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 332 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 332 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 332 "test.vala"
	_tmp9_ = _tmp8_;
#line 332 "test.vala"
	_tmp9__length1 = 3;
#line 332 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 332 "test.vala"
	_tmp11_ = _tmp10_;
#line 332 "test.vala"
	output_destroy (&_tmp11_);
#line 332 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 333 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bxbb", (gsize) -1));
#line 4039 "test.c"
}

static void
output_file_tests_test_a_star_b_input_xaaax (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 336 "test.vala"
	g_return_if_fail (self != NULL);
#line 337 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 337 "test.vala"
	_tmp1_ = string_get_data ("xaaax", &_tmp2_);
#line 337 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 337 "test.vala"
	_tmp3_ = _tmp1_;
#line 337 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 337 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 338 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 338 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 338 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 338 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 338 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 338 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 338 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 338 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 338 "test.vala"
	_tmp9_ = _tmp8_;
#line 338 "test.vala"
	_tmp9__length1 = 3;
#line 338 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 338 "test.vala"
	_tmp11_ = _tmp10_;
#line 338 "test.vala"
	output_destroy (&_tmp11_);
#line 338 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 339 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bxbbxb", (gsize) -1));
#line 4104 "test.c"
}

static void
output_file_tests_test_a_star_b_input_aaaxaaa (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 342 "test.vala"
	g_return_if_fail (self != NULL);
#line 343 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 343 "test.vala"
	_tmp1_ = string_get_data ("aaaxaaa", &_tmp2_);
#line 343 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 343 "test.vala"
	_tmp3_ = _tmp1_;
#line 343 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 343 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 344 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 344 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 344 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 344 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 344 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 344 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 344 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 344 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 344 "test.vala"
	_tmp9_ = _tmp8_;
#line 344 "test.vala"
	_tmp9__length1 = 3;
#line 344 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 344 "test.vala"
	_tmp11_ = _tmp10_;
#line 344 "test.vala"
	output_destroy (&_tmp11_);
#line 344 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 345 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bbxbb", (gsize) -1));
#line 4169 "test.c"
}

static void
output_file_tests_test_a_star_b_input_aaaxxaaa (OutputFileTests* self)
{
	const gchar* _tmp0_;
	guint8* _tmp1_;
	gint _tmp1__length1;
	gint _tmp2_ = 0;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gchar* _tmp4_;
	gchar* _tmp5_;
	const gchar* _tmp6_;
	gchar* _tmp7_;
	gchar** _tmp8_;
	gchar** _tmp9_;
	gint _tmp9__length1;
	Output _tmp10_ = {0};
	Output _tmp11_;
#line 348 "test.vala"
	g_return_if_fail (self != NULL);
#line 349 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 349 "test.vala"
	_tmp1_ = string_get_data ("aaaxxaaa", &_tmp2_);
#line 349 "test.vala"
	_tmp1__length1 = _tmp2_;
#line 349 "test.vala"
	_tmp3_ = _tmp1_;
#line 349 "test.vala"
	_tmp3__length1 = _tmp1__length1;
#line 349 "test.vala"
	buffer_to_file (_tmp0_, _tmp3_, (gint) _tmp3__length1);
#line 350 "test.vala"
	_tmp4_ = g_strdup ("a*");
#line 350 "test.vala"
	_tmp5_ = g_strdup ("b");
#line 350 "test.vala"
	_tmp6_ = ((TestRplOutputFile*) self)->test_result_root;
#line 350 "test.vala"
	_tmp7_ = g_strdup (_tmp6_);
#line 350 "test.vala"
	_tmp8_ = g_new0 (gchar*, 3 + 1);
#line 350 "test.vala"
	_tmp8_[0] = _tmp4_;
#line 350 "test.vala"
	_tmp8_[1] = _tmp5_;
#line 350 "test.vala"
	_tmp8_[2] = _tmp7_;
#line 350 "test.vala"
	_tmp9_ = _tmp8_;
#line 350 "test.vala"
	_tmp9__length1 = 3;
#line 350 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp9_, (gint) 3, 0, &_tmp10_);
#line 350 "test.vala"
	_tmp11_ = _tmp10_;
#line 350 "test.vala"
	output_destroy (&_tmp11_);
#line 350 "test.vala"
	_tmp9_ = (_vala_array_free (_tmp9_, _tmp9__length1, (GDestroyNotify) g_free), NULL);
#line 351 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bbxbxbb", (gsize) -1));
#line 4234 "test.c"
}

static void
output_file_tests_test_multi_buffer_matches_partial_match_at_end (OutputFileTests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gint _tmp4_ = 0;
	guint8* _tmp5_;
	gint _tmp5__length1;
	gchar* _tmp6_;
	gchar* _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar** _tmp10_;
	gchar** _tmp11_;
	gint _tmp11__length1;
	Output _tmp12_ = {0};
	Output _tmp13_;
#line 354 "test.vala"
	g_return_if_fail (self != NULL);
#line 355 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 355 "test.vala"
	_tmp1_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'a');
#line 355 "test.vala"
	_tmp2_ = _tmp1_;
#line 355 "test.vala"
	_tmp3_ = string_get_data (_tmp2_, &_tmp4_);
#line 355 "test.vala"
	_tmp3__length1 = _tmp4_;
#line 355 "test.vala"
	_tmp5_ = _tmp3_;
#line 355 "test.vala"
	_tmp5__length1 = _tmp3__length1;
#line 355 "test.vala"
	buffer_to_file (_tmp0_, _tmp5_, (gint) _tmp5__length1);
#line 355 "test.vala"
	_g_free0 (_tmp2_);
#line 356 "test.vala"
	_tmp6_ = g_strdup ("a+");
#line 356 "test.vala"
	_tmp7_ = g_strdup ("b");
#line 356 "test.vala"
	_tmp8_ = ((TestRplOutputFile*) self)->test_result_root;
#line 356 "test.vala"
	_tmp9_ = g_strdup (_tmp8_);
#line 356 "test.vala"
	_tmp10_ = g_new0 (gchar*, 3 + 1);
#line 356 "test.vala"
	_tmp10_[0] = _tmp6_;
#line 356 "test.vala"
	_tmp10_[1] = _tmp7_;
#line 356 "test.vala"
	_tmp10_[2] = _tmp9_;
#line 356 "test.vala"
	_tmp11_ = _tmp10_;
#line 356 "test.vala"
	_tmp11__length1 = 3;
#line 356 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp11_, (gint) 3, 0, &_tmp12_);
#line 356 "test.vala"
	_tmp13_ = _tmp12_;
#line 356 "test.vala"
	output_destroy (&_tmp13_);
#line 356 "test.vala"
	_tmp11_ = (_vala_array_free (_tmp11_, _tmp11__length1, (GDestroyNotify) g_free), NULL);
#line 357 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "b", (gsize) -1));
#line 4307 "test.c"
}

static void
output_file_tests_test_multi_buffer_matches_partial_empty_match_at_end (OutputFileTests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gint _tmp4_ = 0;
	guint8* _tmp5_;
	gint _tmp5__length1;
	gchar* _tmp6_;
	gchar* _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar** _tmp10_;
	gchar** _tmp11_;
	gint _tmp11__length1;
	Output _tmp12_ = {0};
	Output _tmp13_;
#line 360 "test.vala"
	g_return_if_fail (self != NULL);
#line 361 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 361 "test.vala"
	_tmp1_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'a');
#line 361 "test.vala"
	_tmp2_ = _tmp1_;
#line 361 "test.vala"
	_tmp3_ = string_get_data (_tmp2_, &_tmp4_);
#line 361 "test.vala"
	_tmp3__length1 = _tmp4_;
#line 361 "test.vala"
	_tmp5_ = _tmp3_;
#line 361 "test.vala"
	_tmp5__length1 = _tmp3__length1;
#line 361 "test.vala"
	buffer_to_file (_tmp0_, _tmp5_, (gint) _tmp5__length1);
#line 361 "test.vala"
	_g_free0 (_tmp2_);
#line 362 "test.vala"
	_tmp6_ = g_strdup ("a*");
#line 362 "test.vala"
	_tmp7_ = g_strdup ("b");
#line 362 "test.vala"
	_tmp8_ = ((TestRplOutputFile*) self)->test_result_root;
#line 362 "test.vala"
	_tmp9_ = g_strdup (_tmp8_);
#line 362 "test.vala"
	_tmp10_ = g_new0 (gchar*, 3 + 1);
#line 362 "test.vala"
	_tmp10_[0] = _tmp6_;
#line 362 "test.vala"
	_tmp10_[1] = _tmp7_;
#line 362 "test.vala"
	_tmp10_[2] = _tmp9_;
#line 362 "test.vala"
	_tmp11_ = _tmp10_;
#line 362 "test.vala"
	_tmp11__length1 = 3;
#line 362 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp11_, (gint) 3, 0, &_tmp12_);
#line 362 "test.vala"
	_tmp13_ = _tmp12_;
#line 362 "test.vala"
	output_destroy (&_tmp13_);
#line 362 "test.vala"
	_tmp11_ = (_vala_array_free (_tmp11_, _tmp11__length1, (GDestroyNotify) g_free), NULL);
#line 363 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, "bb", (gsize) -1));
#line 4380 "test.c"
}

static void
output_file_tests_test_multi_buffer_matches_complete_match_at_end (OutputFileTests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gint _tmp4_ = 0;
	guint8* _tmp5_;
	gint _tmp5__length1;
	gchar* _tmp6_;
	gchar* _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar** _tmp10_;
	gchar** _tmp11_;
	gint _tmp11__length1;
	Output _tmp12_ = {0};
	Output _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
#line 366 "test.vala"
	g_return_if_fail (self != NULL);
#line 367 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 367 "test.vala"
	_tmp1_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'a');
#line 367 "test.vala"
	_tmp2_ = _tmp1_;
#line 367 "test.vala"
	_tmp3_ = string_get_data (_tmp2_, &_tmp4_);
#line 367 "test.vala"
	_tmp3__length1 = _tmp4_;
#line 367 "test.vala"
	_tmp5_ = _tmp3_;
#line 367 "test.vala"
	_tmp5__length1 = _tmp3__length1;
#line 367 "test.vala"
	buffer_to_file (_tmp0_, _tmp5_, (gint) _tmp5__length1);
#line 367 "test.vala"
	_g_free0 (_tmp2_);
#line 368 "test.vala"
	_tmp6_ = g_strdup ("a");
#line 368 "test.vala"
	_tmp7_ = g_strdup ("b");
#line 368 "test.vala"
	_tmp8_ = ((TestRplOutputFile*) self)->test_result_root;
#line 368 "test.vala"
	_tmp9_ = g_strdup (_tmp8_);
#line 368 "test.vala"
	_tmp10_ = g_new0 (gchar*, 3 + 1);
#line 368 "test.vala"
	_tmp10_[0] = _tmp6_;
#line 368 "test.vala"
	_tmp10_[1] = _tmp7_;
#line 368 "test.vala"
	_tmp10_[2] = _tmp9_;
#line 368 "test.vala"
	_tmp11_ = _tmp10_;
#line 368 "test.vala"
	_tmp11__length1 = 3;
#line 368 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp11_, (gint) 3, 0, &_tmp12_);
#line 368 "test.vala"
	_tmp13_ = _tmp12_;
#line 368 "test.vala"
	output_destroy (&_tmp13_);
#line 368 "test.vala"
	_tmp11_ = (_vala_array_free (_tmp11_, _tmp11__length1, (GDestroyNotify) g_free), NULL);
#line 369 "test.vala"
	_tmp14_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'b');
#line 369 "test.vala"
	_tmp15_ = _tmp14_;
#line 369 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, _tmp15_, (gsize) -1));
#line 369 "test.vala"
	_g_free0 (_tmp15_);
#line 4461 "test.c"
}

static void
output_file_tests_test_multi_buffer_matches_complete_empty_match_at_end (OutputFileTests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gint _tmp4_ = 0;
	guint8* _tmp5_;
	gint _tmp5__length1;
	gchar* _tmp6_;
	gchar* _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar** _tmp10_;
	gchar** _tmp11_;
	gint _tmp11__length1;
	Output _tmp12_ = {0};
	Output _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
#line 372 "test.vala"
	g_return_if_fail (self != NULL);
#line 373 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 373 "test.vala"
	_tmp1_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'a');
#line 373 "test.vala"
	_tmp2_ = _tmp1_;
#line 373 "test.vala"
	_tmp3_ = string_get_data (_tmp2_, &_tmp4_);
#line 373 "test.vala"
	_tmp3__length1 = _tmp4_;
#line 373 "test.vala"
	_tmp5_ = _tmp3_;
#line 373 "test.vala"
	_tmp5__length1 = _tmp3__length1;
#line 373 "test.vala"
	buffer_to_file (_tmp0_, _tmp5_, (gint) _tmp5__length1);
#line 373 "test.vala"
	_g_free0 (_tmp2_);
#line 374 "test.vala"
	_tmp6_ = g_strdup ("a|$");
#line 374 "test.vala"
	_tmp7_ = g_strdup ("b");
#line 374 "test.vala"
	_tmp8_ = ((TestRplOutputFile*) self)->test_result_root;
#line 374 "test.vala"
	_tmp9_ = g_strdup (_tmp8_);
#line 374 "test.vala"
	_tmp10_ = g_new0 (gchar*, 3 + 1);
#line 374 "test.vala"
	_tmp10_[0] = _tmp6_;
#line 374 "test.vala"
	_tmp10_[1] = _tmp7_;
#line 374 "test.vala"
	_tmp10_[2] = _tmp9_;
#line 374 "test.vala"
	_tmp11_ = _tmp10_;
#line 374 "test.vala"
	_tmp11__length1 = 3;
#line 374 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp11_, (gint) 3, 0, &_tmp12_);
#line 374 "test.vala"
	_tmp13_ = _tmp12_;
#line 374 "test.vala"
	output_destroy (&_tmp13_);
#line 374 "test.vala"
	_tmp11_ = (_vala_array_free (_tmp11_, _tmp11__length1, (GDestroyNotify) g_free), NULL);
#line 375 "test.vala"
	_tmp14_ = g_strnfill ((gsize) (OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES + 1), 'b');
#line 375 "test.vala"
	_tmp15_ = _tmp14_;
#line 375 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, _tmp15_, (gsize) -1));
#line 375 "test.vala"
	_g_free0 (_tmp15_);
#line 4542 "test.c"
}

static void
output_file_tests_test_multi_buffer_lookbehind (OutputFileTests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gint _tmp4_ = 0;
	guint8* _tmp5_;
	gint _tmp5__length1;
	GString* expected = NULL;
	GString* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	const gchar* _tmp11_;
	gchar* _tmp12_;
	gchar** _tmp13_;
	gchar** _tmp14_;
	gint _tmp14__length1;
	Output _tmp15_ = {0};
	Output _tmp16_;
	const gchar* _tmp17_;
#line 378 "test.vala"
	g_return_if_fail (self != NULL);
#line 379 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 379 "test.vala"
	_tmp1_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'a');
#line 379 "test.vala"
	_tmp2_ = _tmp1_;
#line 379 "test.vala"
	_tmp3_ = string_get_data (_tmp2_, &_tmp4_);
#line 379 "test.vala"
	_tmp3__length1 = _tmp4_;
#line 379 "test.vala"
	_tmp5_ = _tmp3_;
#line 379 "test.vala"
	_tmp5__length1 = _tmp3__length1;
#line 379 "test.vala"
	buffer_to_file (_tmp0_, _tmp5_, (gint) _tmp5__length1);
#line 379 "test.vala"
	_g_free0 (_tmp2_);
#line 380 "test.vala"
	_tmp6_ = g_string_new ("b");
#line 380 "test.vala"
	expected = _tmp6_;
#line 381 "test.vala"
	_tmp7_ = g_strnfill ((gsize) (OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES - 1), 'a');
#line 381 "test.vala"
	_tmp8_ = _tmp7_;
#line 381 "test.vala"
	g_string_append (expected, _tmp8_);
#line 381 "test.vala"
	_g_free0 (_tmp8_);
#line 382 "test.vala"
	_tmp9_ = g_strdup ("(?<!a)a");
#line 382 "test.vala"
	_tmp10_ = g_strdup ("b");
#line 382 "test.vala"
	_tmp11_ = ((TestRplOutputFile*) self)->test_result_root;
#line 382 "test.vala"
	_tmp12_ = g_strdup (_tmp11_);
#line 382 "test.vala"
	_tmp13_ = g_new0 (gchar*, 3 + 1);
#line 382 "test.vala"
	_tmp13_[0] = _tmp9_;
#line 382 "test.vala"
	_tmp13_[1] = _tmp10_;
#line 382 "test.vala"
	_tmp13_[2] = _tmp12_;
#line 382 "test.vala"
	_tmp14_ = _tmp13_;
#line 382 "test.vala"
	_tmp14__length1 = 3;
#line 382 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp14_, (gint) 3, 0, &_tmp15_);
#line 382 "test.vala"
	_tmp16_ = _tmp15_;
#line 382 "test.vala"
	output_destroy (&_tmp16_);
#line 382 "test.vala"
	_tmp14_ = (_vala_array_free (_tmp14_, _tmp14__length1, (GDestroyNotify) g_free), NULL);
#line 383 "test.vala"
	_tmp17_ = expected->str;
#line 383 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, _tmp17_, (gsize) -1));
#line 378 "test.vala"
	_g_string_free0 (expected);
#line 4636 "test.c"
}

static guint8*
g_string_get_data (GString* self,
                   gint* result_length1)
{
	guint8* result;
	guint8* res = NULL;
	const gchar* _tmp0_;
	gint res_length1;
	gint _res_size_;
	guint8* _tmp1_;
	gint _tmp1__length1;
#line 5825 "glib-2.0.vapi"
	g_return_val_if_fail (self != NULL, NULL);
#line 5826 "glib-2.0.vapi"
	_tmp0_ = self->str;
#line 5826 "glib-2.0.vapi"
	res = (guint8*) _tmp0_;
#line 5826 "glib-2.0.vapi"
	res_length1 = -1;
#line 5826 "glib-2.0.vapi"
	_res_size_ = res_length1;
#line 5827 "glib-2.0.vapi"
	res_length1 = (gint) self->len;
#line 5828 "glib-2.0.vapi"
	_tmp1_ = res;
#line 5828 "glib-2.0.vapi"
	_tmp1__length1 = res_length1;
#line 5828 "glib-2.0.vapi"
	if (result_length1) {
#line 5828 "glib-2.0.vapi"
		*result_length1 = _tmp1__length1;
#line 4670 "test.c"
	}
#line 5828 "glib-2.0.vapi"
	result = _tmp1_;
#line 5828 "glib-2.0.vapi"
	return result;
#line 4676 "test.c"
}

static void
output_file_tests_test_lookbehind_with_NULs (OutputFileTests* self)
{
	GString* s = NULL;
	GString* _tmp0_;
	const gchar* _tmp5_;
	GString* _tmp6_;
	guint8* _tmp7_;
	gint _tmp7__length1;
	gint _tmp8_ = 0;
	guint8* _tmp9_;
	gint _tmp9__length1;
	GString* expected = NULL;
	GString* _tmp10_;
	gchar* _tmp15_;
	gchar* _tmp16_;
	const gchar* _tmp17_;
	gchar* _tmp18_;
	gchar** _tmp19_;
	gchar** _tmp20_;
	gint _tmp20__length1;
	Output _tmp21_ = {0};
	Output _tmp22_;
	GString* _tmp23_;
	const gchar* _tmp24_;
	GString* _tmp25_;
#line 386 "test.vala"
	g_return_if_fail (self != NULL);
#line 387 "test.vala"
	_tmp0_ = g_string_new ("");
#line 387 "test.vala"
	s = _tmp0_;
#line 4711 "test.c"
	{
		gint i = 0;
#line 388 "test.vala"
		i = 0;
#line 4716 "test.c"
		{
			gboolean _tmp1_ = FALSE;
#line 388 "test.vala"
			_tmp1_ = TRUE;
#line 388 "test.vala"
			while (TRUE) {
#line 4723 "test.c"
				GString* _tmp3_;
				GString* _tmp4_;
#line 388 "test.vala"
				if (!_tmp1_) {
#line 4728 "test.c"
					gint _tmp2_;
#line 388 "test.vala"
					_tmp2_ = i;
#line 388 "test.vala"
					i = _tmp2_ + 1;
#line 4734 "test.c"
				}
#line 388 "test.vala"
				_tmp1_ = FALSE;
#line 388 "test.vala"
				if (!(i < OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES)) {
#line 388 "test.vala"
					break;
#line 4742 "test.c"
				}
#line 389 "test.vala"
				_tmp3_ = s;
#line 389 "test.vala"
				g_string_append_c (_tmp3_, 'a');
#line 390 "test.vala"
				_tmp4_ = s;
#line 390 "test.vala"
				g_string_append_c (_tmp4_, (gchar) 0);
#line 4752 "test.c"
			}
		}
	}
#line 392 "test.vala"
	_tmp5_ = ((TestRplOutputFile*) self)->test_result_root;
#line 392 "test.vala"
	_tmp6_ = s;
#line 392 "test.vala"
	_tmp7_ = g_string_get_data (_tmp6_, &_tmp8_);
#line 392 "test.vala"
	_tmp7__length1 = _tmp8_;
#line 392 "test.vala"
	_tmp9_ = _tmp7_;
#line 392 "test.vala"
	_tmp9__length1 = _tmp7__length1;
#line 392 "test.vala"
	buffer_to_file (_tmp5_, _tmp9_, (gint) _tmp9__length1);
#line 393 "test.vala"
	_tmp10_ = g_string_new ("");
#line 393 "test.vala"
	expected = _tmp10_;
#line 4774 "test.c"
	{
		gint i = 0;
#line 394 "test.vala"
		i = 0;
#line 4779 "test.c"
		{
			gboolean _tmp11_ = FALSE;
#line 394 "test.vala"
			_tmp11_ = TRUE;
#line 394 "test.vala"
			while (TRUE) {
#line 4786 "test.c"
				GString* _tmp13_;
				GString* _tmp14_;
#line 394 "test.vala"
				if (!_tmp11_) {
#line 4791 "test.c"
					gint _tmp12_;
#line 394 "test.vala"
					_tmp12_ = i;
#line 394 "test.vala"
					i = _tmp12_ + 1;
#line 4797 "test.c"
				}
#line 394 "test.vala"
				_tmp11_ = FALSE;
#line 394 "test.vala"
				if (!(i < OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES)) {
#line 394 "test.vala"
					break;
#line 4805 "test.c"
				}
#line 395 "test.vala"
				_tmp13_ = expected;
#line 395 "test.vala"
				g_string_append_c (_tmp13_, 'b');
#line 396 "test.vala"
				_tmp14_ = expected;
#line 396 "test.vala"
				g_string_append_c (_tmp14_, (gchar) 0);
#line 4815 "test.c"
			}
		}
	}
#line 398 "test.vala"
	_tmp15_ = g_strdup ("(?<!c)a");
#line 398 "test.vala"
	_tmp16_ = g_strdup ("b");
#line 398 "test.vala"
	_tmp17_ = ((TestRplOutputFile*) self)->test_result_root;
#line 398 "test.vala"
	_tmp18_ = g_strdup (_tmp17_);
#line 398 "test.vala"
	_tmp19_ = g_new0 (gchar*, 3 + 1);
#line 398 "test.vala"
	_tmp19_[0] = _tmp15_;
#line 398 "test.vala"
	_tmp19_[1] = _tmp16_;
#line 398 "test.vala"
	_tmp19_[2] = _tmp18_;
#line 398 "test.vala"
	_tmp20_ = _tmp19_;
#line 398 "test.vala"
	_tmp20__length1 = 3;
#line 398 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp20_, (gint) 3, 0, &_tmp21_);
#line 398 "test.vala"
	_tmp22_ = _tmp21_;
#line 398 "test.vala"
	output_destroy (&_tmp22_);
#line 398 "test.vala"
	_tmp20_ = (_vala_array_free (_tmp20_, _tmp20__length1, (GDestroyNotify) g_free), NULL);
#line 399 "test.vala"
	_tmp23_ = expected;
#line 399 "test.vala"
	_tmp24_ = _tmp23_->str;
#line 399 "test.vala"
	_tmp25_ = expected;
#line 399 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, _tmp24_, (gsize) _tmp25_->len));
#line 386 "test.vala"
	_g_string_free0 (expected);
#line 386 "test.vala"
	_g_string_free0 (s);
#line 4859 "test.c"
}

static void
output_file_tests_test_lookbehind_word_boundary (OutputFileTests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gint _tmp4_ = 0;
	guint8* _tmp5_;
	gint _tmp5__length1;
	GString* expected = NULL;
	GString* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	const gchar* _tmp11_;
	gchar* _tmp12_;
	gchar** _tmp13_;
	gchar** _tmp14_;
	gint _tmp14__length1;
	Output _tmp15_ = {0};
	Output _tmp16_;
	const gchar* _tmp17_;
#line 402 "test.vala"
	g_return_if_fail (self != NULL);
#line 403 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 403 "test.vala"
	_tmp1_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'a');
#line 403 "test.vala"
	_tmp2_ = _tmp1_;
#line 403 "test.vala"
	_tmp3_ = string_get_data (_tmp2_, &_tmp4_);
#line 403 "test.vala"
	_tmp3__length1 = _tmp4_;
#line 403 "test.vala"
	_tmp5_ = _tmp3_;
#line 403 "test.vala"
	_tmp5__length1 = _tmp3__length1;
#line 403 "test.vala"
	buffer_to_file (_tmp0_, _tmp5_, (gint) _tmp5__length1);
#line 403 "test.vala"
	_g_free0 (_tmp2_);
#line 404 "test.vala"
	_tmp6_ = g_string_new ("b");
#line 404 "test.vala"
	expected = _tmp6_;
#line 405 "test.vala"
	_tmp7_ = g_strnfill ((gsize) (OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES - 1), 'a');
#line 405 "test.vala"
	_tmp8_ = _tmp7_;
#line 405 "test.vala"
	g_string_append (expected, _tmp8_);
#line 405 "test.vala"
	_g_free0 (_tmp8_);
#line 406 "test.vala"
	_tmp9_ = g_strdup ("\\ba");
#line 406 "test.vala"
	_tmp10_ = g_strdup ("b");
#line 406 "test.vala"
	_tmp11_ = ((TestRplOutputFile*) self)->test_result_root;
#line 406 "test.vala"
	_tmp12_ = g_strdup (_tmp11_);
#line 406 "test.vala"
	_tmp13_ = g_new0 (gchar*, 3 + 1);
#line 406 "test.vala"
	_tmp13_[0] = _tmp9_;
#line 406 "test.vala"
	_tmp13_[1] = _tmp10_;
#line 406 "test.vala"
	_tmp13_[2] = _tmp12_;
#line 406 "test.vala"
	_tmp14_ = _tmp13_;
#line 406 "test.vala"
	_tmp14__length1 = 3;
#line 406 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp14_, (gint) 3, 0, &_tmp15_);
#line 406 "test.vala"
	_tmp16_ = _tmp15_;
#line 406 "test.vala"
	output_destroy (&_tmp16_);
#line 406 "test.vala"
	_tmp14_ = (_vala_array_free (_tmp14_, _tmp14__length1, (GDestroyNotify) g_free), NULL);
#line 407 "test.vala"
	_tmp17_ = expected->str;
#line 407 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, _tmp17_, (gsize) -1));
#line 402 "test.vala"
	_g_string_free0 (expected);
#line 4953 "test.c"
}

static void
output_file_tests_test_buffer_crossing_character (OutputFileTests* self)
{
	GString* s = NULL;
	GString* _tmp0_;
	const gchar* _tmp4_;
	GString* _tmp5_;
	guint8* _tmp6_;
	gint _tmp6__length1;
	gint _tmp7_ = 0;
	guint8* _tmp8_;
	gint _tmp8__length1;
	GString* expected = NULL;
	GString* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	gchar* _tmp13_;
	const gchar* _tmp14_;
	gchar* _tmp15_;
	gchar** _tmp16_;
	gchar** _tmp17_;
	gint _tmp17__length1;
	Output _tmp18_ = {0};
	Output _tmp19_;
	const gchar* _tmp20_;
#line 410 "test.vala"
	g_return_if_fail (self != NULL);
#line 411 "test.vala"
	_tmp0_ = g_string_new ("a");
#line 411 "test.vala"
	s = _tmp0_;
#line 4988 "test.c"
	{
		gint i = 0;
#line 414 "test.vala"
		i = 0;
#line 4993 "test.c"
		{
			gboolean _tmp1_ = FALSE;
#line 414 "test.vala"
			_tmp1_ = TRUE;
#line 414 "test.vala"
			while (TRUE) {
#line 5000 "test.c"
				GString* _tmp3_;
#line 414 "test.vala"
				if (!_tmp1_) {
#line 5004 "test.c"
					gint _tmp2_;
#line 414 "test.vala"
					_tmp2_ = i;
#line 414 "test.vala"
					i = _tmp2_ + 1;
#line 5010 "test.c"
				}
#line 414 "test.vala"
				_tmp1_ = FALSE;
#line 414 "test.vala"
				if (!(i < OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES)) {
#line 414 "test.vala"
					break;
#line 5018 "test.c"
				}
#line 415 "test.vala"
				_tmp3_ = s;
#line 415 "test.vala"
				g_string_append_unichar (_tmp3_, 225U);
#line 5024 "test.c"
			}
		}
	}
#line 417 "test.vala"
	_tmp4_ = ((TestRplOutputFile*) self)->test_result_root;
#line 417 "test.vala"
	_tmp5_ = s;
#line 417 "test.vala"
	_tmp6_ = g_string_get_data (_tmp5_, &_tmp7_);
#line 417 "test.vala"
	_tmp6__length1 = _tmp7_;
#line 417 "test.vala"
	_tmp8_ = _tmp6_;
#line 417 "test.vala"
	_tmp8__length1 = _tmp6__length1;
#line 417 "test.vala"
	buffer_to_file (_tmp4_, _tmp8_, (gint) _tmp8__length1);
#line 418 "test.vala"
	_tmp9_ = g_string_new ("a");
#line 418 "test.vala"
	expected = _tmp9_;
#line 419 "test.vala"
	_tmp10_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'b');
#line 419 "test.vala"
	_tmp11_ = _tmp10_;
#line 419 "test.vala"
	g_string_append (expected, _tmp11_);
#line 419 "test.vala"
	_g_free0 (_tmp11_);
#line 420 "test.vala"
	_tmp12_ = g_strdup ("á");
#line 420 "test.vala"
	_tmp13_ = g_strdup ("b");
#line 420 "test.vala"
	_tmp14_ = ((TestRplOutputFile*) self)->test_result_root;
#line 420 "test.vala"
	_tmp15_ = g_strdup (_tmp14_);
#line 420 "test.vala"
	_tmp16_ = g_new0 (gchar*, 3 + 1);
#line 420 "test.vala"
	_tmp16_[0] = _tmp12_;
#line 420 "test.vala"
	_tmp16_[1] = _tmp13_;
#line 420 "test.vala"
	_tmp16_[2] = _tmp15_;
#line 420 "test.vala"
	_tmp17_ = _tmp16_;
#line 420 "test.vala"
	_tmp17__length1 = 3;
#line 420 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp17_, (gint) 3, 0, &_tmp18_);
#line 420 "test.vala"
	_tmp19_ = _tmp18_;
#line 420 "test.vala"
	output_destroy (&_tmp19_);
#line 420 "test.vala"
	_tmp17_ = (_vala_array_free (_tmp17_, _tmp17__length1, (GDestroyNotify) g_free), NULL);
#line 421 "test.vala"
	_tmp20_ = expected->str;
#line 421 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, _tmp20_, (gsize) -1));
#line 410 "test.vala"
	_g_string_free0 (expected);
#line 410 "test.vala"
	_g_string_free0 (s);
#line 5090 "test.c"
}

static void
output_file_tests_test_empty_match_at_buffer_end (OutputFileTests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	guint8* _tmp3_;
	gint _tmp3__length1;
	gint _tmp4_ = 0;
	guint8* _tmp5_;
	gint _tmp5__length1;
	gchar* expected = NULL;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar** _tmp11_;
	gchar** _tmp12_;
	gint _tmp12__length1;
	Output _tmp13_ = {0};
	Output _tmp14_;
#line 424 "test.vala"
	g_return_if_fail (self != NULL);
#line 425 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 425 "test.vala"
	_tmp1_ = g_strnfill ((gsize) OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES, 'a');
#line 425 "test.vala"
	_tmp2_ = _tmp1_;
#line 425 "test.vala"
	_tmp3_ = string_get_data (_tmp2_, &_tmp4_);
#line 425 "test.vala"
	_tmp3__length1 = _tmp4_;
#line 425 "test.vala"
	_tmp5_ = _tmp3_;
#line 425 "test.vala"
	_tmp5__length1 = _tmp3__length1;
#line 425 "test.vala"
	buffer_to_file (_tmp0_, _tmp5_, (gint) _tmp5__length1);
#line 425 "test.vala"
	_g_free0 (_tmp2_);
#line 426 "test.vala"
	_tmp6_ = g_strnfill ((gsize) (OUTPUT_FILE_TESTS_MULTI_BUFFER_TEST_BYTES + 1), 'b');
#line 426 "test.vala"
	expected = _tmp6_;
#line 427 "test.vala"
	_tmp7_ = g_strdup ("a?");
#line 427 "test.vala"
	_tmp8_ = g_strdup ("b");
#line 427 "test.vala"
	_tmp9_ = ((TestRplOutputFile*) self)->test_result_root;
#line 427 "test.vala"
	_tmp10_ = g_strdup (_tmp9_);
#line 427 "test.vala"
	_tmp11_ = g_new0 (gchar*, 3 + 1);
#line 427 "test.vala"
	_tmp11_[0] = _tmp7_;
#line 427 "test.vala"
	_tmp11_[1] = _tmp8_;
#line 427 "test.vala"
	_tmp11_[2] = _tmp10_;
#line 427 "test.vala"
	_tmp12_ = _tmp11_;
#line 427 "test.vala"
	_tmp12__length1 = 3;
#line 427 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp12_, (gint) 3, 0, &_tmp13_);
#line 427 "test.vala"
	_tmp14_ = _tmp13_;
#line 427 "test.vala"
	output_destroy (&_tmp14_);
#line 427 "test.vala"
	_tmp12_ = (_vala_array_free (_tmp12_, _tmp12__length1, (GDestroyNotify) g_free), NULL);
#line 428 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches_string ((TestRplOutputFile*) self, expected, (gsize) -1));
#line 424 "test.vala"
	_g_free0 (expected);
#line 5171 "test.c"
}

static void
output_file_tests_test_recursive_no_file_arguments (OutputFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar** _tmp3_;
	gchar** _tmp4_;
	gint _tmp4__length1;
	Output _tmp5_ = {0};
	Output _tmp6_;
	Output _tmp7_;
	const gchar* _tmp8_;
#line 431 "test.vala"
	g_return_if_fail (self != NULL);
#line 432 "test.vala"
	_tmp0_ = g_strdup ("--recursive");
#line 432 "test.vala"
	_tmp1_ = g_strdup ("foo");
#line 432 "test.vala"
	_tmp2_ = g_strdup ("bar");
#line 432 "test.vala"
	_tmp3_ = g_new0 (gchar*, 3 + 1);
#line 432 "test.vala"
	_tmp3_[0] = _tmp0_;
#line 432 "test.vala"
	_tmp3_[1] = _tmp1_;
#line 432 "test.vala"
	_tmp3_[2] = _tmp2_;
#line 432 "test.vala"
	_tmp4_ = _tmp3_;
#line 432 "test.vala"
	_tmp4__length1 = 3;
#line 432 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp4_, (gint) 3, 1, &_tmp5_);
#line 432 "test.vala"
	_tmp6_ = _tmp5_;
#line 432 "test.vala"
	_tmp4_ = (_vala_array_free (_tmp4_, _tmp4__length1, (GDestroyNotify) g_free), NULL);
#line 432 "test.vala"
	output = _tmp6_;
#line 433 "test.vala"
	_tmp7_ = output;
#line 433 "test.vala"
	_tmp8_ = _tmp7_.std_err;
#line 433 "test.vala"
	g_assert_true (string_contains (_tmp8_, "cannot use --recursive with no file arguments!"));
#line 431 "test.vala"
	output_destroy (&output);
#line 5224 "test.c"
}

static void
output_file_tests_test_bad_regex (OutputFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar** _tmp2_;
	gchar** _tmp3_;
	gint _tmp3__length1;
	Output _tmp4_ = {0};
	Output _tmp5_;
	Output _tmp6_;
	const gchar* _tmp7_;
#line 436 "test.vala"
	g_return_if_fail (self != NULL);
#line 437 "test.vala"
	_tmp0_ = g_strdup ("(foo");
#line 437 "test.vala"
	_tmp1_ = g_strdup ("bar");
#line 437 "test.vala"
	_tmp2_ = g_new0 (gchar*, 2 + 1);
#line 437 "test.vala"
	_tmp2_[0] = _tmp0_;
#line 437 "test.vala"
	_tmp2_[1] = _tmp1_;
#line 437 "test.vala"
	_tmp3_ = _tmp2_;
#line 437 "test.vala"
	_tmp3__length1 = 2;
#line 437 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp3_, (gint) 2, 1, &_tmp4_);
#line 437 "test.vala"
	_tmp5_ = _tmp4_;
#line 437 "test.vala"
	_tmp3_ = (_vala_array_free (_tmp3_, _tmp3__length1, (GDestroyNotify) g_free), NULL);
#line 437 "test.vala"
	output = _tmp5_;
#line 438 "test.vala"
	_tmp6_ = output;
#line 438 "test.vala"
	_tmp7_ = _tmp6_.std_err;
#line 438 "test.vala"
	g_assert_true (string_contains (_tmp7_, "bad regex (foo"));
#line 436 "test.vala"
	output_destroy (&output);
#line 5272 "test.c"
}

static void
output_file_tests_test_non_file_input (OutputFileTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar** _tmp3_;
	gchar** _tmp4_;
	gint _tmp4__length1;
	Output _tmp5_ = {0};
	Output _tmp6_;
	Output _tmp7_;
	const gchar* _tmp8_;
#line 441 "test.vala"
	g_return_if_fail (self != NULL);
#line 442 "test.vala"
	_tmp0_ = g_strdup ("foo");
#line 442 "test.vala"
	_tmp1_ = g_strdup ("bar");
#line 442 "test.vala"
	_tmp2_ = g_strdup ("/dev/null");
#line 442 "test.vala"
	_tmp3_ = g_new0 (gchar*, 3 + 1);
#line 442 "test.vala"
	_tmp3_[0] = _tmp0_;
#line 442 "test.vala"
	_tmp3_[1] = _tmp1_;
#line 442 "test.vala"
	_tmp3_[2] = _tmp2_;
#line 442 "test.vala"
	_tmp4_ = _tmp3_;
#line 442 "test.vala"
	_tmp4__length1 = 3;
#line 442 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp4_, (gint) 3, 0, &_tmp5_);
#line 442 "test.vala"
	_tmp6_ = _tmp5_;
#line 442 "test.vala"
	_tmp4_ = (_vala_array_free (_tmp4_, _tmp4__length1, (GDestroyNotify) g_free), NULL);
#line 442 "test.vala"
	output = _tmp6_;
#line 449 "test.vala"
	_tmp7_ = output;
#line 449 "test.vala"
	_tmp8_ = _tmp7_.std_err;
#line 449 "test.vala"
	g_assert_true (string_contains (_tmp8_, "not a regular file"));
#line 441 "test.vala"
	output_destroy (&output);
#line 5325 "test.c"
}

static void
output_file_tests_class_init (OutputFileTestsClass * klass,
                              gpointer klass_data)
{
#line 275 "test.vala"
	output_file_tests_parent_class = g_type_class_peek_parent (klass);
#line 5334 "test.c"
}

static void
output_file_tests_instance_init (OutputFileTests * self,
                                 gpointer klass)
{
}

static GType
output_file_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (OutputFileTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) output_file_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (OutputFileTests), 0, (GInstanceInitFunc) output_file_tests_instance_init, NULL };
	GType output_file_tests_type_id;
	output_file_tests_type_id = g_type_register_static (TYPE_TEST_RPL_OUTPUT_FILE, "OutputFileTests", &g_define_type_info, 0);
	return output_file_tests_type_id;
}

GType
output_file_tests_get_type (void)
{
	static volatile gsize output_file_tests_type_id__once = 0;
	if (g_once_init_enter (&output_file_tests_type_id__once)) {
		GType output_file_tests_type_id;
		output_file_tests_type_id = output_file_tests_get_type_once ();
		g_once_init_leave (&output_file_tests_type_id__once, output_file_tests_type_id);
	}
	return output_file_tests_type_id__once;
}

static void
_lorem_tests_test_ignore_case_verbose_gee_test_case_test_method (gpointer self)
{
#line 456 "test.vala"
	lorem_tests_test_ignore_case_verbose ((LoremTests*) self);
#line 5369 "test.c"
}

static void
_lorem_tests_test_match_case_gee_test_case_test_method (gpointer self)
{
#line 457 "test.vala"
	lorem_tests_test_match_case ((LoremTests*) self);
#line 5377 "test.c"
}

static void
_lorem_tests_test_no_flags_gee_test_case_test_method (gpointer self)
{
#line 458 "test.vala"
	lorem_tests_test_no_flags ((LoremTests*) self);
#line 5385 "test.c"
}

static void
_lorem_tests_test_use_regexp_gee_test_case_test_method (gpointer self)
{
#line 459 "test.vala"
	lorem_tests_test_use_regexp ((LoremTests*) self);
#line 5393 "test.c"
}

static void
_lorem_tests_test_dry_run_gee_test_case_test_method (gpointer self)
{
#line 460 "test.vala"
	lorem_tests_test_dry_run ((LoremTests*) self);
#line 5401 "test.c"
}

static void
_lorem_tests_test_quiet_gee_test_case_test_method (gpointer self)
{
#line 461 "test.vala"
	lorem_tests_test_quiet ((LoremTests*) self);
#line 5409 "test.c"
}

static void
_lorem_tests_test_ignores_dash_E_gee_test_case_test_method (gpointer self)
{
#line 462 "test.vala"
	lorem_tests_test_ignores_dash_E ((LoremTests*) self);
#line 5417 "test.c"
}

static void
_lorem_tests_test_bad_replacement_gee_test_case_test_method (gpointer self)
{
#line 463 "test.vala"
	lorem_tests_test_bad_replacement ((LoremTests*) self);
#line 5425 "test.c"
}

static void
_lorem_tests_test_input_on_stdin_gee_test_case_test_method (gpointer self)
{
#line 464 "test.vala"
	lorem_tests_test_input_on_stdin ((LoremTests*) self);
#line 5433 "test.c"
}

static void
_lorem_tests_test_recursive_used_with_file_gee_test_case_test_method (gpointer self)
{
#line 465 "test.vala"
	lorem_tests_test_recursive_used_with_file ((LoremTests*) self);
#line 5441 "test.c"
}

static void
_lorem_tests_test_bad_output_encoding_gee_test_case_test_method (gpointer self)
{
#line 466 "test.vala"
	lorem_tests_test_bad_output_encoding ((LoremTests*) self);
#line 5449 "test.c"
}

static void
_lorem_tests_test_bad_ascii_output_gee_test_case_test_method (gpointer self)
{
#line 467 "test.vala"
	lorem_tests_test_bad_ascii_output ((LoremTests*) self);
#line 5457 "test.c"
}

LoremTests*
lorem_tests_construct (GType object_type,
                       const gchar* bin_dir,
                       const gchar* test_files_dir)
{
	LoremTests * self = NULL;
#line 454 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 454 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 455 "test.vala"
	self = (LoremTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "lorem.txt");
#line 456 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_ignore_case_verbose", _lorem_tests_test_ignore_case_verbose_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 457 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_match_case", _lorem_tests_test_match_case_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 458 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_no_flags", _lorem_tests_test_no_flags_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 459 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_use_regexp", _lorem_tests_test_use_regexp_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 460 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_dry_run", _lorem_tests_test_dry_run_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 461 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_quiet", _lorem_tests_test_quiet_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 462 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_ignores_dash_E", _lorem_tests_test_ignores_dash_E_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 463 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_bad_replacement", _lorem_tests_test_bad_replacement_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 464 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_input_on_stdin", _lorem_tests_test_input_on_stdin_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 465 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_recursive_used_with_file", _lorem_tests_test_recursive_used_with_file_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 466 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_bad_output_encoding", _lorem_tests_test_bad_output_encoding_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 467 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_bad_ASCII_output", _lorem_tests_test_bad_ascii_output_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 454 "test.vala"
	return self;
#line 5498 "test.c"
}

LoremTests*
lorem_tests_new (const gchar* bin_dir,
                 const gchar* test_files_dir)
{
#line 454 "test.vala"
	return lorem_tests_construct (TYPE_LOREM_TESTS, bin_dir, test_files_dir);
#line 5507 "test.c"
}

static void
lorem_tests_test_ignore_case_verbose (LoremTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	Output _tmp9_;
	const gchar* _tmp10_;
	const gchar* _tmp11_;
	gchar* _tmp12_;
	gchar* _tmp13_;
#line 470 "test.vala"
	g_return_if_fail (self != NULL);
#line 471 "test.vala"
	_tmp0_ = g_strdup ("-iv");
#line 471 "test.vala"
	_tmp1_ = g_strdup ("Lorem");
#line 471 "test.vala"
	_tmp2_ = g_strdup ("L-O-R-E-M");
#line 471 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 471 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 471 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 471 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 471 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 471 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 471 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 471 "test.vala"
	_tmp6_ = _tmp5_;
#line 471 "test.vala"
	_tmp6__length1 = 4;
#line 471 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 471 "test.vala"
	_tmp8_ = _tmp7_;
#line 471 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 471 "test.vala"
	output = _tmp8_;
#line 472 "test.vala"
	_tmp9_ = output;
#line 472 "test.vala"
	_tmp10_ = _tmp9_.std_err;
#line 472 "test.vala"
	g_assert_true (string_contains (_tmp10_, "processing "));
#line 473 "test.vala"
	_tmp11_ = ((TestRpl*) self)->test_files_dir;
#line 473 "test.vala"
	_tmp12_ = g_build_filename (_tmp11_, "lorem_ignore-case_expected.txt", NULL);
#line 473 "test.vala"
	_tmp13_ = _tmp12_;
#line 473 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp13_));
#line 473 "test.vala"
	_g_free0 (_tmp13_);
#line 470 "test.vala"
	output_destroy (&output);
#line 5581 "test.c"
}

static void
lorem_tests_test_match_case (LoremTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
#line 476 "test.vala"
	g_return_if_fail (self != NULL);
#line 477 "test.vala"
	_tmp0_ = g_strdup ("lorem");
#line 477 "test.vala"
	_tmp1_ = g_strdup ("loReM");
#line 477 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 477 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 477 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 477 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 477 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 477 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 477 "test.vala"
	_tmp5_ = _tmp4_;
#line 477 "test.vala"
	_tmp5__length1 = 3;
#line 477 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 477 "test.vala"
	_tmp7_ = _tmp6_;
#line 477 "test.vala"
	output_destroy (&_tmp7_);
#line 477 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 478 "test.vala"
	_tmp8_ = ((TestRpl*) self)->test_files_dir;
#line 478 "test.vala"
	_tmp9_ = g_build_filename (_tmp8_, "lorem_match-case_expected.txt", NULL);
#line 478 "test.vala"
	_tmp10_ = _tmp9_;
#line 478 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp10_));
#line 478 "test.vala"
	_g_free0 (_tmp10_);
#line 5639 "test.c"
}

static void
lorem_tests_test_no_flags (LoremTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
#line 481 "test.vala"
	g_return_if_fail (self != NULL);
#line 482 "test.vala"
	_tmp0_ = g_strdup ("Lorem");
#line 482 "test.vala"
	_tmp1_ = g_strdup ("L-O-R-E-M");
#line 482 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 482 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 482 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 482 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 482 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 482 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 482 "test.vala"
	_tmp5_ = _tmp4_;
#line 482 "test.vala"
	_tmp5__length1 = 3;
#line 482 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 482 "test.vala"
	_tmp7_ = _tmp6_;
#line 482 "test.vala"
	output_destroy (&_tmp7_);
#line 482 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 483 "test.vala"
	_tmp8_ = ((TestRpl*) self)->test_files_dir;
#line 483 "test.vala"
	_tmp9_ = g_build_filename (_tmp8_, "lorem_no-flags_expected.txt", NULL);
#line 483 "test.vala"
	_tmp10_ = _tmp9_;
#line 483 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp10_));
#line 483 "test.vala"
	_g_free0 (_tmp10_);
#line 5697 "test.c"
}

static void
lorem_tests_test_use_regexp (LoremTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
#line 486 "test.vala"
	g_return_if_fail (self != NULL);
#line 487 "test.vala"
	_tmp0_ = g_strdup ("a[a-z]+");
#line 487 "test.vala"
	_tmp1_ = g_strdup ("coffee");
#line 487 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 487 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 487 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 487 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 487 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 487 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 487 "test.vala"
	_tmp5_ = _tmp4_;
#line 487 "test.vala"
	_tmp5__length1 = 3;
#line 487 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 487 "test.vala"
	_tmp7_ = _tmp6_;
#line 487 "test.vala"
	output_destroy (&_tmp7_);
#line 487 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 488 "test.vala"
	_tmp8_ = ((TestRpl*) self)->test_files_dir;
#line 488 "test.vala"
	_tmp9_ = g_build_filename (_tmp8_, "lorem_use-regexp_expected.txt", NULL);
#line 488 "test.vala"
	_tmp10_ = _tmp9_;
#line 488 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp10_));
#line 488 "test.vala"
	_g_free0 (_tmp10_);
#line 5755 "test.c"
}

static void
lorem_tests_test_dry_run (LoremTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 491 "test.vala"
	g_return_if_fail (self != NULL);
#line 492 "test.vala"
	_tmp0_ = g_strdup ("--dry-run");
#line 492 "test.vala"
	_tmp1_ = g_strdup ("Lorem");
#line 492 "test.vala"
	_tmp2_ = g_strdup ("L-O-R-E-M");
#line 492 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 492 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 492 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 492 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 492 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 492 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 492 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 492 "test.vala"
	_tmp6_ = _tmp5_;
#line 492 "test.vala"
	_tmp6__length1 = 4;
#line 492 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 492 "test.vala"
	_tmp8_ = _tmp7_;
#line 492 "test.vala"
	output_destroy (&_tmp8_);
#line 492 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 493 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 493 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "lorem.txt", NULL);
#line 493 "test.vala"
	_tmp11_ = _tmp10_;
#line 493 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 493 "test.vala"
	_g_free0 (_tmp11_);
#line 5818 "test.c"
}

static void
lorem_tests_test_quiet (LoremTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	Output _tmp9_;
	const gchar* _tmp10_;
	gint _tmp11_;
	gint _tmp12_;
	const gchar* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
#line 496 "test.vala"
	g_return_if_fail (self != NULL);
#line 497 "test.vala"
	_tmp0_ = g_strdup ("--quiet");
#line 497 "test.vala"
	_tmp1_ = g_strdup ("Lorem");
#line 497 "test.vala"
	_tmp2_ = g_strdup ("L-O-R-E-M");
#line 497 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 497 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 497 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 497 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 497 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 497 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 497 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 497 "test.vala"
	_tmp6_ = _tmp5_;
#line 497 "test.vala"
	_tmp6__length1 = 4;
#line 497 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 497 "test.vala"
	_tmp8_ = _tmp7_;
#line 497 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 497 "test.vala"
	output = _tmp8_;
#line 498 "test.vala"
	_tmp9_ = output;
#line 498 "test.vala"
	_tmp10_ = _tmp9_.std_err;
#line 498 "test.vala"
	_tmp11_ = strlen (_tmp10_);
#line 498 "test.vala"
	_tmp12_ = _tmp11_;
#line 498 "test.vala"
	g_assert_true (_tmp12_ == 0);
#line 499 "test.vala"
	_tmp13_ = ((TestRpl*) self)->test_files_dir;
#line 499 "test.vala"
	_tmp14_ = g_build_filename (_tmp13_, "lorem_no-flags_expected.txt", NULL);
#line 499 "test.vala"
	_tmp15_ = _tmp14_;
#line 499 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp15_));
#line 499 "test.vala"
	_g_free0 (_tmp15_);
#line 496 "test.vala"
	output_destroy (&output);
#line 5898 "test.c"
}

static void
lorem_tests_test_ignores_dash_E (LoremTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 502 "test.vala"
	g_return_if_fail (self != NULL);
#line 503 "test.vala"
	_tmp0_ = g_strdup ("-E");
#line 503 "test.vala"
	_tmp1_ = g_strdup ("Lorem");
#line 503 "test.vala"
	_tmp2_ = g_strdup ("L-O-R-E-M");
#line 503 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 503 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 503 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 503 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 503 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 503 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 503 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 503 "test.vala"
	_tmp6_ = _tmp5_;
#line 503 "test.vala"
	_tmp6__length1 = 4;
#line 503 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 503 "test.vala"
	_tmp8_ = _tmp7_;
#line 503 "test.vala"
	output_destroy (&_tmp8_);
#line 503 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 504 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 504 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "lorem_no-flags_expected.txt", NULL);
#line 504 "test.vala"
	_tmp11_ = _tmp10_;
#line 504 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 504 "test.vala"
	_g_free0 (_tmp11_);
#line 5961 "test.c"
}

static void
lorem_tests_test_bad_replacement (LoremTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	Output _tmp8_;
	const gchar* _tmp9_;
#line 507 "test.vala"
	g_return_if_fail (self != NULL);
#line 508 "test.vala"
	_tmp0_ = g_strdup ("Lorem");
#line 508 "test.vala"
	_tmp1_ = g_strdup ("$input");
#line 508 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 508 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 508 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 508 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 508 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 508 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 508 "test.vala"
	_tmp5_ = _tmp4_;
#line 508 "test.vala"
	_tmp5__length1 = 3;
#line 508 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 508 "test.vala"
	_tmp7_ = _tmp6_;
#line 508 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 508 "test.vala"
	output = _tmp7_;
#line 509 "test.vala"
	_tmp8_ = output;
#line 509 "test.vala"
	_tmp9_ = _tmp8_.std_err;
#line 509 "test.vala"
	g_assert_true (string_contains (_tmp9_, "error in replacement"));
#line 507 "test.vala"
	output_destroy (&output);
#line 6017 "test.c"
}

static void
lorem_tests_test_input_on_stdin (LoremTests* self)
{
	GError* _inner_error0_ = NULL;
#line 512 "test.vala"
	g_return_if_fail (self != NULL);
#line 6026 "test.c"
	{
		GSubprocess* proc = NULL;
		const gchar* _tmp0_;
		gchar* _tmp1_;
		gchar* _tmp2_;
		gchar** _tmp3_;
		gchar** _tmp4_;
		gint _tmp4__length1;
		GSubprocess* _tmp5_;
		GSubprocess* _tmp6_;
		GOutputStream* stdin_pipe = NULL;
		GSubprocess* _tmp7_;
		GOutputStream* _tmp8_;
		GOutputStream* _tmp9_;
		GInputStream* stdout_pipe = NULL;
		GSubprocess* _tmp10_;
		GInputStream* _tmp11_;
		GInputStream* _tmp12_;
		gchar* _tmp13_ = NULL;
		const gchar* _tmp14_;
		gchar* _tmp15_;
		GOutputStream* _tmp16_;
		guint8* _tmp17_;
		gint _tmp17__length1;
		gint _tmp18_ = 0;
		guint8* _tmp19_;
		gint _tmp19__length1;
		GOutputStream* _tmp20_;
		gchar* std_out = NULL;
		GInputStream* _tmp21_;
		gchar* _tmp22_;
		gchar* expected_file = NULL;
		const gchar* _tmp23_;
		gchar* _tmp24_;
		gchar* _tmp25_ = NULL;
		const gchar* _tmp26_;
		gchar* _tmp27_;
		const gchar* _tmp28_;
#line 514 "test.vala"
		_tmp0_ = ((TestRpl*) self)->rpl;
#line 514 "test.vala"
		_tmp1_ = g_strdup ("Lorem");
#line 514 "test.vala"
		_tmp2_ = g_strdup ("L-O-R-E-M");
#line 514 "test.vala"
		_tmp3_ = g_new0 (gchar*, 2 + 1);
#line 514 "test.vala"
		_tmp3_[0] = _tmp1_;
#line 514 "test.vala"
		_tmp3_[1] = _tmp2_;
#line 514 "test.vala"
		_tmp4_ = _tmp3_;
#line 514 "test.vala"
		_tmp4__length1 = 2;
#line 514 "test.vala"
		_tmp5_ = start_prog (_tmp0_, _tmp4_, (gint) 2, &_inner_error0_);
#line 514 "test.vala"
		_tmp6_ = _tmp5_;
#line 514 "test.vala"
		_tmp4_ = (_vala_array_free (_tmp4_, _tmp4__length1, (GDestroyNotify) g_free), NULL);
#line 514 "test.vala"
		proc = _tmp6_;
#line 514 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 6091 "test.c"
			goto __catch0_g_error;
		}
#line 515 "test.vala"
		_tmp7_ = proc;
#line 515 "test.vala"
		_tmp8_ = g_subprocess_get_stdin_pipe (_tmp7_);
#line 515 "test.vala"
		_tmp9_ = _g_object_ref0 (_tmp8_);
#line 515 "test.vala"
		stdin_pipe = _tmp9_;
#line 516 "test.vala"
		_tmp10_ = proc;
#line 516 "test.vala"
		_tmp11_ = g_subprocess_get_stdout_pipe (_tmp10_);
#line 516 "test.vala"
		_tmp12_ = _g_object_ref0 (_tmp11_);
#line 516 "test.vala"
		stdout_pipe = _tmp12_;
#line 517 "test.vala"
		_tmp14_ = ((TestRplOutputFile*) self)->test_result_root;
#line 517 "test.vala"
		_tmp15_ = slurp_file (_tmp14_, NULL, &_inner_error0_);
#line 517 "test.vala"
		_tmp13_ = _tmp15_;
#line 517 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 517 "test.vala"
			_g_object_unref0 (stdout_pipe);
#line 517 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 517 "test.vala"
			_g_object_unref0 (proc);
#line 6124 "test.c"
			goto __catch0_g_error;
		}
#line 517 "test.vala"
		_tmp16_ = stdin_pipe;
#line 517 "test.vala"
		_tmp17_ = string_get_data (_tmp13_, &_tmp18_);
#line 517 "test.vala"
		_tmp17__length1 = _tmp18_;
#line 517 "test.vala"
		_tmp19_ = _tmp17_;
#line 517 "test.vala"
		_tmp19__length1 = _tmp17__length1;
#line 517 "test.vala"
		g_output_stream_write (_tmp16_, _tmp19_, (gsize) _tmp19__length1, NULL, &_inner_error0_);
#line 517 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 517 "test.vala"
			_g_free0 (_tmp13_);
#line 517 "test.vala"
			_g_object_unref0 (stdout_pipe);
#line 517 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 517 "test.vala"
			_g_object_unref0 (proc);
#line 6149 "test.c"
			goto __catch0_g_error;
		}
#line 518 "test.vala"
		_tmp20_ = stdin_pipe;
#line 518 "test.vala"
		g_output_stream_close (_tmp20_, NULL, &_inner_error0_);
#line 518 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 518 "test.vala"
			_g_free0 (_tmp13_);
#line 518 "test.vala"
			_g_object_unref0 (stdout_pipe);
#line 518 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 518 "test.vala"
			_g_object_unref0 (proc);
#line 6166 "test.c"
			goto __catch0_g_error;
		}
#line 519 "test.vala"
		_tmp21_ = stdout_pipe;
#line 519 "test.vala"
		_tmp22_ = slurp (_tmp21_, &_inner_error0_);
#line 519 "test.vala"
		std_out = _tmp22_;
#line 519 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 519 "test.vala"
			_g_free0 (_tmp13_);
#line 519 "test.vala"
			_g_object_unref0 (stdout_pipe);
#line 519 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 519 "test.vala"
			_g_object_unref0 (proc);
#line 6185 "test.c"
			goto __catch0_g_error;
		}
#line 520 "test.vala"
		_tmp23_ = ((TestRpl*) self)->test_files_dir;
#line 520 "test.vala"
		_tmp24_ = g_build_filename (_tmp23_, "lorem_no-flags_expected.txt", NULL);
#line 520 "test.vala"
		expected_file = _tmp24_;
#line 521 "test.vala"
		_tmp26_ = expected_file;
#line 521 "test.vala"
		_tmp27_ = slurp_file (_tmp26_, NULL, &_inner_error0_);
#line 521 "test.vala"
		_tmp25_ = _tmp27_;
#line 521 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 521 "test.vala"
			_g_free0 (expected_file);
#line 521 "test.vala"
			_g_free0 (std_out);
#line 521 "test.vala"
			_g_free0 (_tmp13_);
#line 521 "test.vala"
			_g_object_unref0 (stdout_pipe);
#line 521 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 521 "test.vala"
			_g_object_unref0 (proc);
#line 6214 "test.c"
			goto __catch0_g_error;
		}
#line 521 "test.vala"
		_tmp28_ = std_out;
#line 521 "test.vala"
		g_assert_true (g_strcmp0 (_tmp28_, _tmp25_) == 0);
#line 513 "test.vala"
		_g_free0 (_tmp25_);
#line 513 "test.vala"
		_g_free0 (expected_file);
#line 513 "test.vala"
		_g_free0 (std_out);
#line 513 "test.vala"
		_g_free0 (_tmp13_);
#line 513 "test.vala"
		_g_object_unref0 (stdout_pipe);
#line 513 "test.vala"
		_g_object_unref0 (stdin_pipe);
#line 513 "test.vala"
		_g_object_unref0 (proc);
#line 6235 "test.c"
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		GError* _tmp29_;
#line 513 "test.vala"
		e = _inner_error0_;
#line 513 "test.vala"
		_inner_error0_ = NULL;
#line 523 "test.vala"
		g_print ("error communicating with rpl\n");
#line 524 "test.vala"
		_tmp29_ = e;
#line 524 "test.vala"
		g_assert_no_error (_tmp29_);
#line 513 "test.vala"
		_g_error_free0 (e);
#line 6254 "test.c"
	}
	__finally0:
#line 513 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 513 "test.vala"
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 513 "test.vala"
		g_clear_error (&_inner_error0_);
#line 513 "test.vala"
		return;
#line 6265 "test.c"
	}
}

static void
lorem_tests_test_recursive_used_with_file (LoremTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 528 "test.vala"
	g_return_if_fail (self != NULL);
#line 529 "test.vala"
	_tmp0_ = g_strdup ("--recursive");
#line 529 "test.vala"
	_tmp1_ = g_strdup ("Lorem");
#line 529 "test.vala"
	_tmp2_ = g_strdup ("L-O-R-E-M");
#line 529 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 529 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 529 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 529 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 529 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 529 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 529 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 529 "test.vala"
	_tmp6_ = _tmp5_;
#line 529 "test.vala"
	_tmp6__length1 = 4;
#line 529 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 529 "test.vala"
	_tmp8_ = _tmp7_;
#line 529 "test.vala"
	output_destroy (&_tmp8_);
#line 529 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 530 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 530 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "lorem_no-flags_expected.txt", NULL);
#line 530 "test.vala"
	_tmp11_ = _tmp10_;
#line 530 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 530 "test.vala"
	_g_free0 (_tmp11_);
#line 6329 "test.c"
}

static void
lorem_tests_test_bad_output_encoding (LoremTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	Output _tmp9_;
	const gchar* _tmp10_;
#line 533 "test.vala"
	g_return_if_fail (self != NULL);
#line 534 "test.vala"
	_tmp0_ = g_strdup ("--encoding=iso-8859-1");
#line 534 "test.vala"
	_tmp1_ = g_strdup ("amet");
#line 534 "test.vala"
	_tmp2_ = g_strdup ("amαt");
#line 534 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 534 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 534 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 534 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 534 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 534 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 534 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 534 "test.vala"
	_tmp6_ = _tmp5_;
#line 534 "test.vala"
	_tmp6__length1 = 4;
#line 534 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 534 "test.vala"
	_tmp8_ = _tmp7_;
#line 534 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 534 "test.vala"
	output = _tmp8_;
#line 535 "test.vala"
	_tmp9_ = output;
#line 535 "test.vala"
	_tmp10_ = _tmp9_.std_err;
#line 535 "test.vala"
	g_assert_true (string_contains (_tmp10_, "Invalid or incomplete multibyte or wide character"));
#line 533 "test.vala"
	output_destroy (&output);
#line 6390 "test.c"
}

static void
lorem_tests_test_bad_ascii_output (LoremTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	Output _tmp9_;
	const gchar* _tmp10_;
#line 538 "test.vala"
	g_return_if_fail (self != NULL);
#line 539 "test.vala"
	_tmp0_ = g_strdup ("--encoding=ascii");
#line 539 "test.vala"
	_tmp1_ = g_strdup ("amet");
#line 539 "test.vala"
	_tmp2_ = g_strdup ("amαt");
#line 539 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 539 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 539 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 539 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 539 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 539 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 539 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 539 "test.vala"
	_tmp6_ = _tmp5_;
#line 539 "test.vala"
	_tmp6__length1 = 4;
#line 539 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 539 "test.vala"
	_tmp8_ = _tmp7_;
#line 539 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 539 "test.vala"
	output = _tmp8_;
#line 540 "test.vala"
	_tmp9_ = output;
#line 540 "test.vala"
	_tmp10_ = _tmp9_.std_err;
#line 540 "test.vala"
	g_assert_true (string_contains (_tmp10_, "Invalid or incomplete multibyte or wide character"));
#line 538 "test.vala"
	output_destroy (&output);
#line 6451 "test.c"
}

static void
lorem_tests_class_init (LoremTestsClass * klass,
                        gpointer klass_data)
{
#line 453 "test.vala"
	lorem_tests_parent_class = g_type_class_peek_parent (klass);
#line 6460 "test.c"
}

static void
lorem_tests_instance_init (LoremTests * self,
                           gpointer klass)
{
}

static GType
lorem_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (LoremTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) lorem_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (LoremTests), 0, (GInstanceInitFunc) lorem_tests_instance_init, NULL };
	GType lorem_tests_type_id;
	lorem_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "LoremTests", &g_define_type_info, 0);
	return lorem_tests_type_id;
}

GType
lorem_tests_get_type (void)
{
	static volatile gsize lorem_tests_type_id__once = 0;
	if (g_once_init_enter (&lorem_tests_type_id__once)) {
		GType lorem_tests_type_id;
		lorem_tests_type_id = lorem_tests_get_type_once ();
		g_once_init_leave (&lorem_tests_type_id__once, lorem_tests_type_id);
	}
	return lorem_tests_type_id__once;
}

static void
_lorem_utf8_tests_test_utf_8_gee_test_case_test_method (gpointer self)
{
#line 547 "test.vala"
	lorem_utf8_tests_test_utf_8 ((LoremUtf8Tests*) self);
#line 6495 "test.c"
}

static void
_lorem_utf8_tests_test_whole_words_gee_test_case_test_method (gpointer self)
{
#line 548 "test.vala"
	lorem_utf8_tests_test_whole_words ((LoremUtf8Tests*) self);
#line 6503 "test.c"
}

static void
_lorem_utf8_tests_test_patterns_in_files_gee_test_case_test_method (gpointer self)
{
#line 549 "test.vala"
	lorem_utf8_tests_test_patterns_in_files ((LoremUtf8Tests*) self);
#line 6511 "test.c"
}

static void
_lorem_utf8_tests_test_fixed_strings_gee_test_case_test_method (gpointer self)
{
#line 550 "test.vala"
	lorem_utf8_tests_test_fixed_strings ((LoremUtf8Tests*) self);
#line 6519 "test.c"
}

static void
_lorem_utf8_tests_test_match_case_non_ascii_gee_test_case_test_method (gpointer self)
{
#line 551 "test.vala"
	lorem_utf8_tests_test_match_case_non_ascii ((LoremUtf8Tests*) self);
#line 6527 "test.c"
}

static void
_lorem_utf8_tests_test_keep_times_gee_test_case_test_method (gpointer self)
{
#line 552 "test.vala"
	lorem_utf8_tests_test_keep_times ((LoremUtf8Tests*) self);
#line 6535 "test.c"
}

static void
_lorem_utf8_tests_test_without_keep_times_gee_test_case_test_method (gpointer self)
{
#line 553 "test.vala"
	lorem_utf8_tests_test_without_keep_times ((LoremUtf8Tests*) self);
#line 6543 "test.c"
}

static void
_lorem_utf8_tests_test_prompt_yes_gee_test_case_test_method (gpointer self)
{
#line 554 "test.vala"
	lorem_utf8_tests_test_prompt_yes ((LoremUtf8Tests*) self);
#line 6551 "test.c"
}

static void
_lorem_utf8_tests_test_prompt_no_gee_test_case_test_method (gpointer self)
{
#line 555 "test.vala"
	lorem_utf8_tests_test_prompt_no ((LoremUtf8Tests*) self);
#line 6559 "test.c"
}

static void
_lorem_utf8_tests_test_prompt_empty_gee_test_case_test_method (gpointer self)
{
#line 556 "test.vala"
	lorem_utf8_tests_test_prompt_empty ((LoremUtf8Tests*) self);
#line 6567 "test.c"
}

static void
_lorem_utf8_tests_test_force_gee_test_case_test_method (gpointer self)
{
#line 557 "test.vala"
	lorem_utf8_tests_test_force ((LoremUtf8Tests*) self);
#line 6575 "test.c"
}

static void
_lorem_utf8_tests_test_force_fail_gee_test_case_test_method (gpointer self)
{
#line 558 "test.vala"
	lorem_utf8_tests_test_force_fail ((LoremUtf8Tests*) self);
#line 6583 "test.c"
}

static void
_lorem_utf8_tests_test_set_attributes_fail_gee_test_case_test_method (gpointer self)
{
#line 559 "test.vala"
	lorem_utf8_tests_test_set_attributes_fail ((LoremUtf8Tests*) self);
#line 6591 "test.c"
}

static void
_lorem_utf8_tests_test_unreadable_input_gee_test_case_test_method (gpointer self)
{
#line 560 "test.vala"
	lorem_utf8_tests_test_unreadable_input ((LoremUtf8Tests*) self);
#line 6599 "test.c"
}

static void
_lorem_utf8_tests_test_unwritable_input_gee_test_case_test_method (gpointer self)
{
#line 561 "test.vala"
	lorem_utf8_tests_test_unwritable_input ((LoremUtf8Tests*) self);
#line 6607 "test.c"
}

LoremUtf8Tests*
lorem_utf8_tests_construct (GType object_type,
                            const gchar* bin_dir,
                            const gchar* test_files_dir)
{
	LoremUtf8Tests * self = NULL;
#line 545 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 545 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 546 "test.vala"
	self = (LoremUtf8Tests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "lorem-utf-8.txt");
#line 547 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_utf_8", _lorem_utf8_tests_test_utf_8_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 548 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_whole_words", _lorem_utf8_tests_test_whole_words_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 549 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_patterns_in_files", _lorem_utf8_tests_test_patterns_in_files_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 550 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_fixed_strings", _lorem_utf8_tests_test_fixed_strings_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 551 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_match_case_non_ascii", _lorem_utf8_tests_test_match_case_non_ascii_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 552 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_keep_times", _lorem_utf8_tests_test_keep_times_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 553 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_without_keep_times", _lorem_utf8_tests_test_without_keep_times_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 554 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_prompt_yes", _lorem_utf8_tests_test_prompt_yes_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 555 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_prompt_no", _lorem_utf8_tests_test_prompt_no_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 556 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_prompt_empty", _lorem_utf8_tests_test_prompt_empty_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 557 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_force", _lorem_utf8_tests_test_force_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 558 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_force_fail", _lorem_utf8_tests_test_force_fail_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 559 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_set_attributes_fail", _lorem_utf8_tests_test_set_attributes_fail_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 560 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_unreadable_input", _lorem_utf8_tests_test_unreadable_input_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 561 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_unwritable_input", _lorem_utf8_tests_test_unwritable_input_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 545 "test.vala"
	return self;
#line 6654 "test.c"
}

LoremUtf8Tests*
lorem_utf8_tests_new (const gchar* bin_dir,
                      const gchar* test_files_dir)
{
#line 545 "test.vala"
	return lorem_utf8_tests_construct (TYPE_LOREM_UTF8_TESTS, bin_dir, test_files_dir);
#line 6663 "test.c"
}

static void
lorem_utf8_tests_test_utf_8 (LoremUtf8Tests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
#line 564 "test.vala"
	g_return_if_fail (self != NULL);
#line 565 "test.vala"
	_tmp0_ = g_strdup ("amét");
#line 565 "test.vala"
	_tmp1_ = g_strdup ("amèt");
#line 565 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 565 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 565 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 565 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 565 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 565 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 565 "test.vala"
	_tmp5_ = _tmp4_;
#line 565 "test.vala"
	_tmp5__length1 = 3;
#line 565 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 565 "test.vala"
	_tmp7_ = _tmp6_;
#line 565 "test.vala"
	output_destroy (&_tmp7_);
#line 565 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 566 "test.vala"
	_tmp8_ = ((TestRpl*) self)->test_files_dir;
#line 566 "test.vala"
	_tmp9_ = g_build_filename (_tmp8_, "lorem-utf-8_utf-8_expected.txt", NULL);
#line 566 "test.vala"
	_tmp10_ = _tmp9_;
#line 566 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp10_));
#line 566 "test.vala"
	_g_free0 (_tmp10_);
#line 6721 "test.c"
}

static void
lorem_utf8_tests_test_whole_words (LoremUtf8Tests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 569 "test.vala"
	g_return_if_fail (self != NULL);
#line 570 "test.vala"
	_tmp0_ = g_strdup ("--whole-words");
#line 570 "test.vala"
	_tmp1_ = g_strdup ("in");
#line 570 "test.vala"
	_tmp2_ = g_strdup ("out");
#line 570 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 570 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 570 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 570 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 570 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 570 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 570 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 570 "test.vala"
	_tmp6_ = _tmp5_;
#line 570 "test.vala"
	_tmp6__length1 = 4;
#line 570 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 570 "test.vala"
	_tmp8_ = _tmp7_;
#line 570 "test.vala"
	output_destroy (&_tmp8_);
#line 570 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 571 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 571 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "lorem-utf-8_whole-words_expected.txt", NULL);
#line 571 "test.vala"
	_tmp11_ = _tmp10_;
#line 571 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 571 "test.vala"
	_g_free0 (_tmp11_);
#line 6784 "test.c"
}

static void
lorem_utf8_tests_test_patterns_in_files (LoremUtf8Tests* self)
{
	gchar* in_file = NULL;
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* out_file = NULL;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar* _tmp4_;
	gchar* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar** _tmp10_;
	gchar** _tmp11_;
	gint _tmp11__length1;
	Output _tmp12_ = {0};
	Output _tmp13_;
	const gchar* _tmp14_;
	gchar* _tmp15_;
	gchar* _tmp16_;
#line 574 "test.vala"
	g_return_if_fail (self != NULL);
#line 575 "test.vala"
	_tmp0_ = ((TestRpl*) self)->test_files_dir;
#line 575 "test.vala"
	_tmp1_ = g_build_filename (_tmp0_, "in.txt", NULL);
#line 575 "test.vala"
	in_file = _tmp1_;
#line 576 "test.vala"
	_tmp2_ = ((TestRpl*) self)->test_files_dir;
#line 576 "test.vala"
	_tmp3_ = g_build_filename (_tmp2_, "out.txt", NULL);
#line 576 "test.vala"
	out_file = _tmp3_;
#line 577 "test.vala"
	_tmp4_ = g_strdup ("--files");
#line 577 "test.vala"
	_tmp5_ = g_strdup ("--whole-words");
#line 577 "test.vala"
	_tmp6_ = g_strdup (in_file);
#line 577 "test.vala"
	_tmp7_ = g_strdup (out_file);
#line 577 "test.vala"
	_tmp8_ = ((TestRplOutputFile*) self)->test_result_root;
#line 577 "test.vala"
	_tmp9_ = g_strdup (_tmp8_);
#line 577 "test.vala"
	_tmp10_ = g_new0 (gchar*, 5 + 1);
#line 577 "test.vala"
	_tmp10_[0] = _tmp4_;
#line 577 "test.vala"
	_tmp10_[1] = _tmp5_;
#line 577 "test.vala"
	_tmp10_[2] = _tmp6_;
#line 577 "test.vala"
	_tmp10_[3] = _tmp7_;
#line 577 "test.vala"
	_tmp10_[4] = _tmp9_;
#line 577 "test.vala"
	_tmp11_ = _tmp10_;
#line 577 "test.vala"
	_tmp11__length1 = 5;
#line 577 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp11_, (gint) 5, 0, &_tmp12_);
#line 577 "test.vala"
	_tmp13_ = _tmp12_;
#line 577 "test.vala"
	output_destroy (&_tmp13_);
#line 577 "test.vala"
	_tmp11_ = (_vala_array_free (_tmp11_, _tmp11__length1, (GDestroyNotify) g_free), NULL);
#line 578 "test.vala"
	_tmp14_ = ((TestRpl*) self)->test_files_dir;
#line 578 "test.vala"
	_tmp15_ = g_build_filename (_tmp14_, "lorem-utf-8_whole-words_expected.txt", NULL);
#line 578 "test.vala"
	_tmp16_ = _tmp15_;
#line 578 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp16_));
#line 578 "test.vala"
	_g_free0 (_tmp16_);
#line 574 "test.vala"
	_g_free0 (out_file);
#line 574 "test.vala"
	_g_free0 (in_file);
#line 6874 "test.c"
}

static void
lorem_utf8_tests_test_fixed_strings (LoremUtf8Tests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 581 "test.vala"
	g_return_if_fail (self != NULL);
#line 582 "test.vala"
	_tmp0_ = g_strdup ("--fixed-strings");
#line 582 "test.vala"
	_tmp1_ = g_strdup ("t.");
#line 582 "test.vala"
	_tmp2_ = g_strdup ("t$$");
#line 582 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 582 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 582 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 582 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 582 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 582 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 582 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 582 "test.vala"
	_tmp6_ = _tmp5_;
#line 582 "test.vala"
	_tmp6__length1 = 4;
#line 582 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 582 "test.vala"
	_tmp8_ = _tmp7_;
#line 582 "test.vala"
	output_destroy (&_tmp8_);
#line 582 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 583 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 583 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "lorem-utf-8_fixed-strings_expected.txt", NULL);
#line 583 "test.vala"
	_tmp11_ = _tmp10_;
#line 583 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 583 "test.vala"
	_g_free0 (_tmp11_);
#line 6937 "test.c"
}

static void
lorem_utf8_tests_test_match_case_non_ascii (LoremUtf8Tests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 586 "test.vala"
	g_return_if_fail (self != NULL);
#line 587 "test.vala"
	_tmp0_ = g_strdup ("-m");
#line 587 "test.vala"
	_tmp1_ = g_strdup ("\\w+");
#line 587 "test.vala"
	_tmp2_ = g_strdup ("éowyn");
#line 587 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 587 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 587 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 587 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 587 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 587 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 587 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 587 "test.vala"
	_tmp6_ = _tmp5_;
#line 587 "test.vala"
	_tmp6__length1 = 4;
#line 587 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 587 "test.vala"
	_tmp8_ = _tmp7_;
#line 587 "test.vala"
	output_destroy (&_tmp8_);
#line 587 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 588 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 588 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "lorem-utf-8_match-case-non-ascii_expected.txt", NULL);
#line 588 "test.vala"
	_tmp11_ = _tmp10_;
#line 588 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 588 "test.vala"
	_g_free0 (_tmp11_);
#line 7000 "test.c"
}

static void
lorem_utf8_tests_test_keep_times (LoremUtf8Tests* self)
{
	gchar* _tmp0_;
	const gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
	const gchar* _tmp12_;
	gchar* _tmp13_;
	gchar** _tmp14_;
	gchar** _tmp15_;
	gint _tmp15__length1;
	Output _tmp16_ = {0};
	Output _tmp17_;
	struct stat perms = {0};
	const gchar* _tmp18_;
	struct stat _tmp19_ = {0};
	gint _tmp20_;
	struct timespec orig_mtime = {0};
	struct stat _tmp21_;
	const gchar* _tmp22_;
	struct stat _tmp23_ = {0};
	gint _tmp24_;
	struct timespec new_mtime = {0};
	struct stat _tmp25_;
	gboolean _tmp26_ = FALSE;
	struct timespec _tmp27_;
	struct timespec _tmp28_;
#line 591 "test.vala"
	g_return_if_fail (self != NULL);
#line 592 "test.vala"
	_tmp0_ = g_strdup ("-r");
#line 592 "test.vala"
	_tmp1_ = ((TestRplFile*) self)->test_data_root;
#line 592 "test.vala"
	_tmp2_ = g_strdup (_tmp1_);
#line 592 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 592 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 592 "test.vala"
	_tmp5_ = g_new0 (gchar*, 3 + 1);
#line 592 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 592 "test.vala"
	_tmp5_[1] = _tmp2_;
#line 592 "test.vala"
	_tmp5_[2] = _tmp4_;
#line 592 "test.vala"
	_tmp6_ = _tmp5_;
#line 592 "test.vala"
	_tmp6__length1 = 3;
#line 592 "test.vala"
	run_prog ("touch", _tmp6_, (gint) 3, 0, &_tmp7_);
#line 592 "test.vala"
	_tmp8_ = _tmp7_;
#line 592 "test.vala"
	output_destroy (&_tmp8_);
#line 592 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 593 "test.vala"
	_tmp9_ = g_strdup ("--keep-times");
#line 593 "test.vala"
	_tmp10_ = g_strdup ("in");
#line 593 "test.vala"
	_tmp11_ = g_strdup ("out");
#line 593 "test.vala"
	_tmp12_ = ((TestRplOutputFile*) self)->test_result_root;
#line 593 "test.vala"
	_tmp13_ = g_strdup (_tmp12_);
#line 593 "test.vala"
	_tmp14_ = g_new0 (gchar*, 4 + 1);
#line 593 "test.vala"
	_tmp14_[0] = _tmp9_;
#line 593 "test.vala"
	_tmp14_[1] = _tmp10_;
#line 593 "test.vala"
	_tmp14_[2] = _tmp11_;
#line 593 "test.vala"
	_tmp14_[3] = _tmp13_;
#line 593 "test.vala"
	_tmp15_ = _tmp14_;
#line 593 "test.vala"
	_tmp15__length1 = 4;
#line 593 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp15_, (gint) 4, 0, &_tmp16_);
#line 593 "test.vala"
	_tmp17_ = _tmp16_;
#line 593 "test.vala"
	output_destroy (&_tmp17_);
#line 593 "test.vala"
	_tmp15_ = (_vala_array_free (_tmp15_, _tmp15__length1, (GDestroyNotify) g_free), NULL);
#line 594 "test.vala"
	memset (&perms, 0, sizeof (struct stat));
#line 595 "test.vala"
	_tmp18_ = ((TestRplFile*) self)->test_data_root;
#line 595 "test.vala"
	_tmp20_ = lstat (_tmp18_, &_tmp19_);
#line 595 "test.vala"
	perms = _tmp19_;
#line 595 "test.vala"
	g_assert_true (_tmp20_ == 0);
#line 596 "test.vala"
	_tmp21_ = perms;
#line 596 "test.vala"
	orig_mtime = (struct timespec) get_stat_mtime (&_tmp21_);
#line 597 "test.vala"
	_tmp22_ = ((TestRplOutputFile*) self)->test_result_root;
#line 597 "test.vala"
	_tmp24_ = lstat (_tmp22_, &_tmp23_);
#line 597 "test.vala"
	perms = _tmp23_;
#line 597 "test.vala"
	g_assert_true (_tmp24_ == 0);
#line 598 "test.vala"
	_tmp25_ = perms;
#line 598 "test.vala"
	new_mtime = (struct timespec) get_stat_mtime (&_tmp25_);
#line 599 "test.vala"
	_tmp27_ = orig_mtime;
#line 599 "test.vala"
	_tmp28_ = new_mtime;
#line 599 "test.vala"
	if (_tmp27_.tv_sec == _tmp28_.tv_sec) {
#line 7136 "test.c"
		struct timespec _tmp29_;
		struct timespec _tmp30_;
#line 600 "test.vala"
		_tmp29_ = orig_mtime;
#line 600 "test.vala"
		_tmp30_ = new_mtime;
#line 600 "test.vala"
		_tmp26_ = _tmp29_.tv_nsec == _tmp30_.tv_nsec;
#line 7145 "test.c"
	} else {
#line 599 "test.vala"
		_tmp26_ = FALSE;
#line 7149 "test.c"
	}
#line 599 "test.vala"
	g_assert_true (_tmp26_);
#line 7153 "test.c"
}

static void
lorem_utf8_tests_test_without_keep_times (LoremUtf8Tests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	struct stat perms = {0};
	const gchar* _tmp8_;
	struct stat _tmp9_ = {0};
	gint _tmp10_;
	struct timespec orig_mtime = {0};
	struct stat _tmp11_;
	const gchar* _tmp12_;
	struct stat _tmp13_ = {0};
	gint _tmp14_;
	struct timespec new_mtime = {0};
	struct stat _tmp15_;
	gboolean _tmp16_ = FALSE;
	struct timespec _tmp17_;
	struct timespec _tmp18_;
#line 603 "test.vala"
	g_return_if_fail (self != NULL);
#line 604 "test.vala"
	_tmp0_ = g_strdup ("in");
#line 604 "test.vala"
	_tmp1_ = g_strdup ("out");
#line 604 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 604 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 604 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 604 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 604 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 604 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 604 "test.vala"
	_tmp5_ = _tmp4_;
#line 604 "test.vala"
	_tmp5__length1 = 3;
#line 604 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 604 "test.vala"
	_tmp7_ = _tmp6_;
#line 604 "test.vala"
	output_destroy (&_tmp7_);
#line 604 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 605 "test.vala"
	memset (&perms, 0, sizeof (struct stat));
#line 606 "test.vala"
	_tmp8_ = ((TestRplFile*) self)->test_data_root;
#line 606 "test.vala"
	_tmp10_ = lstat (_tmp8_, &_tmp9_);
#line 606 "test.vala"
	perms = _tmp9_;
#line 606 "test.vala"
	g_assert_true (_tmp10_ == 0);
#line 607 "test.vala"
	_tmp11_ = perms;
#line 607 "test.vala"
	orig_mtime = (struct timespec) get_stat_mtime (&_tmp11_);
#line 608 "test.vala"
	_tmp12_ = ((TestRplOutputFile*) self)->test_result_root;
#line 608 "test.vala"
	_tmp14_ = lstat (_tmp12_, &_tmp13_);
#line 608 "test.vala"
	perms = _tmp13_;
#line 608 "test.vala"
	g_assert_true (_tmp14_ == 0);
#line 609 "test.vala"
	_tmp15_ = perms;
#line 609 "test.vala"
	new_mtime = (struct timespec) get_stat_mtime (&_tmp15_);
#line 610 "test.vala"
	_tmp17_ = orig_mtime;
#line 610 "test.vala"
	_tmp18_ = new_mtime;
#line 610 "test.vala"
	if (_tmp17_.tv_sec == _tmp18_.tv_sec) {
#line 7244 "test.c"
		struct timespec _tmp19_;
		struct timespec _tmp20_;
#line 611 "test.vala"
		_tmp19_ = orig_mtime;
#line 611 "test.vala"
		_tmp20_ = new_mtime;
#line 611 "test.vala"
		_tmp16_ = _tmp19_.tv_nsec == _tmp20_.tv_nsec;
#line 7253 "test.c"
	} else {
#line 610 "test.vala"
		_tmp16_ = FALSE;
#line 7257 "test.c"
	}
#line 610 "test.vala"
	g_assert_true (!_tmp16_);
#line 7261 "test.c"
}

static void
lorem_utf8_tests_prompt_test (LoremUtf8Tests* self,
                              const gchar* input,
                              const gchar* expected)
{
	GError* _inner_error0_ = NULL;
#line 614 "test.vala"
	g_return_if_fail (self != NULL);
#line 614 "test.vala"
	g_return_if_fail (input != NULL);
#line 614 "test.vala"
	g_return_if_fail (expected != NULL);
#line 7276 "test.c"
	{
		GSubprocess* proc = NULL;
		const gchar* _tmp0_;
		gchar* _tmp1_;
		gchar* _tmp2_;
		gchar* _tmp3_;
		gchar* _tmp4_;
		const gchar* _tmp5_;
		gchar* _tmp6_;
		gchar** _tmp7_;
		gchar** _tmp8_;
		gint _tmp8__length1;
		GSubprocess* _tmp9_;
		GSubprocess* _tmp10_;
		GOutputStream* stdin_pipe = NULL;
		GSubprocess* _tmp11_;
		GOutputStream* _tmp12_;
		GOutputStream* _tmp13_;
		GInputStream* stderr_pipe = NULL;
		GSubprocess* _tmp14_;
		GInputStream* _tmp15_;
		GInputStream* _tmp16_;
		GOutputStream* _tmp17_;
		guint8* _tmp18_;
		gint _tmp18__length1;
		gint _tmp19_ = 0;
		guint8* _tmp20_;
		gint _tmp20__length1;
		GOutputStream* _tmp21_;
		gchar* std_err = NULL;
		GInputStream* _tmp22_;
		gchar* _tmp23_;
		const gchar* _tmp24_;
		const gchar* _tmp25_;
#line 616 "test.vala"
		_tmp0_ = ((TestRpl*) self)->rpl;
#line 616 "test.vala"
		_tmp1_ = g_strdup ("--whole-words");
#line 616 "test.vala"
		_tmp2_ = g_strdup ("--prompt");
#line 616 "test.vala"
		_tmp3_ = g_strdup ("in");
#line 616 "test.vala"
		_tmp4_ = g_strdup ("out");
#line 616 "test.vala"
		_tmp5_ = ((TestRplOutputFile*) self)->test_result_root;
#line 616 "test.vala"
		_tmp6_ = g_strdup (_tmp5_);
#line 616 "test.vala"
		_tmp7_ = g_new0 (gchar*, 5 + 1);
#line 616 "test.vala"
		_tmp7_[0] = _tmp1_;
#line 616 "test.vala"
		_tmp7_[1] = _tmp2_;
#line 616 "test.vala"
		_tmp7_[2] = _tmp3_;
#line 616 "test.vala"
		_tmp7_[3] = _tmp4_;
#line 616 "test.vala"
		_tmp7_[4] = _tmp6_;
#line 616 "test.vala"
		_tmp8_ = _tmp7_;
#line 616 "test.vala"
		_tmp8__length1 = 5;
#line 616 "test.vala"
		_tmp9_ = start_prog (_tmp0_, _tmp8_, (gint) 5, &_inner_error0_);
#line 616 "test.vala"
		_tmp10_ = _tmp9_;
#line 616 "test.vala"
		_tmp8_ = (_vala_array_free (_tmp8_, _tmp8__length1, (GDestroyNotify) g_free), NULL);
#line 616 "test.vala"
		proc = _tmp10_;
#line 616 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 7351 "test.c"
			goto __catch0_g_error;
		}
#line 617 "test.vala"
		_tmp11_ = proc;
#line 617 "test.vala"
		_tmp12_ = g_subprocess_get_stdin_pipe (_tmp11_);
#line 617 "test.vala"
		_tmp13_ = _g_object_ref0 (_tmp12_);
#line 617 "test.vala"
		stdin_pipe = _tmp13_;
#line 618 "test.vala"
		_tmp14_ = proc;
#line 618 "test.vala"
		_tmp15_ = g_subprocess_get_stderr_pipe (_tmp14_);
#line 618 "test.vala"
		_tmp16_ = _g_object_ref0 (_tmp15_);
#line 618 "test.vala"
		stderr_pipe = _tmp16_;
#line 619 "test.vala"
		_tmp17_ = stdin_pipe;
#line 619 "test.vala"
		_tmp18_ = string_get_data (input, &_tmp19_);
#line 619 "test.vala"
		_tmp18__length1 = _tmp19_;
#line 619 "test.vala"
		_tmp20_ = _tmp18_;
#line 619 "test.vala"
		_tmp20__length1 = _tmp18__length1;
#line 619 "test.vala"
		g_output_stream_write (_tmp17_, _tmp20_, (gsize) _tmp20__length1, NULL, &_inner_error0_);
#line 619 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 619 "test.vala"
			_g_object_unref0 (stderr_pipe);
#line 619 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 619 "test.vala"
			_g_object_unref0 (proc);
#line 7390 "test.c"
			goto __catch0_g_error;
		}
#line 620 "test.vala"
		_tmp21_ = stdin_pipe;
#line 620 "test.vala"
		g_output_stream_close (_tmp21_, NULL, &_inner_error0_);
#line 620 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 620 "test.vala"
			_g_object_unref0 (stderr_pipe);
#line 620 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 620 "test.vala"
			_g_object_unref0 (proc);
#line 7405 "test.c"
			goto __catch0_g_error;
		}
#line 621 "test.vala"
		_tmp22_ = stderr_pipe;
#line 621 "test.vala"
		_tmp23_ = slurp (_tmp22_, &_inner_error0_);
#line 621 "test.vala"
		std_err = _tmp23_;
#line 621 "test.vala"
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 621 "test.vala"
			_g_object_unref0 (stderr_pipe);
#line 621 "test.vala"
			_g_object_unref0 (stdin_pipe);
#line 621 "test.vala"
			_g_object_unref0 (proc);
#line 7422 "test.c"
			goto __catch0_g_error;
		}
#line 622 "test.vala"
		_tmp24_ = std_err;
#line 622 "test.vala"
		g_assert_true (string_contains (_tmp24_, "? [Y/n] "));
#line 623 "test.vala"
		_tmp25_ = std_err;
#line 623 "test.vala"
		g_assert_true (string_contains (_tmp25_, expected));
#line 615 "test.vala"
		_g_free0 (std_err);
#line 615 "test.vala"
		_g_object_unref0 (stderr_pipe);
#line 615 "test.vala"
		_g_object_unref0 (stdin_pipe);
#line 615 "test.vala"
		_g_object_unref0 (proc);
#line 7441 "test.c"
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		GError* _tmp26_;
#line 615 "test.vala"
		e = _inner_error0_;
#line 615 "test.vala"
		_inner_error0_ = NULL;
#line 625 "test.vala"
		g_print ("error communicating with rpl\n");
#line 626 "test.vala"
		_tmp26_ = e;
#line 626 "test.vala"
		g_assert_no_error (_tmp26_);
#line 615 "test.vala"
		_g_error_free0 (e);
#line 7460 "test.c"
	}
	__finally0:
#line 615 "test.vala"
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
#line 615 "test.vala"
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
#line 615 "test.vala"
		g_clear_error (&_inner_error0_);
#line 615 "test.vala"
		return;
#line 7471 "test.c"
	}
}

static void
lorem_utf8_tests_test_prompt_yes (LoremUtf8Tests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
#line 630 "test.vala"
	g_return_if_fail (self != NULL);
#line 631 "test.vala"
	lorem_utf8_tests_prompt_test (self, "y\n", "Updated");
#line 632 "test.vala"
	_tmp0_ = ((TestRpl*) self)->test_files_dir;
#line 632 "test.vala"
	_tmp1_ = g_build_filename (_tmp0_, "lorem-utf-8_whole-words_expected.txt", NULL);
#line 632 "test.vala"
	_tmp2_ = _tmp1_;
#line 632 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp2_));
#line 632 "test.vala"
	_g_free0 (_tmp2_);
#line 7495 "test.c"
}

static void
lorem_utf8_tests_test_prompt_no (LoremUtf8Tests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
#line 635 "test.vala"
	g_return_if_fail (self != NULL);
#line 636 "test.vala"
	lorem_utf8_tests_prompt_test (self, "n\n", "Not updated");
#line 637 "test.vala"
	_tmp0_ = ((TestRpl*) self)->test_files_dir;
#line 637 "test.vala"
	_tmp1_ = g_build_filename (_tmp0_, "lorem-utf-8_whole-words_expected.txt", NULL);
#line 637 "test.vala"
	_tmp2_ = _tmp1_;
#line 637 "test.vala"
	g_assert_true (!test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp2_));
#line 637 "test.vala"
	_g_free0 (_tmp2_);
#line 7518 "test.c"
}

static void
lorem_utf8_tests_test_prompt_empty (LoremUtf8Tests* self)
{
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
#line 640 "test.vala"
	g_return_if_fail (self != NULL);
#line 641 "test.vala"
	lorem_utf8_tests_prompt_test (self, "\n", "Updated");
#line 642 "test.vala"
	_tmp0_ = ((TestRpl*) self)->test_files_dir;
#line 642 "test.vala"
	_tmp1_ = g_build_filename (_tmp0_, "lorem-utf-8_whole-words_expected.txt", NULL);
#line 642 "test.vala"
	_tmp2_ = _tmp1_;
#line 642 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp2_));
#line 642 "test.vala"
	_g_free0 (_tmp2_);
#line 7541 "test.c"
}

static void
lorem_utf8_tests_test_force (LoremUtf8Tests* self)
{
	gboolean _tmp0_ = FALSE;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	gboolean _tmp7_;
	Output output = {0};
	gchar* _tmp14_;
	const gchar* _tmp15_;
	gchar* _tmp16_;
	gchar* _tmp17_;
	gchar* _tmp18_;
	gchar* _tmp19_;
	const gchar* _tmp20_;
	gchar* _tmp21_;
	gchar** _tmp22_;
	gchar** _tmp23_;
	gint _tmp23__length1;
	Output _tmp24_ = {0};
	Output _tmp25_;
	const gchar* _tmp26_;
	gchar* _tmp27_;
	gchar* _tmp28_;
	Output _tmp29_;
	const gchar* _tmp30_;
	Output _tmp31_;
	const gchar* _tmp32_;
#line 645 "test.vala"
	g_return_if_fail (self != NULL);
#line 646 "test.vala"
	_tmp1_ = g_strdup ("chown");
#line 646 "test.vala"
	_tmp2_ = g_strdup ("0:0");
#line 646 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 646 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 646 "test.vala"
	_tmp5_ = g_new0 (gchar*, 3 + 1);
#line 646 "test.vala"
	_tmp5_[0] = _tmp1_;
#line 646 "test.vala"
	_tmp5_[1] = _tmp2_;
#line 646 "test.vala"
	_tmp5_[2] = _tmp4_;
#line 646 "test.vala"
	_tmp6_ = _tmp5_;
#line 646 "test.vala"
	_tmp6__length1 = 3;
#line 646 "test.vala"
	_tmp7_ = !try_sudo (_tmp6_, (gint) 3);
#line 646 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 646 "test.vala"
	if (_tmp7_) {
#line 646 "test.vala"
		_tmp0_ = TRUE;
#line 7607 "test.c"
	} else {
		gchar* _tmp8_;
		gchar* _tmp9_;
		const gchar* _tmp10_;
		gchar* _tmp11_;
		gchar** _tmp12_;
		gchar** _tmp13_;
		gint _tmp13__length1;
#line 647 "test.vala"
		_tmp8_ = g_strdup ("chmod");
#line 647 "test.vala"
		_tmp9_ = g_strdup ("644");
#line 647 "test.vala"
		_tmp10_ = ((TestRplOutputFile*) self)->test_result_root;
#line 647 "test.vala"
		_tmp11_ = g_strdup (_tmp10_);
#line 647 "test.vala"
		_tmp12_ = g_new0 (gchar*, 3 + 1);
#line 647 "test.vala"
		_tmp12_[0] = _tmp8_;
#line 647 "test.vala"
		_tmp12_[1] = _tmp9_;
#line 647 "test.vala"
		_tmp12_[2] = _tmp11_;
#line 647 "test.vala"
		_tmp13_ = _tmp12_;
#line 647 "test.vala"
		_tmp13__length1 = 3;
#line 647 "test.vala"
		_tmp0_ = !try_sudo (_tmp13_, (gint) 3);
#line 647 "test.vala"
		_tmp13_ = (_vala_array_free (_tmp13_, _tmp13__length1, (GDestroyNotify) g_free), NULL);
#line 7640 "test.c"
	}
#line 646 "test.vala"
	if (_tmp0_) {
#line 648 "test.vala"
		return;
#line 7646 "test.c"
	}
#line 650 "test.vala"
	_tmp14_ = g_strdup ("-n");
#line 650 "test.vala"
	_tmp15_ = ((TestRpl*) self)->rpl;
#line 650 "test.vala"
	_tmp16_ = g_strdup (_tmp15_);
#line 650 "test.vala"
	_tmp17_ = g_strdup ("--force");
#line 650 "test.vala"
	_tmp18_ = g_strdup ("amét");
#line 650 "test.vala"
	_tmp19_ = g_strdup ("amèt");
#line 650 "test.vala"
	_tmp20_ = ((TestRplOutputFile*) self)->test_result_root;
#line 650 "test.vala"
	_tmp21_ = g_strdup (_tmp20_);
#line 650 "test.vala"
	_tmp22_ = g_new0 (gchar*, 6 + 1);
#line 650 "test.vala"
	_tmp22_[0] = _tmp14_;
#line 650 "test.vala"
	_tmp22_[1] = _tmp16_;
#line 650 "test.vala"
	_tmp22_[2] = _tmp17_;
#line 650 "test.vala"
	_tmp22_[3] = _tmp18_;
#line 650 "test.vala"
	_tmp22_[4] = _tmp19_;
#line 650 "test.vala"
	_tmp22_[5] = _tmp21_;
#line 650 "test.vala"
	_tmp23_ = _tmp22_;
#line 650 "test.vala"
	_tmp23__length1 = 6;
#line 650 "test.vala"
	run_prog ("sudo", _tmp23_, (gint) 6, 0, &_tmp24_);
#line 650 "test.vala"
	_tmp25_ = _tmp24_;
#line 650 "test.vala"
	_tmp23_ = (_vala_array_free (_tmp23_, _tmp23__length1, (GDestroyNotify) g_free), NULL);
#line 650 "test.vala"
	output = _tmp25_;
#line 651 "test.vala"
	_tmp26_ = ((TestRpl*) self)->test_files_dir;
#line 651 "test.vala"
	_tmp27_ = g_build_filename (_tmp26_, "lorem-utf-8_utf-8_expected.txt", NULL);
#line 651 "test.vala"
	_tmp28_ = _tmp27_;
#line 651 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp28_));
#line 651 "test.vala"
	_g_free0 (_tmp28_);
#line 652 "test.vala"
	_tmp29_ = output;
#line 652 "test.vala"
	_tmp30_ = _tmp29_.std_err;
#line 652 "test.vala"
	g_assert_true (!string_contains (_tmp30_, "unable to set attributes"));
#line 653 "test.vala"
	_tmp31_ = output;
#line 653 "test.vala"
	_tmp32_ = _tmp31_.std_err;
#line 653 "test.vala"
	g_assert_true (!string_contains (_tmp32_, "new file attributes may not match"));
#line 645 "test.vala"
	output_destroy (&output);
#line 7714 "test.c"
}

static void
lorem_utf8_tests_test_force_fail (LoremUtf8Tests* self)
{
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar** _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	gboolean _tmp8_;
	Output output = {0};
	gchar* _tmp21_;
	gchar* _tmp22_;
	gchar* _tmp23_;
	const gchar* _tmp24_;
	gchar* _tmp25_;
	gchar** _tmp26_;
	gchar** _tmp27_;
	gint _tmp27__length1;
	Output _tmp28_ = {0};
	Output _tmp29_;
	Output _tmp30_;
	const gchar* _tmp31_;
	Output _tmp32_;
	const gchar* _tmp33_;
#line 656 "test.vala"
	g_return_if_fail (self != NULL);
#line 657 "test.vala"
	_tmp2_ = g_strdup ("chown");
#line 657 "test.vala"
	_tmp3_ = g_strdup ("0:0");
#line 657 "test.vala"
	_tmp4_ = ((TestRplOutputFile*) self)->test_result_root;
#line 657 "test.vala"
	_tmp5_ = g_strdup (_tmp4_);
#line 657 "test.vala"
	_tmp6_ = g_new0 (gchar*, 3 + 1);
#line 657 "test.vala"
	_tmp6_[0] = _tmp2_;
#line 657 "test.vala"
	_tmp6_[1] = _tmp3_;
#line 657 "test.vala"
	_tmp6_[2] = _tmp5_;
#line 657 "test.vala"
	_tmp7_ = _tmp6_;
#line 657 "test.vala"
	_tmp7__length1 = 3;
#line 657 "test.vala"
	_tmp8_ = !try_sudo (_tmp7_, (gint) 3);
#line 657 "test.vala"
	_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
#line 657 "test.vala"
	if (_tmp8_) {
#line 657 "test.vala"
		_tmp1_ = TRUE;
#line 7775 "test.c"
	} else {
		gchar* _tmp9_;
		gchar* _tmp10_;
		const gchar* _tmp11_;
		gchar* _tmp12_;
		gchar** _tmp13_;
		gchar** _tmp14_;
		gint _tmp14__length1;
#line 658 "test.vala"
		_tmp9_ = g_strdup ("chmod");
#line 658 "test.vala"
		_tmp10_ = g_strdup ("777");
#line 658 "test.vala"
		_tmp11_ = ((TestRplOutputFile*) self)->test_result_root;
#line 658 "test.vala"
		_tmp12_ = g_strdup (_tmp11_);
#line 658 "test.vala"
		_tmp13_ = g_new0 (gchar*, 3 + 1);
#line 658 "test.vala"
		_tmp13_[0] = _tmp9_;
#line 658 "test.vala"
		_tmp13_[1] = _tmp10_;
#line 658 "test.vala"
		_tmp13_[2] = _tmp12_;
#line 658 "test.vala"
		_tmp14_ = _tmp13_;
#line 658 "test.vala"
		_tmp14__length1 = 3;
#line 658 "test.vala"
		_tmp1_ = !try_sudo (_tmp14_, (gint) 3);
#line 658 "test.vala"
		_tmp14_ = (_vala_array_free (_tmp14_, _tmp14__length1, (GDestroyNotify) g_free), NULL);
#line 7808 "test.c"
	}
#line 657 "test.vala"
	if (_tmp1_) {
#line 657 "test.vala"
		_tmp0_ = TRUE;
#line 7814 "test.c"
	} else {
		gchar* _tmp15_;
		gchar* _tmp16_;
		const gchar* _tmp17_;
		gchar* _tmp18_;
		gchar** _tmp19_;
		gchar** _tmp20_;
		gint _tmp20__length1;
#line 659 "test.vala"
		_tmp15_ = g_strdup ("chmod");
#line 659 "test.vala"
		_tmp16_ = g_strdup ("755");
#line 659 "test.vala"
		_tmp17_ = ((TestRpl*) self)->test_result_dir;
#line 659 "test.vala"
		_tmp18_ = g_strdup (_tmp17_);
#line 659 "test.vala"
		_tmp19_ = g_new0 (gchar*, 3 + 1);
#line 659 "test.vala"
		_tmp19_[0] = _tmp15_;
#line 659 "test.vala"
		_tmp19_[1] = _tmp16_;
#line 659 "test.vala"
		_tmp19_[2] = _tmp18_;
#line 659 "test.vala"
		_tmp20_ = _tmp19_;
#line 659 "test.vala"
		_tmp20__length1 = 3;
#line 659 "test.vala"
		_tmp0_ = !try_sudo (_tmp20_, (gint) 3);
#line 659 "test.vala"
		_tmp20_ = (_vala_array_free (_tmp20_, _tmp20__length1, (GDestroyNotify) g_free), NULL);
#line 7847 "test.c"
	}
#line 657 "test.vala"
	if (_tmp0_) {
#line 660 "test.vala"
		return;
#line 7853 "test.c"
	}
#line 662 "test.vala"
	_tmp21_ = g_strdup ("--force");
#line 662 "test.vala"
	_tmp22_ = g_strdup ("amét");
#line 662 "test.vala"
	_tmp23_ = g_strdup ("amèt");
#line 662 "test.vala"
	_tmp24_ = ((TestRplOutputFile*) self)->test_result_root;
#line 662 "test.vala"
	_tmp25_ = g_strdup (_tmp24_);
#line 662 "test.vala"
	_tmp26_ = g_new0 (gchar*, 4 + 1);
#line 662 "test.vala"
	_tmp26_[0] = _tmp21_;
#line 662 "test.vala"
	_tmp26_[1] = _tmp22_;
#line 662 "test.vala"
	_tmp26_[2] = _tmp23_;
#line 662 "test.vala"
	_tmp26_[3] = _tmp25_;
#line 662 "test.vala"
	_tmp27_ = _tmp26_;
#line 662 "test.vala"
	_tmp27__length1 = 4;
#line 662 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp27_, (gint) 4, 0, &_tmp28_);
#line 662 "test.vala"
	_tmp29_ = _tmp28_;
#line 662 "test.vala"
	_tmp27_ = (_vala_array_free (_tmp27_, _tmp27__length1, (GDestroyNotify) g_free), NULL);
#line 662 "test.vala"
	output = _tmp29_;
#line 663 "test.vala"
	_tmp30_ = output;
#line 663 "test.vala"
	_tmp31_ = _tmp30_.std_err;
#line 663 "test.vala"
	g_assert_true (string_contains (_tmp31_, "unable to set attributes"));
#line 664 "test.vala"
	_tmp32_ = output;
#line 664 "test.vala"
	_tmp33_ = _tmp32_.std_err;
#line 664 "test.vala"
	g_assert_true (string_contains (_tmp33_, "new file attributes may not match"));
#line 656 "test.vala"
	output_destroy (&output);
#line 7901 "test.c"
}

static void
lorem_utf8_tests_test_set_attributes_fail (LoremUtf8Tests* self)
{
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar** _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	gboolean _tmp8_;
	Output output = {0};
	gchar* _tmp21_;
	gchar* _tmp22_;
	const gchar* _tmp23_;
	gchar* _tmp24_;
	gchar** _tmp25_;
	gchar** _tmp26_;
	gint _tmp26__length1;
	Output _tmp27_ = {0};
	Output _tmp28_;
	Output _tmp29_;
	const gchar* _tmp30_;
	Output _tmp31_;
	const gchar* _tmp32_;
#line 667 "test.vala"
	g_return_if_fail (self != NULL);
#line 668 "test.vala"
	_tmp2_ = g_strdup ("chown");
#line 668 "test.vala"
	_tmp3_ = g_strdup ("0:0");
#line 668 "test.vala"
	_tmp4_ = ((TestRplOutputFile*) self)->test_result_root;
#line 668 "test.vala"
	_tmp5_ = g_strdup (_tmp4_);
#line 668 "test.vala"
	_tmp6_ = g_new0 (gchar*, 3 + 1);
#line 668 "test.vala"
	_tmp6_[0] = _tmp2_;
#line 668 "test.vala"
	_tmp6_[1] = _tmp3_;
#line 668 "test.vala"
	_tmp6_[2] = _tmp5_;
#line 668 "test.vala"
	_tmp7_ = _tmp6_;
#line 668 "test.vala"
	_tmp7__length1 = 3;
#line 668 "test.vala"
	_tmp8_ = !try_sudo (_tmp7_, (gint) 3);
#line 668 "test.vala"
	_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
#line 668 "test.vala"
	if (_tmp8_) {
#line 668 "test.vala"
		_tmp1_ = TRUE;
#line 7961 "test.c"
	} else {
		gchar* _tmp9_;
		gchar* _tmp10_;
		const gchar* _tmp11_;
		gchar* _tmp12_;
		gchar** _tmp13_;
		gchar** _tmp14_;
		gint _tmp14__length1;
#line 669 "test.vala"
		_tmp9_ = g_strdup ("chmod");
#line 669 "test.vala"
		_tmp10_ = g_strdup ("777");
#line 669 "test.vala"
		_tmp11_ = ((TestRplOutputFile*) self)->test_result_root;
#line 669 "test.vala"
		_tmp12_ = g_strdup (_tmp11_);
#line 669 "test.vala"
		_tmp13_ = g_new0 (gchar*, 3 + 1);
#line 669 "test.vala"
		_tmp13_[0] = _tmp9_;
#line 669 "test.vala"
		_tmp13_[1] = _tmp10_;
#line 669 "test.vala"
		_tmp13_[2] = _tmp12_;
#line 669 "test.vala"
		_tmp14_ = _tmp13_;
#line 669 "test.vala"
		_tmp14__length1 = 3;
#line 669 "test.vala"
		_tmp1_ = !try_sudo (_tmp14_, (gint) 3);
#line 669 "test.vala"
		_tmp14_ = (_vala_array_free (_tmp14_, _tmp14__length1, (GDestroyNotify) g_free), NULL);
#line 7994 "test.c"
	}
#line 668 "test.vala"
	if (_tmp1_) {
#line 668 "test.vala"
		_tmp0_ = TRUE;
#line 8000 "test.c"
	} else {
		gchar* _tmp15_;
		gchar* _tmp16_;
		const gchar* _tmp17_;
		gchar* _tmp18_;
		gchar** _tmp19_;
		gchar** _tmp20_;
		gint _tmp20__length1;
#line 670 "test.vala"
		_tmp15_ = g_strdup ("chmod");
#line 670 "test.vala"
		_tmp16_ = g_strdup ("755");
#line 670 "test.vala"
		_tmp17_ = ((TestRpl*) self)->test_result_dir;
#line 670 "test.vala"
		_tmp18_ = g_strdup (_tmp17_);
#line 670 "test.vala"
		_tmp19_ = g_new0 (gchar*, 3 + 1);
#line 670 "test.vala"
		_tmp19_[0] = _tmp15_;
#line 670 "test.vala"
		_tmp19_[1] = _tmp16_;
#line 670 "test.vala"
		_tmp19_[2] = _tmp18_;
#line 670 "test.vala"
		_tmp20_ = _tmp19_;
#line 670 "test.vala"
		_tmp20__length1 = 3;
#line 670 "test.vala"
		_tmp0_ = !try_sudo (_tmp20_, (gint) 3);
#line 670 "test.vala"
		_tmp20_ = (_vala_array_free (_tmp20_, _tmp20__length1, (GDestroyNotify) g_free), NULL);
#line 8033 "test.c"
	}
#line 668 "test.vala"
	if (_tmp0_) {
#line 671 "test.vala"
		return;
#line 8039 "test.c"
	}
#line 673 "test.vala"
	_tmp21_ = g_strdup ("amét");
#line 673 "test.vala"
	_tmp22_ = g_strdup ("amèt");
#line 673 "test.vala"
	_tmp23_ = ((TestRplOutputFile*) self)->test_result_root;
#line 673 "test.vala"
	_tmp24_ = g_strdup (_tmp23_);
#line 673 "test.vala"
	_tmp25_ = g_new0 (gchar*, 3 + 1);
#line 673 "test.vala"
	_tmp25_[0] = _tmp21_;
#line 673 "test.vala"
	_tmp25_[1] = _tmp22_;
#line 673 "test.vala"
	_tmp25_[2] = _tmp24_;
#line 673 "test.vala"
	_tmp26_ = _tmp25_;
#line 673 "test.vala"
	_tmp26__length1 = 3;
#line 673 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp26_, (gint) 3, 0, &_tmp27_);
#line 673 "test.vala"
	_tmp28_ = _tmp27_;
#line 673 "test.vala"
	_tmp26_ = (_vala_array_free (_tmp26_, _tmp26__length1, (GDestroyNotify) g_free), NULL);
#line 673 "test.vala"
	output = _tmp28_;
#line 674 "test.vala"
	_tmp29_ = output;
#line 674 "test.vala"
	_tmp30_ = _tmp29_.std_err;
#line 674 "test.vala"
	g_assert_true (string_contains (_tmp30_, "unable to set attributes"));
#line 675 "test.vala"
	_tmp31_ = output;
#line 675 "test.vala"
	_tmp32_ = _tmp31_.std_err;
#line 675 "test.vala"
	g_assert_true (string_contains (_tmp32_, "skipping"));
#line 667 "test.vala"
	output_destroy (&output);
#line 8083 "test.c"
}

static void
lorem_utf8_tests_test_unreadable_input (LoremUtf8Tests* self)
{
	const gchar* _tmp0_;
	Output output = {0};
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	Output _tmp9_;
	const gchar* _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	gchar* _tmp13_;
	gchar* _tmp14_;
#line 678 "test.vala"
	g_return_if_fail (self != NULL);
#line 682 "test.vala"
	_tmp0_ = ((TestRplOutputFile*) self)->test_result_root;
#line 682 "test.vala"
	g_assert_true (chmod (_tmp0_, (mode_t) 0000) == 0);
#line 683 "test.vala"
	_tmp1_ = g_strdup ("amét");
#line 683 "test.vala"
	_tmp2_ = g_strdup ("amèt");
#line 683 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 683 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 683 "test.vala"
	_tmp5_ = g_new0 (gchar*, 3 + 1);
#line 683 "test.vala"
	_tmp5_[0] = _tmp1_;
#line 683 "test.vala"
	_tmp5_[1] = _tmp2_;
#line 683 "test.vala"
	_tmp5_[2] = _tmp4_;
#line 683 "test.vala"
	_tmp6_ = _tmp5_;
#line 683 "test.vala"
	_tmp6__length1 = 3;
#line 683 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 3, 0, &_tmp7_);
#line 683 "test.vala"
	_tmp8_ = _tmp7_;
#line 683 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 683 "test.vala"
	output = _tmp8_;
#line 684 "test.vala"
	_tmp9_ = output;
#line 684 "test.vala"
	_tmp10_ = _tmp9_.std_err;
#line 684 "test.vala"
	_tmp11_ = ((TestRplOutputFile*) self)->test_result_root;
#line 684 "test.vala"
	_tmp12_ = string_to_string (_tmp11_);
#line 684 "test.vala"
	_tmp13_ = g_strconcat ("skipping ", _tmp12_, NULL);
#line 684 "test.vala"
	_tmp14_ = _tmp13_;
#line 684 "test.vala"
	g_assert_true (string_contains (_tmp10_, _tmp14_));
#line 684 "test.vala"
	_g_free0 (_tmp14_);
#line 678 "test.vala"
	output_destroy (&output);
#line 8158 "test.c"
}

static void
lorem_utf8_tests_test_unwritable_input (LoremUtf8Tests* self)
{
	const gchar* _tmp0_;
	const gchar* _tmp1_;
	Output output = {0};
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar** _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	Output _tmp8_ = {0};
	Output _tmp9_;
	Output _tmp10_;
	const gchar* _tmp11_;
	const gchar* _tmp12_;
	const gchar* _tmp13_;
	gchar* _tmp14_;
	gchar* _tmp15_;
	const gchar* _tmp16_;
#line 688 "test.vala"
	g_return_if_fail (self != NULL);
#line 692 "test.vala"
	_tmp0_ = ((TestRpl*) self)->test_result_dir;
#line 692 "test.vala"
	g_assert_true (chmod (_tmp0_, (mode_t) 0500) == 0);
#line 693 "test.vala"
	_tmp1_ = ((TestRplOutputFile*) self)->test_result_root;
#line 693 "test.vala"
	g_assert_true (chmod (_tmp1_, (mode_t) 0777) == 0);
#line 694 "test.vala"
	_tmp2_ = g_strdup ("amét");
#line 694 "test.vala"
	_tmp3_ = g_strdup ("amèt");
#line 694 "test.vala"
	_tmp4_ = ((TestRplOutputFile*) self)->test_result_root;
#line 694 "test.vala"
	_tmp5_ = g_strdup (_tmp4_);
#line 694 "test.vala"
	_tmp6_ = g_new0 (gchar*, 3 + 1);
#line 694 "test.vala"
	_tmp6_[0] = _tmp2_;
#line 694 "test.vala"
	_tmp6_[1] = _tmp3_;
#line 694 "test.vala"
	_tmp6_[2] = _tmp5_;
#line 694 "test.vala"
	_tmp7_ = _tmp6_;
#line 694 "test.vala"
	_tmp7__length1 = 3;
#line 694 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp7_, (gint) 3, 0, &_tmp8_);
#line 694 "test.vala"
	_tmp9_ = _tmp8_;
#line 694 "test.vala"
	_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
#line 694 "test.vala"
	output = _tmp9_;
#line 695 "test.vala"
	_tmp10_ = output;
#line 695 "test.vala"
	_tmp11_ = _tmp10_.std_err;
#line 695 "test.vala"
	_tmp12_ = ((TestRplOutputFile*) self)->test_result_root;
#line 695 "test.vala"
	_tmp13_ = string_to_string (_tmp12_);
#line 695 "test.vala"
	_tmp14_ = g_strconcat ("skipping ", _tmp13_, NULL);
#line 695 "test.vala"
	_tmp15_ = _tmp14_;
#line 695 "test.vala"
	g_assert_true (string_contains (_tmp11_, _tmp15_));
#line 695 "test.vala"
	_g_free0 (_tmp15_);
#line 697 "test.vala"
	_tmp16_ = ((TestRpl*) self)->test_result_dir;
#line 697 "test.vala"
	g_assert_true (chmod (_tmp16_, (mode_t) 0700) == 0);
#line 688 "test.vala"
	output_destroy (&output);
#line 8243 "test.c"
}

static void
lorem_utf8_tests_class_init (LoremUtf8TestsClass * klass,
                             gpointer klass_data)
{
#line 544 "test.vala"
	lorem_utf8_tests_parent_class = g_type_class_peek_parent (klass);
#line 8252 "test.c"
}

static void
lorem_utf8_tests_instance_init (LoremUtf8Tests * self,
                                gpointer klass)
{
}

static GType
lorem_utf8_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (LoremUtf8TestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) lorem_utf8_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (LoremUtf8Tests), 0, (GInstanceInitFunc) lorem_utf8_tests_instance_init, NULL };
	GType lorem_utf8_tests_type_id;
	lorem_utf8_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "LoremUtf8Tests", &g_define_type_info, 0);
	return lorem_utf8_tests_type_id;
}

GType
lorem_utf8_tests_get_type (void)
{
	static volatile gsize lorem_utf8_tests_type_id__once = 0;
	if (g_once_init_enter (&lorem_utf8_tests_type_id__once)) {
		GType lorem_utf8_tests_type_id;
		lorem_utf8_tests_type_id = lorem_utf8_tests_get_type_once ();
		g_once_init_leave (&lorem_utf8_tests_type_id__once, lorem_utf8_tests_type_id);
	}
	return lorem_utf8_tests_type_id__once;
}

static void
_utf8_sig_tests_test_utf_8_sig_gee_test_case_test_method (gpointer self)
{
#line 705 "test.vala"
	utf8_sig_tests_test_utf_8_sig ((Utf8SigTests*) self);
#line 8287 "test.c"
}

Utf8SigTests*
utf8_sig_tests_construct (GType object_type,
                          const gchar* bin_dir,
                          const gchar* test_files_dir)
{
	Utf8SigTests * self = NULL;
#line 703 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 703 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 704 "test.vala"
	self = (Utf8SigTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "utf-8-sig.txt");
#line 705 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_utf_8_sig", _utf8_sig_tests_test_utf_8_sig_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 703 "test.vala"
	return self;
#line 8306 "test.c"
}

Utf8SigTests*
utf8_sig_tests_new (const gchar* bin_dir,
                    const gchar* test_files_dir)
{
#line 703 "test.vala"
	return utf8_sig_tests_construct (TYPE_UTF8_SIG_TESTS, bin_dir, test_files_dir);
#line 8315 "test.c"
}

static void
utf8_sig_tests_test_utf_8_sig (Utf8SigTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
#line 708 "test.vala"
	g_return_if_fail (self != NULL);
#line 709 "test.vala"
	_tmp0_ = g_strdup ("BOM mark");
#line 709 "test.vala"
	_tmp1_ = g_strdup ("BOM");
#line 709 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 709 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 709 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 709 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 709 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 709 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 709 "test.vala"
	_tmp5_ = _tmp4_;
#line 709 "test.vala"
	_tmp5__length1 = 3;
#line 709 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 709 "test.vala"
	_tmp7_ = _tmp6_;
#line 709 "test.vala"
	output_destroy (&_tmp7_);
#line 709 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 710 "test.vala"
	_tmp8_ = ((TestRpl*) self)->test_files_dir;
#line 710 "test.vala"
	_tmp9_ = g_build_filename (_tmp8_, "utf-8-sig_utf-8-sig_expected.txt", NULL);
#line 710 "test.vala"
	_tmp10_ = _tmp9_;
#line 710 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp10_));
#line 710 "test.vala"
	_g_free0 (_tmp10_);
#line 8373 "test.c"
}

static void
utf8_sig_tests_class_init (Utf8SigTestsClass * klass,
                           gpointer klass_data)
{
#line 702 "test.vala"
	utf8_sig_tests_parent_class = g_type_class_peek_parent (klass);
#line 8382 "test.c"
}

static void
utf8_sig_tests_instance_init (Utf8SigTests * self,
                              gpointer klass)
{
}

static GType
utf8_sig_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (Utf8SigTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) utf8_sig_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Utf8SigTests), 0, (GInstanceInitFunc) utf8_sig_tests_instance_init, NULL };
	GType utf8_sig_tests_type_id;
	utf8_sig_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "Utf8SigTests", &g_define_type_info, 0);
	return utf8_sig_tests_type_id;
}

GType
utf8_sig_tests_get_type (void)
{
	static volatile gsize utf8_sig_tests_type_id__once = 0;
	if (g_once_init_enter (&utf8_sig_tests_type_id__once)) {
		GType utf8_sig_tests_type_id;
		utf8_sig_tests_type_id = utf8_sig_tests_get_type_once ();
		g_once_init_leave (&utf8_sig_tests_type_id__once, utf8_sig_tests_type_id);
	}
	return utf8_sig_tests_type_id__once;
}

static void
_mixed_case_tests_test_mixed_replace_lower_gee_test_case_test_method (gpointer self)
{
#line 717 "test.vala"
	mixed_case_tests_test_mixed_replace_lower ((MixedCaseTests*) self);
#line 8417 "test.c"
}

MixedCaseTests*
mixed_case_tests_construct (GType object_type,
                            const gchar* bin_dir,
                            const gchar* test_files_dir)
{
	MixedCaseTests * self = NULL;
#line 715 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 715 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 716 "test.vala"
	self = (MixedCaseTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "mixed-case.txt");
#line 717 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_mixed_replace_lower", _mixed_case_tests_test_mixed_replace_lower_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 715 "test.vala"
	return self;
#line 8436 "test.c"
}

MixedCaseTests*
mixed_case_tests_new (const gchar* bin_dir,
                      const gchar* test_files_dir)
{
#line 715 "test.vala"
	return mixed_case_tests_construct (TYPE_MIXED_CASE_TESTS, bin_dir, test_files_dir);
#line 8445 "test.c"
}

static void
mixed_case_tests_test_mixed_replace_lower (MixedCaseTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 720 "test.vala"
	g_return_if_fail (self != NULL);
#line 721 "test.vala"
	_tmp0_ = g_strdup ("-m");
#line 721 "test.vala"
	_tmp1_ = g_strdup ("MixedInput");
#line 721 "test.vala"
	_tmp2_ = g_strdup ("MixedOutput");
#line 721 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 721 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 721 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 721 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 721 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 721 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 721 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 721 "test.vala"
	_tmp6_ = _tmp5_;
#line 721 "test.vala"
	_tmp6__length1 = 4;
#line 721 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 721 "test.vala"
	_tmp8_ = _tmp7_;
#line 721 "test.vala"
	output_destroy (&_tmp8_);
#line 721 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 722 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 722 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "mixed-case_mixed-replace-lower_expected.txt", NULL);
#line 722 "test.vala"
	_tmp11_ = _tmp10_;
#line 722 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 722 "test.vala"
	_g_free0 (_tmp11_);
#line 8508 "test.c"
}

static void
mixed_case_tests_class_init (MixedCaseTestsClass * klass,
                             gpointer klass_data)
{
#line 714 "test.vala"
	mixed_case_tests_parent_class = g_type_class_peek_parent (klass);
#line 8517 "test.c"
}

static void
mixed_case_tests_instance_init (MixedCaseTests * self,
                                gpointer klass)
{
}

static GType
mixed_case_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (MixedCaseTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) mixed_case_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MixedCaseTests), 0, (GInstanceInitFunc) mixed_case_tests_instance_init, NULL };
	GType mixed_case_tests_type_id;
	mixed_case_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "MixedCaseTests", &g_define_type_info, 0);
	return mixed_case_tests_type_id;
}

GType
mixed_case_tests_get_type (void)
{
	static volatile gsize mixed_case_tests_type_id__once = 0;
	if (g_once_init_enter (&mixed_case_tests_type_id__once)) {
		GType mixed_case_tests_type_id;
		mixed_case_tests_type_id = mixed_case_tests_get_type_once ();
		g_once_init_leave (&mixed_case_tests_type_id__once, mixed_case_tests_type_id);
	}
	return mixed_case_tests_type_id__once;
}

static void
_backreference_tests_test_backreference_numbering_gee_test_case_test_method (gpointer self)
{
#line 729 "test.vala"
	backreference_tests_test_backreference_numbering ((BackreferenceTests*) self);
#line 8552 "test.c"
}

BackreferenceTests*
backreference_tests_construct (GType object_type,
                               const gchar* bin_dir,
                               const gchar* test_files_dir)
{
	BackreferenceTests * self = NULL;
#line 727 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 727 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 728 "test.vala"
	self = (BackreferenceTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "aba.txt");
#line 729 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_backreference_numbering", _backreference_tests_test_backreference_numbering_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 727 "test.vala"
	return self;
#line 8571 "test.c"
}

BackreferenceTests*
backreference_tests_new (const gchar* bin_dir,
                         const gchar* test_files_dir)
{
#line 727 "test.vala"
	return backreference_tests_construct (TYPE_BACKREFERENCE_TESTS, bin_dir, test_files_dir);
#line 8580 "test.c"
}

static void
backreference_tests_test_backreference_numbering (BackreferenceTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
#line 732 "test.vala"
	g_return_if_fail (self != NULL);
#line 733 "test.vala"
	_tmp0_ = g_strdup ("a(b)a");
#line 733 "test.vala"
	_tmp1_ = g_strdup ("$1");
#line 733 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 733 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 733 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 733 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 733 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 733 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 733 "test.vala"
	_tmp5_ = _tmp4_;
#line 733 "test.vala"
	_tmp5__length1 = 3;
#line 733 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 733 "test.vala"
	_tmp7_ = _tmp6_;
#line 733 "test.vala"
	output_destroy (&_tmp7_);
#line 733 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 734 "test.vala"
	_tmp8_ = ((TestRpl*) self)->test_files_dir;
#line 734 "test.vala"
	_tmp9_ = g_build_filename (_tmp8_, "aba_backreference-numbering_expected.txt", NULL);
#line 734 "test.vala"
	_tmp10_ = _tmp9_;
#line 734 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp10_));
#line 734 "test.vala"
	_g_free0 (_tmp10_);
#line 8638 "test.c"
}

static void
backreference_tests_class_init (BackreferenceTestsClass * klass,
                                gpointer klass_data)
{
#line 726 "test.vala"
	backreference_tests_parent_class = g_type_class_peek_parent (klass);
#line 8647 "test.c"
}

static void
backreference_tests_instance_init (BackreferenceTests * self,
                                   gpointer klass)
{
}

static GType
backreference_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (BackreferenceTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) backreference_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (BackreferenceTests), 0, (GInstanceInitFunc) backreference_tests_instance_init, NULL };
	GType backreference_tests_type_id;
	backreference_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "BackreferenceTests", &g_define_type_info, 0);
	return backreference_tests_type_id;
}

GType
backreference_tests_get_type (void)
{
	static volatile gsize backreference_tests_type_id__once = 0;
	if (g_once_init_enter (&backreference_tests_type_id__once)) {
		GType backreference_tests_type_id;
		backreference_tests_type_id = backreference_tests_get_type_once ();
		g_once_init_leave (&backreference_tests_type_id__once, backreference_tests_type_id);
	}
	return backreference_tests_type_id__once;
}

static void
_empty_matches_tests_test_empty_matches_gee_test_case_test_method (gpointer self)
{
#line 741 "test.vala"
	empty_matches_tests_test_empty_matches ((EmptyMatchesTests*) self);
#line 8682 "test.c"
}

EmptyMatchesTests*
empty_matches_tests_construct (GType object_type,
                               const gchar* bin_dir,
                               const gchar* test_files_dir)
{
	EmptyMatchesTests * self = NULL;
#line 739 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 739 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 740 "test.vala"
	self = (EmptyMatchesTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "abc-123.txt");
#line 741 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_empty_matches", _empty_matches_tests_test_empty_matches_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 739 "test.vala"
	return self;
#line 8701 "test.c"
}

EmptyMatchesTests*
empty_matches_tests_new (const gchar* bin_dir,
                         const gchar* test_files_dir)
{
#line 739 "test.vala"
	return empty_matches_tests_construct (TYPE_EMPTY_MATCHES_TESTS, bin_dir, test_files_dir);
#line 8710 "test.c"
}

static void
empty_matches_tests_test_empty_matches (EmptyMatchesTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_;
	gchar** _tmp5_;
	gint _tmp5__length1;
	Output _tmp6_ = {0};
	Output _tmp7_;
	const gchar* _tmp8_;
	gchar* _tmp9_;
	gchar* _tmp10_;
#line 744 "test.vala"
	g_return_if_fail (self != NULL);
#line 745 "test.vala"
	_tmp0_ = g_strdup ("^");
#line 745 "test.vala"
	_tmp1_ = g_strdup ("#");
#line 745 "test.vala"
	_tmp2_ = ((TestRplOutputFile*) self)->test_result_root;
#line 745 "test.vala"
	_tmp3_ = g_strdup (_tmp2_);
#line 745 "test.vala"
	_tmp4_ = g_new0 (gchar*, 3 + 1);
#line 745 "test.vala"
	_tmp4_[0] = _tmp0_;
#line 745 "test.vala"
	_tmp4_[1] = _tmp1_;
#line 745 "test.vala"
	_tmp4_[2] = _tmp3_;
#line 745 "test.vala"
	_tmp5_ = _tmp4_;
#line 745 "test.vala"
	_tmp5__length1 = 3;
#line 745 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp5_, (gint) 3, 0, &_tmp6_);
#line 745 "test.vala"
	_tmp7_ = _tmp6_;
#line 745 "test.vala"
	output_destroy (&_tmp7_);
#line 745 "test.vala"
	_tmp5_ = (_vala_array_free (_tmp5_, _tmp5__length1, (GDestroyNotify) g_free), NULL);
#line 746 "test.vala"
	_tmp8_ = ((TestRpl*) self)->test_files_dir;
#line 746 "test.vala"
	_tmp9_ = g_build_filename (_tmp8_, "abc-123_empty-matches_expected.txt", NULL);
#line 746 "test.vala"
	_tmp10_ = _tmp9_;
#line 746 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp10_));
#line 746 "test.vala"
	_g_free0 (_tmp10_);
#line 8768 "test.c"
}

static void
empty_matches_tests_class_init (EmptyMatchesTestsClass * klass,
                                gpointer klass_data)
{
#line 738 "test.vala"
	empty_matches_tests_parent_class = g_type_class_peek_parent (klass);
#line 8777 "test.c"
}

static void
empty_matches_tests_instance_init (EmptyMatchesTests * self,
                                   gpointer klass)
{
}

static GType
empty_matches_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (EmptyMatchesTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) empty_matches_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (EmptyMatchesTests), 0, (GInstanceInitFunc) empty_matches_tests_instance_init, NULL };
	GType empty_matches_tests_type_id;
	empty_matches_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "EmptyMatchesTests", &g_define_type_info, 0);
	return empty_matches_tests_type_id;
}

GType
empty_matches_tests_get_type (void)
{
	static volatile gsize empty_matches_tests_type_id__once = 0;
	if (g_once_init_enter (&empty_matches_tests_type_id__once)) {
		GType empty_matches_tests_type_id;
		empty_matches_tests_type_id = empty_matches_tests_get_type_once ();
		g_once_init_leave (&empty_matches_tests_type_id__once, empty_matches_tests_type_id);
	}
	return empty_matches_tests_type_id__once;
}

static void
_dir_tests_test_recursive_gee_test_case_test_method (gpointer self)
{
#line 753 "test.vala"
	dir_tests_test_recursive ((DirTests*) self);
#line 8812 "test.c"
}

static void
_dir_tests_test_backup_gee_test_case_test_method (gpointer self)
{
#line 754 "test.vala"
	dir_tests_test_backup ((DirTests*) self);
#line 8820 "test.c"
}

DirTests*
dir_tests_construct (GType object_type,
                     const gchar* bin_dir,
                     const gchar* test_files_dir)
{
	DirTests * self = NULL;
#line 751 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 751 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 752 "test.vala"
	self = (DirTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "test-dir");
#line 753 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_recursive", _dir_tests_test_recursive_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 754 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_backup", _dir_tests_test_backup_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 751 "test.vala"
	return self;
#line 8841 "test.c"
}

DirTests*
dir_tests_new (const gchar* bin_dir,
               const gchar* test_files_dir)
{
#line 751 "test.vala"
	return dir_tests_construct (TYPE_DIR_TESTS, bin_dir, test_files_dir);
#line 8850 "test.c"
}

static void
dir_tests_test_recursive (DirTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	const gchar* _tmp3_;
	gchar* _tmp4_;
	gchar** _tmp5_;
	gchar** _tmp6_;
	gint _tmp6__length1;
	Output _tmp7_ = {0};
	Output _tmp8_;
	const gchar* _tmp9_;
	gchar* _tmp10_;
	gchar* _tmp11_;
#line 757 "test.vala"
	g_return_if_fail (self != NULL);
#line 758 "test.vala"
	_tmp0_ = g_strdup ("--recursive");
#line 758 "test.vala"
	_tmp1_ = g_strdup ("foo");
#line 758 "test.vala"
	_tmp2_ = g_strdup ("bar");
#line 758 "test.vala"
	_tmp3_ = ((TestRplOutputFile*) self)->test_result_root;
#line 758 "test.vala"
	_tmp4_ = g_strdup (_tmp3_);
#line 758 "test.vala"
	_tmp5_ = g_new0 (gchar*, 4 + 1);
#line 758 "test.vala"
	_tmp5_[0] = _tmp0_;
#line 758 "test.vala"
	_tmp5_[1] = _tmp1_;
#line 758 "test.vala"
	_tmp5_[2] = _tmp2_;
#line 758 "test.vala"
	_tmp5_[3] = _tmp4_;
#line 758 "test.vala"
	_tmp6_ = _tmp5_;
#line 758 "test.vala"
	_tmp6__length1 = 4;
#line 758 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp6_, (gint) 4, 0, &_tmp7_);
#line 758 "test.vala"
	_tmp8_ = _tmp7_;
#line 758 "test.vala"
	output_destroy (&_tmp8_);
#line 758 "test.vala"
	_tmp6_ = (_vala_array_free (_tmp6_, _tmp6__length1, (GDestroyNotify) g_free), NULL);
#line 759 "test.vala"
	_tmp9_ = ((TestRpl*) self)->test_files_dir;
#line 759 "test.vala"
	_tmp10_ = g_build_filename (_tmp9_, "test-dir-expected", NULL);
#line 759 "test.vala"
	_tmp11_ = _tmp10_;
#line 759 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp11_));
#line 759 "test.vala"
	_g_free0 (_tmp11_);
#line 8913 "test.c"
}

static void
dir_tests_test_backup (DirTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar** _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	Output _tmp8_ = {0};
	Output _tmp9_;
	const gchar* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
#line 762 "test.vala"
	g_return_if_fail (self != NULL);
#line 763 "test.vala"
	_tmp0_ = g_strdup ("--backup");
#line 763 "test.vala"
	_tmp1_ = g_strdup ("--recursive");
#line 763 "test.vala"
	_tmp2_ = g_strdup ("foo");
#line 763 "test.vala"
	_tmp3_ = g_strdup ("bar");
#line 763 "test.vala"
	_tmp4_ = ((TestRplOutputFile*) self)->test_result_root;
#line 763 "test.vala"
	_tmp5_ = g_strdup (_tmp4_);
#line 763 "test.vala"
	_tmp6_ = g_new0 (gchar*, 5 + 1);
#line 763 "test.vala"
	_tmp6_[0] = _tmp0_;
#line 763 "test.vala"
	_tmp6_[1] = _tmp1_;
#line 763 "test.vala"
	_tmp6_[2] = _tmp2_;
#line 763 "test.vala"
	_tmp6_[3] = _tmp3_;
#line 763 "test.vala"
	_tmp6_[4] = _tmp5_;
#line 763 "test.vala"
	_tmp7_ = _tmp6_;
#line 763 "test.vala"
	_tmp7__length1 = 5;
#line 763 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp7_, (gint) 5, 0, &_tmp8_);
#line 763 "test.vala"
	_tmp9_ = _tmp8_;
#line 763 "test.vala"
	output_destroy (&_tmp9_);
#line 763 "test.vala"
	_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
#line 764 "test.vala"
	_tmp10_ = ((TestRpl*) self)->test_files_dir;
#line 764 "test.vala"
	_tmp11_ = g_build_filename (_tmp10_, "test-dir-backup-expected", NULL);
#line 764 "test.vala"
	_tmp12_ = _tmp11_;
#line 764 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp12_));
#line 764 "test.vala"
	_g_free0 (_tmp12_);
#line 8981 "test.c"
}

static void
dir_tests_class_init (DirTestsClass * klass,
                      gpointer klass_data)
{
#line 750 "test.vala"
	dir_tests_parent_class = g_type_class_peek_parent (klass);
#line 8990 "test.c"
}

static void
dir_tests_instance_init (DirTests * self,
                         gpointer klass)
{
}

static GType
dir_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (DirTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) dir_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (DirTests), 0, (GInstanceInitFunc) dir_tests_instance_init, NULL };
	GType dir_tests_type_id;
	dir_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "DirTests", &g_define_type_info, 0);
	return dir_tests_type_id;
}

GType
dir_tests_get_type (void)
{
	static volatile gsize dir_tests_type_id__once = 0;
	if (g_once_init_enter (&dir_tests_type_id__once)) {
		GType dir_tests_type_id;
		dir_tests_type_id = dir_tests_get_type_once ();
		g_once_init_leave (&dir_tests_type_id__once, dir_tests_type_id);
	}
	return dir_tests_type_id__once;
}

static void
_glob_tests_test_globs_gee_test_case_test_method (gpointer self)
{
#line 771 "test.vala"
	glob_tests_test_globs ((GlobTests*) self);
#line 9025 "test.c"
}

static void
_glob_tests_test_globs_no_match_gee_test_case_test_method (gpointer self)
{
#line 772 "test.vala"
	glob_tests_test_globs_no_match ((GlobTests*) self);
#line 9033 "test.c"
}

GlobTests*
glob_tests_construct (GType object_type,
                      const gchar* bin_dir,
                      const gchar* test_files_dir)
{
	GlobTests * self = NULL;
#line 769 "test.vala"
	g_return_val_if_fail (bin_dir != NULL, NULL);
#line 769 "test.vala"
	g_return_val_if_fail (test_files_dir != NULL, NULL);
#line 770 "test.vala"
	self = (GlobTests*) test_rpl_file_construct (object_type, bin_dir, test_files_dir, "test-tree");
#line 771 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_globs", _glob_tests_test_globs_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 772 "test.vala"
	gee_test_case_add_test ((GeeTestCase*) self, "test_globs_no_match", _glob_tests_test_globs_no_match_gee_test_case_test_method, g_object_ref (self), g_object_unref);
#line 769 "test.vala"
	return self;
#line 9054 "test.c"
}

GlobTests*
glob_tests_new (const gchar* bin_dir,
                const gchar* test_files_dir)
{
#line 769 "test.vala"
	return glob_tests_construct (TYPE_GLOB_TESTS, bin_dir, test_files_dir);
#line 9063 "test.c"
}

static void
glob_tests_test_globs (GlobTests* self)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar** _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	Output _tmp8_ = {0};
	Output _tmp9_;
	const gchar* _tmp10_;
	gchar* _tmp11_;
	gchar* _tmp12_;
#line 775 "test.vala"
	g_return_if_fail (self != NULL);
#line 776 "test.vala"
	_tmp0_ = g_strdup ("--recursive");
#line 776 "test.vala"
	_tmp1_ = g_strdup ("--glob=*.txt");
#line 776 "test.vala"
	_tmp2_ = g_strdup ("foo");
#line 776 "test.vala"
	_tmp3_ = g_strdup ("bar");
#line 776 "test.vala"
	_tmp4_ = ((TestRplOutputFile*) self)->test_result_root;
#line 776 "test.vala"
	_tmp5_ = g_strdup (_tmp4_);
#line 776 "test.vala"
	_tmp6_ = g_new0 (gchar*, 5 + 1);
#line 776 "test.vala"
	_tmp6_[0] = _tmp0_;
#line 776 "test.vala"
	_tmp6_[1] = _tmp1_;
#line 776 "test.vala"
	_tmp6_[2] = _tmp2_;
#line 776 "test.vala"
	_tmp6_[3] = _tmp3_;
#line 776 "test.vala"
	_tmp6_[4] = _tmp5_;
#line 776 "test.vala"
	_tmp7_ = _tmp6_;
#line 776 "test.vala"
	_tmp7__length1 = 5;
#line 776 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp7_, (gint) 5, 0, &_tmp8_);
#line 776 "test.vala"
	_tmp9_ = _tmp8_;
#line 776 "test.vala"
	output_destroy (&_tmp9_);
#line 776 "test.vala"
	_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
#line 777 "test.vala"
	_tmp10_ = ((TestRpl*) self)->test_files_dir;
#line 777 "test.vala"
	_tmp11_ = g_build_filename (_tmp10_, "test-tree-expected", NULL);
#line 777 "test.vala"
	_tmp12_ = _tmp11_;
#line 777 "test.vala"
	g_assert_true (test_rpl_output_file_result_matches ((TestRplOutputFile*) self, _tmp12_));
#line 777 "test.vala"
	_g_free0 (_tmp12_);
#line 9131 "test.c"
}

static void
glob_tests_test_globs_no_match (GlobTests* self)
{
	Output output = {0};
	gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* _tmp2_;
	gchar* _tmp3_;
	const gchar* _tmp4_;
	gchar* _tmp5_;
	gchar** _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	Output _tmp8_ = {0};
	Output _tmp9_;
	Output _tmp10_;
	const gchar* _tmp11_;
#line 780 "test.vala"
	g_return_if_fail (self != NULL);
#line 781 "test.vala"
	_tmp0_ = g_strdup ("--recursive");
#line 781 "test.vala"
	_tmp1_ = g_strdup ("--glob=*.foo");
#line 781 "test.vala"
	_tmp2_ = g_strdup ("foo");
#line 781 "test.vala"
	_tmp3_ = g_strdup ("bar");
#line 781 "test.vala"
	_tmp4_ = ((TestRplOutputFile*) self)->test_result_root;
#line 781 "test.vala"
	_tmp5_ = g_strdup (_tmp4_);
#line 781 "test.vala"
	_tmp6_ = g_new0 (gchar*, 5 + 1);
#line 781 "test.vala"
	_tmp6_[0] = _tmp0_;
#line 781 "test.vala"
	_tmp6_[1] = _tmp1_;
#line 781 "test.vala"
	_tmp6_[2] = _tmp2_;
#line 781 "test.vala"
	_tmp6_[3] = _tmp3_;
#line 781 "test.vala"
	_tmp6_[4] = _tmp5_;
#line 781 "test.vala"
	_tmp7_ = _tmp6_;
#line 781 "test.vala"
	_tmp7__length1 = 5;
#line 781 "test.vala"
	test_rpl_run ((TestRpl*) self, _tmp7_, (gint) 5, 1, &_tmp8_);
#line 781 "test.vala"
	_tmp9_ = _tmp8_;
#line 781 "test.vala"
	_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
#line 781 "test.vala"
	output = _tmp9_;
#line 782 "test.vala"
	_tmp10_ = output;
#line 782 "test.vala"
	_tmp11_ = _tmp10_.std_err;
#line 782 "test.vala"
	g_assert_true (string_contains (_tmp11_, "the given filename patterns did not match any files!"));
#line 780 "test.vala"
	output_destroy (&output);
#line 9197 "test.c"
}

static void
glob_tests_class_init (GlobTestsClass * klass,
                       gpointer klass_data)
{
#line 768 "test.vala"
	glob_tests_parent_class = g_type_class_peek_parent (klass);
#line 9206 "test.c"
}

static void
glob_tests_instance_init (GlobTests * self,
                          gpointer klass)
{
}

static GType
glob_tests_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (GlobTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) glob_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GlobTests), 0, (GInstanceInitFunc) glob_tests_instance_init, NULL };
	GType glob_tests_type_id;
	glob_tests_type_id = g_type_register_static (TYPE_TEST_RPL_FILE, "GlobTests", &g_define_type_info, 0);
	return glob_tests_type_id;
}

GType
glob_tests_get_type (void)
{
	static volatile gsize glob_tests_type_id__once = 0;
	if (g_once_init_enter (&glob_tests_type_id__once)) {
		GType glob_tests_type_id;
		glob_tests_type_id = glob_tests_get_type_once ();
		g_once_init_leave (&glob_tests_type_id__once, glob_tests_type_id);
	}
	return glob_tests_type_id__once;
}

static gint
_vala_main (gchar** args,
            gint args_length1)
{
	gchar* test_files_dir = NULL;
	const gchar* _tmp0_;
	gchar* _tmp1_;
	gchar* bin_dir = NULL;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	GTestSuite* _tmp4_;
	NoFileTests* _tmp5_;
	NoFileTests* _tmp6_;
	GTestSuite* _tmp7_;
	GTestSuite* _tmp8_;
	OutputFileTests* _tmp9_;
	OutputFileTests* _tmp10_;
	GTestSuite* _tmp11_;
	GTestSuite* _tmp12_;
	EncodingTests* _tmp13_;
	EncodingTests* _tmp14_;
	GTestSuite* _tmp15_;
	GTestSuite* _tmp16_;
	LoremTests* _tmp17_;
	LoremTests* _tmp18_;
	GTestSuite* _tmp19_;
	GTestSuite* _tmp20_;
	LoremUtf8Tests* _tmp21_;
	LoremUtf8Tests* _tmp22_;
	GTestSuite* _tmp23_;
	GTestSuite* _tmp24_;
	Utf8SigTests* _tmp25_;
	Utf8SigTests* _tmp26_;
	GTestSuite* _tmp27_;
	GTestSuite* _tmp28_;
	MixedCaseTests* _tmp29_;
	MixedCaseTests* _tmp30_;
	GTestSuite* _tmp31_;
	GTestSuite* _tmp32_;
	BackreferenceTests* _tmp33_;
	BackreferenceTests* _tmp34_;
	GTestSuite* _tmp35_;
	GTestSuite* _tmp36_;
	EmptyMatchesTests* _tmp37_;
	EmptyMatchesTests* _tmp38_;
	GTestSuite* _tmp39_;
	GTestSuite* _tmp40_;
	DirTests* _tmp41_;
	DirTests* _tmp42_;
	GTestSuite* _tmp43_;
	GTestSuite* _tmp44_;
	GlobTests* _tmp45_;
	GlobTests* _tmp46_;
	GTestSuite* _tmp47_;
	gint result;
#line 787 "test.vala"
	_tmp0_ = g_getenv ("TEST_FILES_DIR");
#line 787 "test.vala"
	_tmp1_ = g_strdup (_tmp0_);
#line 787 "test.vala"
	test_files_dir = _tmp1_;
#line 788 "test.vala"
	_tmp2_ = args[0];
#line 788 "test.vala"
	_tmp3_ = g_path_get_dirname (_tmp2_);
#line 788 "test.vala"
	bin_dir = _tmp3_;
#line 789 "test.vala"
	g_test_init ((gint*) (&args_length1), &args, NULL);
#line 790 "test.vala"
	g_test_set_nonfatal_assertions ();
#line 791 "test.vala"
	_tmp4_ = g_test_get_root ();
#line 791 "test.vala"
	_tmp5_ = no_file_tests_new (bin_dir, test_files_dir);
#line 791 "test.vala"
	_tmp6_ = _tmp5_;
#line 791 "test.vala"
	_tmp7_ = gee_test_case_get_suite ((GeeTestCase*) _tmp6_);
#line 791 "test.vala"
	g_test_suite_add_suite (_tmp4_, _tmp7_);
#line 791 "test.vala"
	_g_object_unref0 (_tmp6_);
#line 792 "test.vala"
	_tmp8_ = g_test_get_root ();
#line 792 "test.vala"
	_tmp9_ = output_file_tests_new (bin_dir, test_files_dir);
#line 792 "test.vala"
	_tmp10_ = _tmp9_;
#line 792 "test.vala"
	_tmp11_ = gee_test_case_get_suite ((GeeTestCase*) _tmp10_);
#line 792 "test.vala"
	g_test_suite_add_suite (_tmp8_, _tmp11_);
#line 792 "test.vala"
	_g_object_unref0 (_tmp10_);
#line 793 "test.vala"
	_tmp12_ = g_test_get_root ();
#line 793 "test.vala"
	_tmp13_ = encoding_tests_new (bin_dir, test_files_dir);
#line 793 "test.vala"
	_tmp14_ = _tmp13_;
#line 793 "test.vala"
	_tmp15_ = gee_test_case_get_suite ((GeeTestCase*) _tmp14_);
#line 793 "test.vala"
	g_test_suite_add_suite (_tmp12_, _tmp15_);
#line 793 "test.vala"
	_g_object_unref0 (_tmp14_);
#line 794 "test.vala"
	_tmp16_ = g_test_get_root ();
#line 794 "test.vala"
	_tmp17_ = lorem_tests_new (bin_dir, test_files_dir);
#line 794 "test.vala"
	_tmp18_ = _tmp17_;
#line 794 "test.vala"
	_tmp19_ = gee_test_case_get_suite ((GeeTestCase*) _tmp18_);
#line 794 "test.vala"
	g_test_suite_add_suite (_tmp16_, _tmp19_);
#line 794 "test.vala"
	_g_object_unref0 (_tmp18_);
#line 795 "test.vala"
	_tmp20_ = g_test_get_root ();
#line 795 "test.vala"
	_tmp21_ = lorem_utf8_tests_new (bin_dir, test_files_dir);
#line 795 "test.vala"
	_tmp22_ = _tmp21_;
#line 795 "test.vala"
	_tmp23_ = gee_test_case_get_suite ((GeeTestCase*) _tmp22_);
#line 795 "test.vala"
	g_test_suite_add_suite (_tmp20_, _tmp23_);
#line 795 "test.vala"
	_g_object_unref0 (_tmp22_);
#line 796 "test.vala"
	_tmp24_ = g_test_get_root ();
#line 796 "test.vala"
	_tmp25_ = utf8_sig_tests_new (bin_dir, test_files_dir);
#line 796 "test.vala"
	_tmp26_ = _tmp25_;
#line 796 "test.vala"
	_tmp27_ = gee_test_case_get_suite ((GeeTestCase*) _tmp26_);
#line 796 "test.vala"
	g_test_suite_add_suite (_tmp24_, _tmp27_);
#line 796 "test.vala"
	_g_object_unref0 (_tmp26_);
#line 797 "test.vala"
	_tmp28_ = g_test_get_root ();
#line 797 "test.vala"
	_tmp29_ = mixed_case_tests_new (bin_dir, test_files_dir);
#line 797 "test.vala"
	_tmp30_ = _tmp29_;
#line 797 "test.vala"
	_tmp31_ = gee_test_case_get_suite ((GeeTestCase*) _tmp30_);
#line 797 "test.vala"
	g_test_suite_add_suite (_tmp28_, _tmp31_);
#line 797 "test.vala"
	_g_object_unref0 (_tmp30_);
#line 798 "test.vala"
	_tmp32_ = g_test_get_root ();
#line 798 "test.vala"
	_tmp33_ = backreference_tests_new (bin_dir, test_files_dir);
#line 798 "test.vala"
	_tmp34_ = _tmp33_;
#line 798 "test.vala"
	_tmp35_ = gee_test_case_get_suite ((GeeTestCase*) _tmp34_);
#line 798 "test.vala"
	g_test_suite_add_suite (_tmp32_, _tmp35_);
#line 798 "test.vala"
	_g_object_unref0 (_tmp34_);
#line 799 "test.vala"
	_tmp36_ = g_test_get_root ();
#line 799 "test.vala"
	_tmp37_ = empty_matches_tests_new (bin_dir, test_files_dir);
#line 799 "test.vala"
	_tmp38_ = _tmp37_;
#line 799 "test.vala"
	_tmp39_ = gee_test_case_get_suite ((GeeTestCase*) _tmp38_);
#line 799 "test.vala"
	g_test_suite_add_suite (_tmp36_, _tmp39_);
#line 799 "test.vala"
	_g_object_unref0 (_tmp38_);
#line 800 "test.vala"
	_tmp40_ = g_test_get_root ();
#line 800 "test.vala"
	_tmp41_ = dir_tests_new (bin_dir, test_files_dir);
#line 800 "test.vala"
	_tmp42_ = _tmp41_;
#line 800 "test.vala"
	_tmp43_ = gee_test_case_get_suite ((GeeTestCase*) _tmp42_);
#line 800 "test.vala"
	g_test_suite_add_suite (_tmp40_, _tmp43_);
#line 800 "test.vala"
	_g_object_unref0 (_tmp42_);
#line 801 "test.vala"
	_tmp44_ = g_test_get_root ();
#line 801 "test.vala"
	_tmp45_ = glob_tests_new (bin_dir, test_files_dir);
#line 801 "test.vala"
	_tmp46_ = _tmp45_;
#line 801 "test.vala"
	_tmp47_ = gee_test_case_get_suite ((GeeTestCase*) _tmp46_);
#line 801 "test.vala"
	g_test_suite_add_suite (_tmp44_, _tmp47_);
#line 801 "test.vala"
	_g_object_unref0 (_tmp46_);
#line 803 "test.vala"
	result = g_test_run ();
#line 803 "test.vala"
	_g_free0 (bin_dir);
#line 803 "test.vala"
	_g_free0 (test_files_dir);
#line 803 "test.vala"
	return result;
#line 9447 "test.c"
}

int
main (int argc,
      char ** argv)
{
#line 786 "test.vala"
	return _vala_main (argv, argc);
#line 9456 "test.c"
}

static void
_vala_array_destroy (gpointer array,
                     gssize array_length,
                     GDestroyNotify destroy_func)
{
	if ((array != NULL) && (destroy_func != NULL)) {
		gssize i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}

static void
_vala_array_free (gpointer array,
                  gssize array_length,
                  GDestroyNotify destroy_func)
{
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}

