initial

1 files changed, 353 insertions, 0 deletions

diff --git a/tests/smart-converter.c b/tests/smart-converter.c
new file mode 100755
index 00000000..b48240a4
--- /dev/null
+++ b/tests/smart-converter.c
@@ -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 ();
+}