wp/xed
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

initial

Browse Source
This commit is contained in:
Perberos
2011-11-07 16:46:58 -03:00
commit 528c1e5ff5
532 changed files with 709826 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
tests/Makefile.am Executable file
View File

@@ -0,0 +1,28 @@
INCLUDES = -g -I$(top_srcdir) -I$(top_srcdir)/gedit $(GEDIT_DEBUG_FLAGS) $(GEDIT_CFLAGS)
noinst_PROGRAMS = $(TEST_PROGS)
progs_ldadd = $(top_builddir)/gedit/libgedit.la
TEST_PROGS = smart-converter
smart_converter_SOURCES = smart-converter.c
smart_converter_LDADD = $(progs_ldadd)
TEST_PROGS += document-input-stream
document_input_stream_SOURCES = document-input-stream.c
document_input_stream_LDADD = $(progs_ldadd)
TEST_PROGS += document-output-stream
document_output_stream_SOURCES = document-output-stream.c
document_output_stream_LDADD = $(progs_ldadd)
TEST_PROGS += document-loader
document_loader_SOURCES = document-loader.c
document_loader_LDADD = $(progs_ldadd)
TEST_PROGS += document-saver
document_saver_SOURCES = document-saver.c
document_saver_LDADD = $(progs_ldadd)
TESTS = $(TEST_PROGS)
EXTRA_DIST = setup-document-saver.sh

156
tests/document-input-stream.c Executable file
View File

@@ -0,0 +1,156 @@
/*
* document-input-stream.c
* This file is part of gedit
*
* Copyright (C) 2010 - Ignacio Casal Quinteiro
*
* gedit 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 2 of the License, or
* (at your option) any later version.
*
* gedit 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 gedit; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "gedit-document-input-stream.h"
#include <gio/gio.h>
#include <gtk/gtk.h>
#include <glib.h>
#include <string.h>
static void
test_consecutive_read (const gchar *inbuf,
const gchar *outbuf,
GeditDocumentNewlineType type,
gsize read_chunk_len)
{
GtkTextBuffer *buf;
GInputStream *in;
gsize outlen;
gssize n, r;
GError *err = NULL;
gchar *b;
gboolean close;
buf = gtk_text_buffer_new (NULL);
gtk_text_buffer_set_text (buf, inbuf, -1);
b = g_malloc (200);
in = gedit_document_input_stream_new (buf, type);
outlen = strlen (outbuf);
n = 0;
do
{
r = g_input_stream_read (in, b + n, read_chunk_len, NULL, &err);
g_assert_cmpint (r, >=, 0);
g_assert_no_error (err);
n += r;
} while (r != 0);
g_assert_cmpint (n, ==, outlen);
b[n] = '\0';
g_assert_cmpstr (b, ==, outbuf);
close = g_input_stream_close (in, NULL, &err);
g_assert (close);
g_assert_no_error (err);
g_object_unref (buf);
g_object_unref (in);
g_free (b);
}
static void
test_empty ()
{
/* empty file should not have a trailing newline */
test_consecutive_read ("", "", GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, 10);
}
static void
test_consecutive_cut_char ()
{
/* first \n is read then fo and then is added \r but not \n */
test_consecutive_read ("\nfo\nbar\n\nblah\n", "\r\nfo\r\nbar\r\n\r\nblah\r\n\r\n", GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, 8);
test_consecutive_read ("\nfo\nbar\n\nblah", "\r\nfo\r\nbar\r\n\r\nblah\r\n", GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, 8);
}
static void
test_consecutive_big_read ()
{
test_consecutive_read ("\nfo\nbar\n\nblah\n", "\rfo\rbar\r\rblah\r\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 200);
test_consecutive_read ("\nfo\nbar\n\nblah", "\rfo\rbar\r\rblah\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 200);
test_consecutive_read ("\rfo\rbar\r\rblah\r", "\nfo\nbar\n\nblah\n\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 200);
test_consecutive_read ("\rfo\rbar\r\rblah", "\nfo\nbar\n\nblah\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 200);
test_consecutive_read ("\r\nfo\r\nbar\r\n\r\nblah\r\n", "\nfo\nbar\n\nblah\n\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 200);
test_consecutive_read ("\r\nfo\r\nbar\r\n\r\nblah", "\nfo\nbar\n\nblah\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 200);
test_consecutive_read ("\nfo\nbar\n\nblah\n", "\r\nfo\r\nbar\r\n\r\nblah\r\n\r\n", GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, 200);
test_consecutive_read ("\nfo\nbar\n\nblah", "\r\nfo\r\nbar\r\n\r\nblah\r\n", GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, 200);
}
static void
test_consecutive_middle_read ()
{
test_consecutive_read ("\nfo\nbar\n\nblah\n", "\rfo\rbar\r\rblah\r\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 6);
test_consecutive_read ("\nfo\nbar\n\nblah", "\rfo\rbar\r\rblah\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 6);
test_consecutive_read ("\rfo\rbar\r\rblah\r", "\nfo\nbar\n\nblah\n\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 6);
test_consecutive_read ("\rfo\rbar\r\rblah", "\nfo\nbar\n\nblah\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 6);
test_consecutive_read ("\r\nfo\r\nbar\r\n\r\nblah\r\n", "\nfo\nbar\n\nblah\n\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 6);
test_consecutive_read ("\r\nfo\r\nbar\r\n\r\nblah", "\nfo\nbar\n\nblah\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 6);
test_consecutive_read ("\nfo\nbar\n\nblah\n", "\r\nfo\r\nbar\r\n\r\nblah\r\n\r\n", GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, 6);
test_consecutive_read ("\nfo\nbar\n\nblah", "\r\nfo\r\nbar\r\n\r\nblah\r\n", GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, 6);
}
static void
test_consecutive_multibyte_cut ()
{
test_consecutive_read ("hello\nhello\xe6\x96\x87\nworld\n", "hello\rhello\xe6\x96\x87\rworld\r\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 6);
test_consecutive_read ("hello\rhello\xe6\x96\x87\rworld\r", "hello\rhello\xe6\x96\x87\rworld\r\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 6);
test_consecutive_read ("hello\nhello\xe6\x96\x87\nworld\n", "hello\nhello\xe6\x96\x87\nworld\n\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 6);
}
static void
test_consecutive_multibyte_big_read ()
{
test_consecutive_read ("hello\nhello\xe6\x96\x87\nworld\n", "hello\rhello\xe6\x96\x87\rworld\r\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 200);
test_consecutive_read ("hello\rhello\xe6\x96\x87\rworld\r", "hello\rhello\xe6\x96\x87\rworld\r\r", GEDIT_DOCUMENT_NEWLINE_TYPE_CR, 200);
test_consecutive_read ("hello\nhello\xe6\x96\x87\nworld\n", "hello\nhello\xe6\x96\x87\nworld\n\n", GEDIT_DOCUMENT_NEWLINE_TYPE_LF, 200);
}
int main (int argc,
char *argv[])
{
g_type_init ();
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/document-input-stream/empty", test_empty);
g_test_add_func ("/document-input-stream/consecutive_cut_char", test_consecutive_cut_char);
g_test_add_func ("/document-input-stream/consecutive_big_read", test_consecutive_big_read);
g_test_add_func ("/document-input-stream/consecutive_middle_read", test_consecutive_middle_read);
g_test_add_func ("/document-input-stream/consecutive_multibyte_cut", test_consecutive_multibyte_cut);
g_test_add_func ("/document-input-stream/consecutive_multibyte_big_read", test_consecutive_multibyte_big_read);
return g_test_run ();
}

251
tests/document-loader.c Executable file
View File

@@ -0,0 +1,251 @@
/*
* document-loader.c
* This file is part of gedit
*
* Copyright (C) 2010 - Jesse van den Kieboom
*
* gedit 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 2 of the License, or
* (at your option) any later version.
*
* gedit 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 gedit; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "gedit-gio-document-loader.h"
#include <gio/gio.h>
#include <gtk/gtk.h>
#include <glib.h>
#include <string.h>
static gboolean test_completed;
typedef struct
{
const gchar *in_buffer;
gint newline_type;
GFile *file;
} LoaderTestData;
static GFile *
create_document (const gchar *filename,
const gchar *contents)
{
GError *error = NULL;
GeditDocument *document;
gchar *uri;
if (!g_file_set_contents (filename, contents, -1, &error))
{
g_assert_no_error (error);
}
return g_file_new_for_path (filename);
}
static void
delete_document (GFile *location)
{
if (g_file_query_exists (location, NULL))
{
GError *err = NULL;
g_file_delete (location, NULL, &err);
g_assert_no_error (err);
}
test_completed = TRUE;
}
static void
on_document_loaded (GeditDocument *document,
GError *error,
LoaderTestData *data)
{
GtkTextIter start, end;
g_assert_no_error (error);
if (data->in_buffer != NULL)
{
gchar *text;
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (document), &start, &end);
text = gtk_text_iter_get_slice (&start, &end);
g_assert_cmpstr (text, ==, data->in_buffer);
g_free (text);
}
if (data->newline_type != -1)
{
g_assert_cmpint (gedit_document_get_newline_type (document),
==,
data->newline_type);
}
delete_document (data->file);
}
static void
test_loader (const gchar *filename,
const gchar *contents,
const gchar *in_buffer,
gint newline_type)
{
GFile *file;
gchar *uri;
GeditDocument *document;
file = create_document (filename, contents);
document = gedit_document_new ();
LoaderTestData *data = g_slice_new (LoaderTestData);
data->in_buffer = in_buffer;
data->newline_type = newline_type;
data->file = file;
test_completed = FALSE;
g_signal_connect (document,
"loaded",
G_CALLBACK (on_document_loaded),
data);
uri = g_file_get_uri (file);
gedit_document_load (document, uri, gedit_encoding_get_utf8 (), 0, FALSE);
g_free (uri);
while (!test_completed)
{
g_main_context_iteration (NULL, TRUE);
}
g_slice_free (LoaderTestData, data);
g_object_unref (file);
g_object_unref (document);
}
static void
test_end_line_stripping ()
{
test_loader ("document-loader.txt",
"hello world\n",
"hello world",
-1);
test_loader ("document-loader.txt",
"hello world",
"hello world",
-1);
test_loader ("document-loader.txt",
"\nhello world",
"\nhello world",
-1);
test_loader ("document-loader.txt",
"\nhello world\n",
"\nhello world",
-1);
test_loader ("document-loader.txt",
"hello world\n\n",
"hello world\n",
-1);
test_loader ("document-loader.txt",
"hello world\r\n",
"hello world",
-1);
test_loader ("document-loader.txt",
"hello world\r\n\r\n",
"hello world\r\n",
-1);
test_loader ("document-loader.txt",
"\n",
"",
-1);
test_loader ("document-loader.txt",
"\r\n",
"",
-1);
test_loader ("document-loader.txt",
"\n\n",
"\n",
-1);
test_loader ("document-loader.txt",
"\r\n\r\n",
"\r\n",
-1);
}
static void
test_end_new_line_detection ()
{
test_loader ("document-loader.txt",
"hello world\n",
NULL,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF);
test_loader ("document-loader.txt",
"hello world\r\n",
NULL,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF);
test_loader ("document-loader.txt",
"hello world\r",
NULL,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR);
}
static void
test_begin_new_line_detection ()
{
test_loader ("document-loader.txt",
"\nhello world",
NULL,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF);
test_loader ("document-loader.txt",
"\r\nhello world",
NULL,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF);
test_loader ("document-loader.txt",
"\rhello world",
NULL,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR);
}
int main (int argc,
char *argv[])
{
g_type_init ();
g_test_init (&argc, &argv, NULL);
gedit_prefs_manager_app_init ();
g_test_add_func ("/document-loader/end-line-stripping", test_end_line_stripping);
g_test_add_func ("/document-loader/end-new-line-detection", test_end_new_line_detection);
g_test_add_func ("/document-loader/begin-new-line-detection", test_begin_new_line_detection);
return g_test_run ();
}

134
tests/document-output-stream.c Executable file
View File

@@ -0,0 +1,134 @@
/*
* document-output-stream.c
* This file is part of gedit
*
* Copyright (C) 2010 - Ignacio Casal Quinteiro
*
* gedit 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 2 of the License, or
* (at your option) any later version.
*
* gedit 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 gedit; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "gedit-document-output-stream.h"
#include <gio/gio.h>
#include <gtk/gtk.h>
#include <glib.h>
#include <string.h>
static void
test_consecutive_write (const gchar *inbuf,
const gchar *outbuf,
gsize write_chunk_len,
GeditDocumentNewlineType newline_type)
{
GeditDocument *doc;
GOutputStream *out;
gsize len;
gssize n, w;
GError *err = NULL;
gchar *b;
GeditDocumentNewlineType type;
doc = gedit_document_new ();
out = gedit_document_output_stream_new (doc);
n = 0;
do
{
len = MIN (write_chunk_len, strlen (inbuf + n));
w = g_output_stream_write (out, inbuf + n, len, NULL, &err);
g_assert_cmpint (w, >=, 0);
g_assert_no_error (err);
n += w;
} while (w != 0);
g_object_get (G_OBJECT (doc), "text", &b, NULL);
g_assert_cmpstr (inbuf, ==, b);
g_free (b);
type = gedit_document_output_stream_detect_newline_type (GEDIT_DOCUMENT_OUTPUT_STREAM (out));
g_assert (type == newline_type);
g_output_stream_close (out, NULL, &err);
g_assert_no_error (err);
g_object_get (G_OBJECT (doc), "text", &b, NULL);
g_assert_cmpstr (outbuf, ==, b);
g_free (b);
g_assert (gtk_text_buffer_get_modified (GTK_TEXT_BUFFER (doc)) == FALSE);
g_object_unref (doc);
g_object_unref (out);
}
static void
test_empty ()
{
test_consecutive_write ("", "", 10, GEDIT_DOCUMENT_NEWLINE_TYPE_DEFAULT);
test_consecutive_write ("\r\n", "", 10, GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF);
test_consecutive_write ("\r", "", 10, GEDIT_DOCUMENT_NEWLINE_TYPE_CR);
test_consecutive_write ("\n", "", 10, GEDIT_DOCUMENT_NEWLINE_TYPE_LF);
}
static void
test_consecutive ()
{
test_consecutive_write ("hello\nhow\nare\nyou", "hello\nhow\nare\nyou", 2,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF);
test_consecutive_write ("hello\rhow\rare\ryou", "hello\rhow\rare\ryou", 2,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR);
test_consecutive_write ("hello\r\nhow\r\nare\r\nyou", "hello\r\nhow\r\nare\r\nyou", 2,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF);
}
static void
test_consecutive_tnewline ()
{
test_consecutive_write ("hello\nhow\nare\nyou\n", "hello\nhow\nare\nyou", 2,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF);
test_consecutive_write ("hello\rhow\rare\ryou\r", "hello\rhow\rare\ryou", 2,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR);
test_consecutive_write ("hello\r\nhow\r\nare\r\nyou\r\n", "hello\r\nhow\r\nare\r\nyou", 2,
GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF);
}
static void
test_big_char ()
{
test_consecutive_write ("\343\203\200\343\203\200", "\343\203\200\343\203\200", 2,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF);
}
int main (int argc,
char *argv[])
{
g_type_init ();
g_test_init (&argc, &argv, NULL);
gedit_prefs_manager_app_init ();
g_test_add_func ("/document-output-stream/empty", test_empty);
g_test_add_func ("/document-output-stream/consecutive", test_consecutive);
g_test_add_func ("/document-output-stream/consecutive_tnewline", test_consecutive_tnewline);
g_test_add_func ("/document-output-stream/big-char", test_big_char);
return g_test_run ();
}

735
tests/document-saver.c Executable file
View File

@@ -0,0 +1,735 @@
/*
* document-saver.c
* This file is part of gedit
*
* Copyright (C) 2010 - Jesse van den Kieboom
*
* gedit 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 2 of the License, or
* (at your option) any later version.
*
* gedit 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 gedit; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "gedit-gio-document-loader.h"
#include <gio/gio.h>
#include <gtk/gtk.h>
#include <glib.h>
#include <string.h>
#include <sys/stat.h>
#define DEFAULT_LOCAL_URI "/tmp/gedit-document-saver-test.txt"
#define DEFAULT_REMOTE_URI "sftp://localhost/tmp/gedit-document-saver-test.txt"
#define DEFAULT_CONTENT "hello world!"
#define DEFAULT_CONTENT_RESULT "hello world!\n"
#define UNOWNED_LOCAL_DIRECTORY "/tmp/gedit-document-saver-unowned"
#define UNOWNED_LOCAL_URI "/tmp/gedit-document-saver-unowned/gedit-document-saver-test.txt"
#define UNOWNED_REMOTE_DIRECTORY "sftp://localhost/tmp/gedit-document-saver-unowned"
#define UNOWNED_REMOTE_URI "sftp://localhost/tmp/gedit-document-saver-unowned/gedit-document-saver-test.txt"
#define UNOWNED_GROUP_LOCAL_URI "/tmp/gedit-document-saver-unowned-group.txt"
#define UNOWNED_GROUP_REMOTE_URI "sftp://localhost/tmp/gedit-document-saver-unowned-group.txt"
static gboolean test_completed;
static gboolean mount_completed;
static gboolean mount_success;
typedef struct
{
gchar *uri;
const gchar *test_contents;
gpointer data;
} SaverTestData;
static SaverTestData *
saver_test_data_new (const gchar *uri, const gchar *test_contents, gpointer data)
{
SaverTestData *ret = g_slice_new (SaverTestData);
ret->uri = g_strdup (uri);
ret->test_contents = test_contents;
ret->data = data;
return ret;
}
static void
saver_test_data_free (SaverTestData *data)
{
if (data == NULL)
{
return;
}
g_free (data->uri);
g_slice_free (SaverTestData, data);
}
static GeditDocument *
create_document (const gchar *contents)
{
GeditDocument *document = gedit_document_new ();
gtk_text_buffer_set_text (GTK_TEXT_BUFFER (document), contents, -1);
return document;
}
static void
complete_test_error (GeditDocument *document,
GError *error,
SaverTestData *data)
{
g_assert_no_error (error);
}
static const gchar *
read_file (const gchar *uri)
{
GFile *file = g_file_new_for_commandline_arg (uri);
GError *error = NULL;
static gchar buffer[4096];
gsize read;
GInputStream *stream = G_INPUT_STREAM (g_file_read (file, NULL, &error));
g_assert_no_error (error);
g_input_stream_read_all (stream, buffer, sizeof (buffer) - 1, &read, NULL, &error);
g_assert_no_error (error);
buffer[read] = '\0';
g_input_stream_close (stream, NULL, NULL);
g_object_unref (stream);
g_object_unref (file);
return buffer;
}
static void
complete_test (GeditDocument *document,
GError *error,
SaverTestData *data)
{
test_completed = TRUE;
if (data && data->test_contents && data->uri)
{
g_assert_cmpstr (data->test_contents, ==, read_file (data->uri));
}
}
static void
mount_ready_callback (GObject *object,
GAsyncResult *result,
gpointer data)
{
GError *error = NULL;
mount_success = g_file_mount_enclosing_volume_finish (G_FILE (object),
result,
&error);
if (error && error->code == G_IO_ERROR_ALREADY_MOUNTED)
{
mount_success = TRUE;
g_error_free (error);
}
else
{
g_assert_no_error (error);
}
mount_completed = TRUE;
}
static gboolean
ensure_mounted (GFile *file)
{
GMountOperation *mo;
mount_success = FALSE;
mount_completed = FALSE;
if (g_file_is_native (file))
{
return TRUE;
}
mo = gtk_mount_operation_new (NULL);
g_file_mount_enclosing_volume (file,
G_MOUNT_MOUNT_NONE,
mo,
NULL,
mount_ready_callback,
NULL);
while (!mount_completed)
{
g_main_context_iteration (NULL, TRUE);
}
g_object_unref (mo);
return mount_success;
}
static void
test_saver (const gchar *filename_or_uri,
const gchar *contents,
GeditDocumentNewlineType newline_type,
GeditDocumentSaveFlags save_flags,
GCallback saved_callback,
SaverTestData *data)
{
GFile *file;
gchar *uri;
GeditDocument *document;
gboolean existed;
document = create_document (contents);
gedit_document_set_newline_type (document, newline_type);
g_signal_connect (document, "saved", G_CALLBACK (complete_test_error), data);
if (saved_callback)
{
g_signal_connect (document, "saved", saved_callback, data);
}
g_signal_connect_after (document, "saved", G_CALLBACK (complete_test), data);
test_completed = FALSE;
file = g_file_new_for_commandline_arg (filename_or_uri);
uri = g_file_get_uri (file);
existed = g_file_query_exists (file, NULL);
ensure_mounted (file);
gedit_document_save_as (document, uri, gedit_encoding_get_utf8 (), save_flags);
while (!test_completed)
{
g_main_context_iteration (NULL, TRUE);
}
if (!existed)
{
g_file_delete (file, NULL, NULL);
}
g_free (uri);
g_object_unref (file);
saver_test_data_free (data);
}
typedef struct
{
GeditDocumentNewlineType type;
const gchar *text;
const gchar *result;
} NewLineTestData;
static NewLineTestData newline_test_data[] = {
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\nhello\nworld", "\nhello\nworld\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\nhello\nworld\n", "\nhello\nworld\n\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\nhello\nworld\n\n", "\nhello\nworld\n\n\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\r\nhello\r\nworld", "\nhello\nworld\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\r\nhello\r\nworld\r\n", "\nhello\nworld\n\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\rhello\rworld", "\nhello\nworld\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\rhello\rworld\r", "\nhello\nworld\n\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\nhello\r\nworld", "\nhello\nworld\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_LF, "\nhello\r\nworld\r", "\nhello\nworld\n\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\nhello\nworld", "\r\nhello\r\nworld\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\nhello\nworld\n", "\r\nhello\r\nworld\r\n\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\nhello\nworld\n\n", "\r\nhello\r\nworld\r\n\r\n\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\r\nhello\r\nworld", "\r\nhello\r\nworld\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\r\nhello\r\nworld\r\n", "\r\nhello\r\nworld\r\n\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\rhello\rworld", "\r\nhello\r\nworld\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\rhello\rworld\r", "\r\nhello\r\nworld\r\n\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\nhello\r\nworld", "\r\nhello\r\nworld\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF, "\nhello\r\nworld\r", "\r\nhello\r\nworld\r\n\r\n"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\nhello\nworld", "\rhello\rworld\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\nhello\nworld\n", "\rhello\rworld\r\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\nhello\nworld\n\n", "\rhello\rworld\r\r\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\r\nhello\r\nworld", "\rhello\rworld\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\r\nhello\r\nworld\r\n", "\rhello\rworld\r\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\rhello\rworld", "\rhello\rworld\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\rhello\rworld\r", "\rhello\rworld\r\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\nhello\r\nworld", "\rhello\rworld\r"},
{GEDIT_DOCUMENT_NEWLINE_TYPE_CR, "\nhello\r\nworld\r", "\rhello\rworld\r\r"}
};
static void
test_new_line (const gchar *filename, GeditDocumentSaveFlags save_flags)
{
gint i;
gint num = sizeof (newline_test_data) / sizeof (NewLineTestData);
for (i = 0; i < num; ++i)
{
NewLineTestData *nt = &(newline_test_data[i]);
test_saver (filename,
nt->text,
nt->type,
save_flags,
NULL,
saver_test_data_new (filename, nt->result, NULL));
}
}
static void
test_local_newline ()
{
test_new_line (DEFAULT_LOCAL_URI, 0);
}
static void
test_local ()
{
test_saver (DEFAULT_LOCAL_URI,
"hello world",
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (DEFAULT_LOCAL_URI, "hello world\n", NULL));
test_saver (DEFAULT_LOCAL_URI,
"hello world\r\n",
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (DEFAULT_LOCAL_URI, "hello world\n\n", NULL));
test_saver (DEFAULT_LOCAL_URI,
"hello world\n",
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (DEFAULT_LOCAL_URI, "hello world\n\n", NULL));
}
static void
test_remote_newline ()
{
test_new_line (DEFAULT_REMOTE_URI, 0);
}
static void
test_remote ()
{
test_saver (DEFAULT_REMOTE_URI,
"hello world",
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (DEFAULT_REMOTE_URI, "hello world\n", NULL));
test_saver (DEFAULT_REMOTE_URI,
"hello world\r\n",
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (DEFAULT_REMOTE_URI, "hello world\n\n", NULL));
test_saver (DEFAULT_REMOTE_URI,
"hello world\n",
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (DEFAULT_REMOTE_URI, "hello world\n\n", NULL));
}
#ifndef G_OS_WIN32
static void
check_permissions (GFile *file,
guint permissions)
{
GError *error = NULL;
GFileInfo *info;
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_UNIX_MODE,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
g_assert_no_error (error);
g_assert_cmpint (permissions,
==,
g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE) & ACCESSPERMS);
g_object_unref (info);
}
static void
check_permissions_saved (GeditDocument *document,
GError *error,
SaverTestData *data)
{
guint permissions = (guint)GPOINTER_TO_INT (data->data);
GFile *file = gedit_document_get_location (document);
check_permissions (file, permissions);
g_object_unref (file);
}
static void
test_permissions (const gchar *uri,
guint permissions)
{
GError *error = NULL;
GFile *file = g_file_new_for_commandline_arg (uri);
GFileOutputStream *stream;
GFileInfo *info;
guint mode;
g_file_delete (file, NULL, NULL);
stream = g_file_create (file, 0, NULL, &error);
g_assert_no_error (error);
g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, NULL);
g_object_unref (stream);
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_UNIX_MODE,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
g_assert_no_error (error);
mode = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);
g_object_unref (info);
g_file_set_attribute_uint32 (file,
G_FILE_ATTRIBUTE_UNIX_MODE,
(mode & ~ACCESSPERMS) | permissions,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
g_assert_no_error (error);
check_permissions (file, permissions);
test_saver (uri,
DEFAULT_CONTENT,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
G_CALLBACK (check_permissions_saved),
saver_test_data_new (uri,
DEFAULT_CONTENT_RESULT,
GINT_TO_POINTER ((gint)permissions)));
g_file_delete (file, NULL, NULL);
g_object_unref (file);
}
static void
test_local_permissions ()
{
test_permissions (DEFAULT_LOCAL_URI, 0600);
test_permissions (DEFAULT_LOCAL_URI, 0660);
test_permissions (DEFAULT_LOCAL_URI, 0666);
test_permissions (DEFAULT_LOCAL_URI, 0760);
}
#endif
static void
test_local_unowned_directory ()
{
test_saver (UNOWNED_LOCAL_URI,
DEFAULT_CONTENT,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (UNOWNED_LOCAL_URI,
DEFAULT_CONTENT_RESULT,
NULL));
}
static void
test_remote_unowned_directory ()
{
test_saver (UNOWNED_REMOTE_URI,
DEFAULT_CONTENT,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
NULL,
saver_test_data_new (UNOWNED_REMOTE_URI,
DEFAULT_CONTENT_RESULT,
NULL));
}
#ifndef G_OS_WIN32
static void
test_remote_permissions ()
{
test_permissions (DEFAULT_REMOTE_URI, 0600);
test_permissions (DEFAULT_REMOTE_URI, 0660);
test_permissions (DEFAULT_REMOTE_URI, 0666);
test_permissions (DEFAULT_REMOTE_URI, 0760);
}
static void
test_unowned_group_permissions (GeditDocument *document,
GError *error,
SaverTestData *data)
{
GFile *file = g_file_new_for_commandline_arg (data->uri);
GError *err = NULL;
const gchar *group;
guint32 mode;
GFileInfo *info = g_file_query_info (file,
G_FILE_ATTRIBUTE_OWNER_GROUP ","
G_FILE_ATTRIBUTE_UNIX_MODE,
G_FILE_QUERY_INFO_NONE,
NULL,
&err);
g_assert_no_error (err);
group = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP);
g_assert_cmpstr (group, ==, "root");
mode = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);
g_assert_cmpint (mode & ACCESSPERMS, ==, 0660);
g_object_unref (file);
g_object_unref (info);
}
static void
test_unowned_group (const gchar *uri)
{
test_saver (uri,
DEFAULT_CONTENT,
GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
0,
G_CALLBACK (test_unowned_group_permissions),
saver_test_data_new (uri,
DEFAULT_CONTENT_RESULT,
NULL));
}
static void
test_local_unowned_group ()
{
test_unowned_group (UNOWNED_GROUP_LOCAL_URI);
}
static void
test_remote_unowned_group ()
{
test_unowned_group (UNOWNED_GROUP_REMOTE_URI);
}
#endif
static gboolean
check_unowned_directory ()
{
GFile *unowned = g_file_new_for_path (UNOWNED_LOCAL_DIRECTORY);
GFile *unowned_file;
GFileInfo *info;
GError *error = NULL;
g_printf ("*** Checking for unowned directory test... ");
info = g_file_query_info (unowned,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
if (error)
{
g_object_unref (unowned);
g_printf ("NO: directory does not exist\n");
g_error_free (error);
return FALSE;
}
if (g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
g_object_unref (unowned);
g_printf ("NO: directory is writable\n");
g_object_unref (info);
return FALSE;
}
g_object_unref (info);
g_object_unref (unowned);
unowned_file = g_file_new_for_commandline_arg (UNOWNED_LOCAL_URI);
info = g_file_query_info (unowned_file,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
if (error)
{
g_object_unref (unowned_file);
g_error_free (error);
g_printf ("NO: file does not exist\n");
return FALSE;
}
if (!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
g_object_unref (unowned_file);
g_printf ("NO: file is not writable\n");
g_object_unref (info);
return FALSE;
}
g_object_unref (info);
g_object_unref (unowned_file);
g_printf ("YES\n");
return TRUE;
}
static gboolean
check_unowned_group ()
{
GFile *unowned = g_file_new_for_path (UNOWNED_GROUP_LOCAL_URI);
GFileInfo *info;
GError *error = NULL;
g_printf ("*** Checking for unowned group test... ");
info = g_file_query_info (unowned,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE ","
G_FILE_ATTRIBUTE_OWNER_GROUP ","
G_FILE_ATTRIBUTE_UNIX_MODE,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
if (error)
{
g_object_unref (unowned);
g_printf ("NO: file does not exist\n");
g_error_free (error);
return FALSE;
}
if (!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
g_object_unref (unowned);
g_printf ("NO: file is not writable\n");
g_object_unref (info);
return FALSE;
}
if (g_strcmp0 (g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP),
"root") != 0)
{
g_object_unref (unowned);
g_printf ("NO: group is not root (%s)\n", g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP));
g_object_unref (info);
return FALSE;
}
#ifndef G_OS_WIN32
if ((g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE) & ACCESSPERMS) != 0660)
{
g_object_unref (unowned);
g_printf ("NO: file has wrong permissions\n");
g_object_unref (info);
return FALSE;
}
#endif
g_object_unref (info);
g_object_unref (unowned);
g_printf ("YES\n");
return TRUE;
}
int main (int argc,
char *argv[])
{
gboolean have_unowned;
gboolean have_unowned_group;
g_type_init ();
g_test_init (&argc, &argv, NULL);
gedit_prefs_manager_app_init ();
g_printf ("\n***\n");
have_unowned = check_unowned_directory ();
have_unowned_group = check_unowned_group ();
g_printf ("***\n\n");
g_test_add_func ("/document-saver/local", test_local);
g_test_add_func ("/document-saver/local-new-line", test_local_newline);
if (have_unowned)
{
g_test_add_func ("/document-saver/local-unowned-directory", test_local_unowned_directory);
}
g_test_add_func ("/document-saver/remote", test_remote);
g_test_add_func ("/document-saver/remote-new-line", test_remote_newline);
if (have_unowned)
{
g_test_add_func ("/document-saver/remote-unowned-directory", test_remote_unowned_directory);
}
if (have_unowned_group)
{
/* FIXME: there is a bug in gvfs sftp which doesn't pass this test */
/* g_test_add_func ("/document-saver/remote-unowned-group", test_remote_unowned_group); */
}
#ifndef G_OS_WIN32
g_test_add_func ("/document-saver/local-permissions", test_local_permissions);
if (have_unowned_group)
{
g_test_add_func ("/document-saver/local-unowned-group", test_local_unowned_group);
}
g_test_add_func ("/document-saver/remote-permissions", test_remote_permissions);
#endif
return g_test_run ();
}

27
tests/setup-document-saver.sh Executable file
View File

@@ -0,0 +1,27 @@
#!/bin/sh
# This script is used to setup some special directory structures, permissions
# for the saver test
UNOWNED_DIRECTORY="/tmp/gedit-document-saver-unowned"
UNOWNED_FILE="/tmp/gedit-document-saver-unowned/gedit-document-saver-test.txt"
UNOWNED_GROUP="/tmp/gedit-document-saver-unowned-group.txt"
if [ -f "$UNOWNED_FILE" ]; then
sudo rm "$UNOWNED_FILE"
fi
if [ -d "$UNOWNED_DIRECTORY" ]; then
sudo rmdir "$UNOWNED_DIRECTORY"
fi
mkdir "$UNOWNED_DIRECTORY"
touch "$UNOWNED_FILE"
sudo chown nobody "$UNOWNED_DIRECTORY"
sudo touch "$UNOWNED_GROUP"
sudo chgrp root "$UNOWNED_GROUP"
sudo chmod u+w,g+w,o-rwx "$UNOWNED_GROUP"
sudo chown $USER "$UNOWNED_GROUP"

353
tests/smart-converter.c Executable file
View File

@@ -0,0 +1,353 @@
/*
* smart-converter.c
* This file is part of gedit
*
* Copyright (C) 2009 - Ignacio Casal Quinteiro
*
* gedit 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 2 of the License, or
* (at your option) any later version.
*
* gedit 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 gedit; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "gedit-smart-charset-converter.h"
#include "gedit-encodings.h"
#include <gio/gio.h>
#include <glib.h>
#include <string.h>
#define TEXT_TO_CONVERT "this is some text to make the tests"
#define TEXT_TO_GUESS "hello \xe6\x96\x87 world"
static void
print_hex (gchar *ptr, gint len)
{
gint i;
for (i = 0; i < len; ++i)
{
g_printf ("\\x%02x", (unsigned char)ptr[i]);
}
g_printf ("\n");
}
static gchar *
get_encoded_text (const gchar *text,
gsize nread,
const GeditEncoding *to,
const GeditEncoding *from,
gsize *bytes_written_aux,
gboolean care_about_error)
{
GCharsetConverter *converter;
gchar *out, *out_aux;
gsize bytes_read, bytes_read_aux;
gsize bytes_written;
GConverterResult res;
GError *err;
converter = g_charset_converter_new (gedit_encoding_get_charset (to),
gedit_encoding_get_charset (from),
NULL);
out = g_malloc (200);
out_aux = g_malloc (200);
err = NULL;
bytes_read_aux = 0;
*bytes_written_aux = 0;
if (nread == -1)
{
nread = strlen (text);
}
do
{
res = g_converter_convert (G_CONVERTER (converter),
text + bytes_read_aux,
nread,
out_aux,
200,
G_CONVERTER_INPUT_AT_END,
&bytes_read,
&bytes_written,
&err);
memcpy (out + *bytes_written_aux, out_aux, bytes_written);
bytes_read_aux += bytes_read;
*bytes_written_aux += bytes_written;
nread -= bytes_read;
} while (res != G_CONVERTER_FINISHED && res != G_CONVERTER_ERROR);
if (care_about_error)
{
g_assert_no_error (err);
}
else if (err)
{
g_printf ("** You don't care, but there was an error: %s", err->message);
return NULL;
}
out[*bytes_written_aux] = '\0';
if (!g_utf8_validate (out, *bytes_written_aux, NULL) && !care_about_error)
{
if (!care_about_error)
{
return NULL;
}
else
{
g_assert_not_reached ();
}
}
return out;
}
static GSList *
get_all_encodings ()
{
GSList *encs = NULL;
gint i = 0;
while (TRUE)
{
const GeditEncoding *enc;
enc = gedit_encoding_get_from_index (i);
if (enc == NULL)
break;
encs = g_slist_prepend (encs, (gpointer)enc);
i++;
}
return encs;
}
static gchar *
do_test (const gchar *test_in,
const gchar *enc,
GSList *encodings,
gsize nread,
const GeditEncoding **guessed)
{
GeditSmartCharsetConverter *converter;
gchar *out, *out_aux;
gsize bytes_read, bytes_read_aux;
gsize bytes_written, bytes_written_aux;
GConverterResult res;
GError *err;
if (enc != NULL)
{
encodings = NULL;
encodings = g_slist_prepend (encodings, (gpointer)gedit_encoding_get_from_charset (enc));
}
converter = gedit_smart_charset_converter_new (encodings);
out = g_malloc (200);
out_aux = g_malloc (200);
err = NULL;
bytes_read_aux = 0;
bytes_written_aux = 0;
do
{
res = g_converter_convert (G_CONVERTER (converter),
test_in + bytes_read_aux,
nread,
out_aux,
200,
G_CONVERTER_INPUT_AT_END,
&bytes_read,
&bytes_written,
&err);
memcpy (out + bytes_written_aux, out_aux, bytes_written);
bytes_read_aux += bytes_read;
bytes_written_aux += bytes_written;
nread -= bytes_read;
} while (res != G_CONVERTER_FINISHED && res != G_CONVERTER_ERROR);
g_assert_no_error (err);
out[bytes_written_aux] = '\0';
if (guessed != NULL)
*guessed = gedit_smart_charset_converter_get_guessed (converter);
return out;
}
static void
do_test_roundtrip (const char *str, const char *charset)
{
gsize len;
gchar *buf, *p;
GInputStream *in, *tmp;
GCharsetConverter *c1;
GeditSmartCharsetConverter *c2;
gsize n, tot;
GError *err;
GSList *enc = NULL;
len = strlen(str);
buf = g_new0 (char, len);
in = g_memory_input_stream_new_from_data (str, -1, NULL);
c1 = g_charset_converter_new (charset, "UTF-8", NULL);
tmp = in;
in = g_converter_input_stream_new (in, G_CONVERTER (c1));
g_object_unref (tmp);
g_object_unref (c1);
enc = g_slist_prepend (enc, (gpointer)gedit_encoding_get_from_charset (charset));
c2 = gedit_smart_charset_converter_new (enc);
g_slist_free (enc);
tmp = in;
in = g_converter_input_stream_new (in, G_CONVERTER (c2));
g_object_unref (tmp);
g_object_unref (c2);
tot = 0;
p = buf;
n = len;
while (TRUE)
{
gssize res;
err = NULL;
res = g_input_stream_read (in, p, n, NULL, &err);
g_assert_no_error (err);
if (res == 0)
break;
p += res;
n -= res;
tot += res;
}
g_assert_cmpint (tot, ==, len);
g_assert_cmpstr (str, ==, buf);
g_free (buf);
g_object_unref (in);
}
static void
test_utf8_utf8 ()
{
gchar *aux;
aux = do_test (TEXT_TO_CONVERT, "UTF-8", NULL, strlen (TEXT_TO_CONVERT), NULL);
g_assert_cmpstr (aux, ==, TEXT_TO_CONVERT);
aux = do_test ("foobar\xc3\xa8\xc3\xa8\xc3\xa8zzzzzz", "UTF-8", NULL, 18, NULL);
g_assert_cmpstr (aux, ==, "foobar\xc3\xa8\xc3\xa8\xc3\xa8zzzzzz");
aux = do_test ("foobar\xc3\xa8\xc3\xa8\xc3\xa8zzzzzz", "UTF-8", NULL, 9, NULL);
g_assert_cmpstr (aux, ==, "foobar\xc3\xa8\xc3");
/* FIXME: Use the utf8 stream for a fallback? */
//do_test_with_error ("\xef\xbf\xbezzzzzz", encs, G_IO_ERROR_FAILED);
}
static void
test_xxx_xxx ()
{
GSList *encs, *l;
encs = get_all_encodings ();
/* Here we just test all encodings it is just to know that the conversions
are done ok */
for (l = encs; l != NULL; l = g_slist_next (l))
{
do_test_roundtrip (TEXT_TO_CONVERT, gedit_encoding_get_charset ((const GeditEncoding *)l->data));
}
g_slist_free (encs);
}
static void
test_empty ()
{
const GeditEncoding *guessed;
gchar *out;
GSList *encodings = NULL;
/* testing the case of an empty file and list of encodings with no
utf-8. In this case, the smart converter cannot determine the right
encoding (because there is no input), but should still default to
utf-8 for the detection */
encodings = g_slist_prepend (encodings, (gpointer)gedit_encoding_get_from_charset ("UTF-16"));
encodings = g_slist_prepend (encodings, (gpointer)gedit_encoding_get_from_charset ("ISO-8859-15"));
out = do_test ("", NULL, encodings, 0, &guessed);
g_assert_cmpstr (out, ==, "");
g_assert (guessed == gedit_encoding_get_utf8 ());
}
static void
test_guessed ()
{
GSList *encs = NULL;
gchar *aux, *aux2, *fail;
gsize aux_len, fail_len;
const GeditEncoding *guessed;
aux = get_encoded_text (TEXT_TO_GUESS, -1,
gedit_encoding_get_from_charset ("UTF-16"),
gedit_encoding_get_from_charset ("UTF-8"),
&aux_len,
TRUE);
fail = get_encoded_text (aux, aux_len,
gedit_encoding_get_from_charset ("UTF-8"),
gedit_encoding_get_from_charset ("ISO-8859-15"),
&fail_len,
FALSE);
g_assert (fail == NULL);
/* ISO-8859-15 should fail */
encs = g_slist_append (encs, (gpointer)gedit_encoding_get_from_charset ("ISO-8859-15"));
encs = g_slist_append (encs, (gpointer)gedit_encoding_get_from_charset ("UTF-16"));
aux2 = do_test (aux, NULL, encs, aux_len, &guessed);
g_assert (guessed == gedit_encoding_get_from_charset ("UTF-16"));
}
int main (int argc,
char *argv[])
{
g_type_init ();
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/smart-converter/utf8-utf8", test_utf8_utf8);
//g_test_add_func ("/smart-converter/xxx-xxx", test_xxx_xxx);
g_test_add_func ("/smart-converter/guessed", test_guessed);
g_test_add_func ("/smart-converter/empty", test_empty);
return g_test_run ();
}