mathematical 0.3.1 → 0.4.0

data/ext/mathematical/{lsmsvgstyle.c → lasem/src/lsmsvgstyle.c}

@@ -544,17 +544,3 @@ lsm_svg_style_new_inherited (const LsmSvgStyle *parent_style, LsmPropertyBag *pr
 
 	return style;
 }
-
-#if 0 /* Unused code - remove? */
-LsmSvgStyle *
-lsm_svg_style_duplicate (const LsmSvgStyle *origin)
-{
-	LsmSvgStyle *style;
-
-	style = g_new (LsmSvgStyle, 1);
-
-	memcpy (style, origin, sizeof (LsmSvgStyle));
-
-	return style;
-}
-#endif /* 0 */

data/ext/mathematical/{lsmsvgview.c → lasem/src/lsmsvgview.c}

@@ -1256,7 +1256,8 @@ _show_text (LsmSvgView *view,
 
 	style = view->style;
 
-	lsm_debug_render ("[LsmSvgView::show_text] Show '%s' at %g,%g (%g px)", string, x, y, style->font_size_px);
+	lsm_debug_render ("[LsmSvgView::show_text] Show '%s' at %g,%g (%g px)", string,
+			 x != NULL ? *x : 0, y != NULL ? *y : 0, style->font_size_px);
 
 	need_pop = _lock_pango_layout (view);
 

data/ext/mathematical/lasem/tests/dom.c

@@ -0,0 +1,272 @@
+#include <glib.h>
+#include <lsmdom.h>
+
+static void
+_weak_ref_cb (void *data, GObject *object)
+{
+	int *counter = data;
+
+	(*counter)++;
+}
+
+static void
+create_document_test (void)
+{
+	LsmDomDocument *document;
+
+	document = lsm_dom_implementation_create_document (NULL, "math");
+	g_assert (LSM_IS_DOM_DOCUMENT (document));
+	g_assert_cmpstr (lsm_dom_node_get_node_name (LSM_DOM_NODE (document)), ==, "#document");
+	g_assert (lsm_dom_node_get_node_value (LSM_DOM_NODE (document)) == NULL);
+
+	g_object_unref (document);
+
+	document = lsm_dom_implementation_create_document (NULL, "svg");
+	g_assert (LSM_IS_DOM_DOCUMENT (document));
+	g_assert_cmpstr (lsm_dom_node_get_node_name (LSM_DOM_NODE (document)), ==, "#document");
+	g_assert (lsm_dom_node_get_node_value (LSM_DOM_NODE (document)) == NULL);
+
+	g_object_unref (document);
+}
+
+static void
+owner_document_test (void)
+{
+	LsmDomDocument *document;
+	LsmDomElement *element;
+	LsmDomElement *text_element;
+	LsmDomText *text;
+	int counter = 0;
+
+	document = lsm_dom_implementation_create_document (NULL, "svg");
+	g_assert (LSM_IS_DOM_DOCUMENT (document));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (document)) == NULL);
+
+	element = lsm_dom_document_create_element (document, "svg");
+	g_assert (LSM_IS_DOM_ELEMENT (element));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (element)) == document);
+
+	lsm_dom_node_append_child (LSM_DOM_NODE (document), LSM_DOM_NODE (element));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (element)) == document);
+
+	text_element = lsm_dom_document_create_element (document, "text");
+	g_assert (LSM_IS_DOM_ELEMENT (text_element));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (text_element)) == document);
+
+	lsm_dom_node_append_child (LSM_DOM_NODE (element), LSM_DOM_NODE (text_element));
+
+	text = lsm_dom_document_create_text_node (document, "");
+	g_assert (LSM_IS_DOM_TEXT (text));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (text)) == document);
+
+	lsm_dom_node_append_child (LSM_DOM_NODE (text_element), LSM_DOM_NODE (text));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (text)) == document);
+
+	g_object_weak_ref (G_OBJECT (document), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (element), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (text_element), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (text), _weak_ref_cb, &counter);
+
+	g_object_unref (document);
+
+	g_assert_cmpint (counter, ==, 4);
+}
+
+static void
+owner_mismatch_test (void)
+{
+	LsmDomDocument *document_a;
+	LsmDomDocument *document_b;
+	LsmDomElement *element_a;
+	LsmDomElement *element_b;
+	LsmDomElement *element_c;
+	int counter = 0;
+
+	document_a = lsm_dom_implementation_create_document (NULL, "svg");
+	g_assert (LSM_IS_DOM_DOCUMENT (document_a));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (document_a)) == NULL);
+
+	element_a = lsm_dom_document_create_element (document_a, "svg");
+	element_b = lsm_dom_document_create_element (document_a, "text");
+
+	document_b = lsm_dom_implementation_create_document (NULL, "svg");
+	g_assert (LSM_IS_DOM_DOCUMENT (document_b));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (document_b)) == NULL);
+
+	element_c = lsm_dom_document_create_element (document_b, "text");
+
+	g_assert (lsm_dom_node_append_child (LSM_DOM_NODE (document_a), LSM_DOM_NODE (element_a)) == LSM_DOM_NODE (element_a));
+	g_assert (lsm_dom_node_append_child (LSM_DOM_NODE (element_a), LSM_DOM_NODE (element_b)) == LSM_DOM_NODE (element_b));
+
+	g_object_weak_ref (G_OBJECT (document_a), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (document_b), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (element_a), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (element_c), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (element_b), _weak_ref_cb, &counter);
+
+	g_assert (lsm_dom_node_append_child (LSM_DOM_NODE (element_a), LSM_DOM_NODE (element_c)) == NULL);
+
+	g_object_unref (document_a);
+	g_object_unref (document_b);
+
+	g_assert_cmpint (counter,  ==, 5);
+}
+
+static void
+create_element_test (void)
+{
+	LsmDomDocument *document;
+	LsmDomElement *element;
+
+	document = lsm_dom_implementation_create_document (NULL, "svg");
+	g_assert (LSM_IS_DOM_DOCUMENT (document));
+	g_assert_cmpstr (lsm_dom_node_get_node_name (LSM_DOM_NODE (document)), ==, "#document");
+
+	element = lsm_dom_document_create_element (document, "unknown");
+	g_assert (element == NULL);
+
+	element = lsm_dom_document_create_element (document, "svg");
+	g_assert (LSM_IS_DOM_ELEMENT (element));
+
+	g_object_unref (element);
+	g_object_unref (document);
+}
+
+static void
+add_remove_element_test (void)
+{
+	LsmDomDocument *document;
+	LsmDomElement *element;
+
+	document = lsm_dom_implementation_create_document (NULL, "svg");
+	g_assert (LSM_IS_DOM_DOCUMENT (document));
+
+	element = lsm_dom_document_create_element (document, "unknown");
+	g_assert (element == NULL);
+
+	element = lsm_dom_document_create_element (document, "svg");
+	g_assert (LSM_IS_DOM_ELEMENT (element));
+	g_assert_cmpstr (lsm_dom_element_get_tag_name (LSM_DOM_ELEMENT (element)), ==, "svg");
+	g_assert (lsm_dom_node_get_next_sibling (LSM_DOM_NODE (element)) == NULL);
+	g_assert (lsm_dom_node_get_previous_sibling (LSM_DOM_NODE (element)) == NULL);
+	g_assert (lsm_dom_node_get_parent_node (LSM_DOM_NODE (element)) == NULL);
+
+	g_assert (lsm_dom_node_append_child (LSM_DOM_NODE (document), LSM_DOM_NODE (element)) ==
+		  LSM_DOM_NODE (element));
+	g_assert (lsm_dom_node_get_parent_node (LSM_DOM_NODE (element)) == LSM_DOM_NODE (document));
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (element)) == document);
+	g_assert (lsm_dom_node_get_first_child (LSM_DOM_NODE (document)) == LSM_DOM_NODE (element));
+
+	g_object_ref (element);
+
+	lsm_dom_node_remove_child (LSM_DOM_NODE (document), LSM_DOM_NODE (element));
+	g_assert (lsm_dom_node_get_first_child (LSM_DOM_NODE (document)) == NULL);
+	g_assert (lsm_dom_node_get_parent_node (LSM_DOM_NODE (element)) == NULL);
+	g_assert (lsm_dom_node_get_owner_document (LSM_DOM_NODE (element)) != NULL);
+
+	g_object_unref (element);
+	g_object_unref (document);
+}
+
+static void
+node_list_test (void)
+{
+	LsmDomDocument *document;
+	LsmDomElement *element;
+	LsmDomNodeList *childs;
+	int counter = 0;
+
+	document = lsm_dom_implementation_create_document (NULL, "svg");
+	element = lsm_dom_document_create_element (document, "svg");
+	lsm_dom_node_append_child (LSM_DOM_NODE (document), LSM_DOM_NODE (element));
+
+	childs = lsm_dom_node_get_child_nodes (LSM_DOM_NODE (document));
+	g_assert (LSM_IS_DOM_NODE_LIST (childs));
+	g_assert (lsm_dom_node_list_get_length (childs) == 1);
+	g_assert (lsm_dom_node_list_get_item (childs, 0) == LSM_DOM_NODE (element));
+	g_assert (lsm_dom_node_list_get_item (childs, 1) == NULL);
+
+	g_object_weak_ref (G_OBJECT (document), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (element), _weak_ref_cb, &counter);
+	g_object_weak_ref (G_OBJECT (childs), _weak_ref_cb, &counter);
+
+	g_object_ref (childs);
+	g_object_unref (document);
+
+	g_assert (lsm_dom_node_list_get_length (childs) == 0);
+
+	g_object_unref (childs);
+
+	g_assert_cmpint (counter, ==, 3);
+}
+
+static void
+insert_before_test (void)
+{
+	LsmDomDocument *document;
+	LsmDomNode *node;
+	LsmDomNodeList *childs;
+	LsmDomElement *math;
+	LsmDomElement *mn1;
+	LsmDomElement *mn2;
+	LsmDomElement *mo1;
+	LsmDomElement *mo2;
+
+	document = lsm_dom_implementation_create_document (NULL, "math");
+	math = lsm_dom_document_create_element (document, "math");
+	lsm_dom_node_append_child (LSM_DOM_NODE (document), LSM_DOM_NODE (math));
+	mn1 = lsm_dom_document_create_element (document, "mn");
+	mn2 = lsm_dom_document_create_element (document, "mn");
+	mo1 = lsm_dom_document_create_element (document, "mo");
+
+	node = lsm_dom_node_append_child (LSM_DOM_NODE (math), LSM_DOM_NODE (mn2));
+	g_assert (node == LSM_DOM_NODE (mn2));
+	node = lsm_dom_node_insert_before (LSM_DOM_NODE (math), LSM_DOM_NODE (mn1), LSM_DOM_NODE (mn2));
+	g_assert (node == LSM_DOM_NODE (mn1));
+	node = lsm_dom_node_insert_before (LSM_DOM_NODE (math), LSM_DOM_NODE (mo1), LSM_DOM_NODE (mn2));
+	g_assert (node == LSM_DOM_NODE (mo1));
+
+	childs = lsm_dom_node_get_child_nodes (LSM_DOM_NODE (math));
+	g_assert (LSM_IS_DOM_NODE_LIST (childs));
+
+	g_assert (lsm_dom_node_list_get_item (childs, 0) == LSM_DOM_NODE (mn1));
+	g_assert (lsm_dom_node_list_get_item (childs, 1) == LSM_DOM_NODE (mo1));
+	g_assert (lsm_dom_node_list_get_item (childs, 2) == LSM_DOM_NODE (mn2));
+	g_assert (lsm_dom_node_list_get_length (childs) == 3);
+
+	mo2 = lsm_dom_document_create_element (document, "mo");
+	node = lsm_dom_node_replace_child (LSM_DOM_NODE (math), LSM_DOM_NODE (mo2), LSM_DOM_NODE (mo1));
+	g_assert (node == LSM_DOM_NODE (mo1));
+
+	g_assert (lsm_dom_node_list_get_item (childs, 1) == LSM_DOM_NODE (mo2));
+	g_assert (lsm_dom_node_list_get_length (childs) == 3);
+
+	g_object_unref (mo1);
+	g_object_unref (document);
+}
+
+int
+main (int argc, char *argv[])
+{
+	int result;
+
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add_func ("/dom/create-document", create_document_test);
+	g_test_add_func ("/dom/owner-document", owner_document_test);
+	g_test_add_func ("/dom/owner-mismatch", owner_mismatch_test);
+	g_test_add_func ("/dom/create-element", create_element_test);
+	g_test_add_func ("/dom/add-remove-element", add_remove_element_test);
+	g_test_add_func ("/dom/node-list", node_list_test);
+	g_test_add_func ("/dom/insert-before", insert_before_test);
+
+#if !GLIB_CHECK_VERSION(2,36,0)
+	g_type_init ();
+#endif
+
+	result = g_test_run();
+
+	lsm_shutdown ();
+
+	return result;
+}

data/ext/mathematical/lasem/tests/lsmtest.c

@@ -0,0 +1,597 @@
+/* Lasem - SVG and Mathml library
+ *
+ * lsm-test - Regression test utility for Lasem
+ *
+ * Copyright © 2004 Richard D. Worth
+ * Copyright © 2006 Red Hat, Inc.
+ * Copyright © 2007-2012 Emmanuel Pacaud
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of the authors
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ * The authors make no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without express
+ * or implied warranty.
+ *
+ * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Emmanuel Pacaud <emmanuel@gnome.org>
+ *	    Richard D. Worth <richard@theworths.org>
+ *	    Carl Worth <cworth@cworth.org>
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <lsmmathml.h>
+#include <glib.h>
+#include <glib/gprintf.h>
+#include <gio/gio.h>
+
+#include <libxml/parser.h>
+
+#include <../itex2mml/itex2MML.h>
+
+#define XML_FILENAME	"lasemtest.xml"
+
+static char *option_debug_domains = NULL;
+static char **option_input_filenames = NULL;
+double option_ppi = 72.0;
+static gboolean option_fatal_warning = FALSE;
+static gboolean option_debug_filter = FALSE;
+static gboolean option_debug_pattern = FALSE;
+static gboolean option_debug_mask = FALSE;
+static gboolean option_debug_group = FALSE;
+static gboolean option_debug_text = FALSE;
+static gboolean option_dry_run = FALSE;
+static double option_compare_fuzz = 10.0;
+
+static const GOptionEntry entries[] =
+{
+	{ G_OPTION_REMAINING,	' ', 0,	G_OPTION_ARG_FILENAME_ARRAY,
+		&option_input_filenames, 	NULL, NULL},
+	{ "ppi", 		'p', 0, G_OPTION_ARG_DOUBLE,
+		&option_ppi, 			"Pixel per inch", NULL },
+	{ "debug", 		'd', 0, G_OPTION_ARG_STRING,
+		&option_debug_domains,		"Debug domains", NULL },
+	{ "fatal-warning", 	'f', 0, G_OPTION_ARG_NONE,
+		&option_fatal_warning,		"Make warning fatal", NULL },
+	{ "debug-filter", 	' ' , 0, G_OPTION_ARG_NONE,
+		&option_debug_filter,		"Debug filter surfaces", NULL },
+	{ "debug-pattern", 	' ' , 0, G_OPTION_ARG_NONE,
+		&option_debug_pattern,		"Debug pattern surfaces", NULL },
+	{ "debug-mask", 	' ' , 0, G_OPTION_ARG_NONE,
+		&option_debug_mask,		"Debug mask surfaces", NULL },
+	{ "debug-group", 	' ' , 0, G_OPTION_ARG_NONE,
+		&option_debug_group,		"Debug group surfaces", NULL },
+	{ "debug-text", 	' ' , 0, G_OPTION_ARG_NONE,
+		&option_debug_text,		"Debug text layout", NULL },
+	{ "dry-run",		'n' , 0, G_OPTION_ARG_NONE,
+		&option_dry_run,		"Don't write files", NULL },
+	{ "compare-fuzz",	'z', 0, G_OPTION_ARG_DOUBLE,
+		&option_compare_fuzz,		"Compare fuzz", NULL},
+	{ NULL }
+};
+
+static const char *fail_face = "";
+static const char *success_face = "";
+static const char *normal_face = "";
+FILE *lasem_test_html_file = NULL;
+
+typedef struct {
+	double elapsed_time;
+	unsigned int rendered_count;
+	unsigned int comparison_count;
+	unsigned int failed_count;
+	unsigned int success_count;
+} Statistic;
+
+static void __attribute__((format(printf,1,2)))
+lasem_test_html (const char *fmt, ...) 
+{
+	va_list va;
+	FILE *file = lasem_test_html_file ? lasem_test_html_file : stdout;
+
+	va_start (va, fmt);
+	vfprintf (file, fmt, va);
+	va_end (va);
+}
+
+static GRegex *regex_mml = NULL;
+
+typedef struct _buffer_diff_result {
+    unsigned int pixels_changed;
+    unsigned int max_diff;
+} buffer_diff_result_t;
+
+typedef guint32 pixman_bits_t;
+
+static void
+buffer_diff_core (unsigned char *_buf_a,
+		  unsigned char *_buf_b,
+		  unsigned char *_buf_diff,
+		  int		width,
+		  int		height,
+		  int		stride,
+		  pixman_bits_t mask,
+		  buffer_diff_result_t *result_ret)
+{
+	int x, y;
+	pixman_bits_t *row_a, *row_b, *row;
+	buffer_diff_result_t result = {0, 0};
+	pixman_bits_t *buf_a = (pixman_bits_t*)_buf_a;
+	pixman_bits_t *buf_b = (pixman_bits_t*)_buf_b;
+	pixman_bits_t *buf_diff = (pixman_bits_t*)_buf_diff;
+
+	stride /= sizeof(pixman_bits_t);
+	for (y = 0; y < height; y++)
+	{
+		row_a = buf_a + y * stride;
+		row_b = buf_b + y * stride;
+		row = buf_diff + y * stride;
+		for (x = 0; x < width; x++)
+		{
+			/* check if the pixels are the same */
+			if ((row_a[x] & mask) != (row_b[x] & mask)) {
+				int channel;
+				pixman_bits_t diff_pixel = 0;
+
+				/* calculate a difference value for all 4 channels */
+				for (channel = 0; channel < 4; channel++) {
+					int value_a = (row_a[x] >> (channel*8)) & 0xff;
+					int value_b = (row_b[x] >> (channel*8)) & 0xff;
+					unsigned int diff;
+					diff = abs (value_a - value_b);
+					if (diff > result.max_diff)
+						result.max_diff = diff;
+					diff *= 4;  /* emphasize */
+					if (diff)
+						diff += 128; /* make sure it's visible */
+					if (diff > 255)
+						diff = 255;
+					diff_pixel |= diff << (channel*8);
+				}
+
+				result.pixels_changed++;
+				row[x] = diff_pixel;
+			} else {
+				row[x] = 0;
+			}
+			row[x] |= 0xff000000; /* Set ALPHA to 100% (opaque) */
+		}
+	}
+
+	*result_ret = result;
+}
+
+static gboolean
+compare_surfaces (const char *test_name, cairo_surface_t *surface_a, cairo_surface_t *surface_b)
+{
+	int width_a, width_b, height_a, height_b, stride_a, stride_b;
+
+	if (surface_b == NULL)
+		return FALSE;
+	if (surface_a == NULL)
+		return FALSE;
+
+	width_a = cairo_image_surface_get_width (surface_a);
+	height_a = cairo_image_surface_get_height (surface_a);
+	stride_a = cairo_image_surface_get_stride (surface_a);
+	width_b = cairo_image_surface_get_width (surface_b);
+	height_b = cairo_image_surface_get_height (surface_b);
+	stride_b = cairo_image_surface_get_stride (surface_b);
+
+	if (width_a  == width_b && height_a == height_b && stride_a == stride_b) {
+		buffer_diff_result_t result;
+		cairo_surface_t *surface_diff;
+		char *diff_png_filename;
+		char *command;
+		char *command_result = NULL;
+		int command_status;
+
+		diff_png_filename = g_strdup_printf ("%s-diff.png", test_name);
+
+		surface_diff = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
+							   width_a, height_a);
+
+		buffer_diff_core (cairo_image_surface_get_data (surface_a),
+				  cairo_image_surface_get_data (surface_b),
+				  cairo_image_surface_get_data (surface_diff),
+				  cairo_image_surface_get_width (surface_a),
+				  cairo_image_surface_get_height (surface_a),
+				  cairo_image_surface_get_stride (surface_a),
+				  0xffffffff,
+				  &result);
+
+		cairo_surface_write_to_png (surface_diff, diff_png_filename);
+
+		cairo_surface_destroy (surface_diff);
+		g_free (diff_png_filename);
+
+		if (result.pixels_changed == 0) {
+			g_printf (" %sOK%s \n", success_face, normal_face);
+			return TRUE;
+		}
+
+		command = g_strdup_printf ("compare -metric AE -fuzz %g%% %s-out.png %s-ref.png %s-compare-diff.png",
+					   option_compare_fuzz, test_name, test_name, test_name);
+		g_spawn_command_line_sync (command, NULL, &command_result, &command_status, NULL);
+		g_free (command);
+
+		if (command_result != NULL && atoi (command_result) == 0) {
+			g_printf (" %sOK%s \n", success_face, normal_face);
+			return TRUE;
+		}
+	}
+
+	g_printf (" %sFAIL%s \n", fail_face, normal_face);
+	return FALSE;
+}
+
+static void
+lasem_test_render (char const *filename, gboolean compare, gboolean dry_run, Statistic *statistic)
+{
+	LsmDomDocument *document;
+	LsmDomView *view;
+	GTimer *timer;
+	cairo_t *cairo;
+	cairo_surface_t *surface;
+	char *buffer = NULL;
+	gsize size;
+	char *png_filename;
+	char *reference_png_filename;
+	char *test_name;
+	char *mime;
+	unsigned int width, height;
+	gboolean is_xml, success;
+	gboolean is_svg;
+	gboolean is_mathml;
+	gboolean check;
+	GRegex *regex;
+	GError *error = NULL;
+	char *filtered_buffer;
+
+	g_return_if_fail (statistic != NULL);
+
+	test_name = g_regex_replace (regex_mml, filename, -1, 0, "", 0, NULL);
+
+	png_filename = g_strdup_printf ("%s-out.png", test_name);
+	reference_png_filename = g_strdup_printf ("%s-ref.png", test_name);
+	if (g_file_test (reference_png_filename, G_FILE_TEST_IS_REGULAR)) {
+		check = compare;
+	} else {
+		g_free (reference_png_filename);
+		reference_png_filename = g_strdup_printf ("%s.png", test_name);
+		check = FALSE;
+	}
+
+	mime = g_content_type_guess (filename, NULL, 0, NULL);
+
+	is_svg = strcmp (mime, "image/svg+xml") == 0;
+	is_mathml = (strcmp (mime, "text/mathml") == 0) || (strcmp (mime, "application/mathml+xml") == 0);
+	is_xml = is_svg || is_mathml;
+
+	g_printf ("\trender %s (%s)", filename, mime);
+	g_free (mime);
+
+	success = g_file_get_contents (filename, &buffer, &size, NULL);
+	if (success) {
+		LsmBox viewport;
+		char *xml;
+
+		if (is_xml)
+			xml = buffer;
+		else {
+			xml = itex2MML_parse (buffer, size);
+			size = 0;
+		}
+
+		timer = g_timer_new ();
+
+		document = lsm_dom_document_new_from_memory (xml, size, NULL);
+
+		lsm_dom_document_set_path (document, filename);
+
+		view = lsm_dom_document_create_view (document);
+
+		viewport.x = 0.0;
+		viewport.y = 0.0;
+		viewport.width = 480.0;
+		viewport.height = 360.0;
+
+		lsm_dom_view_set_resolution (view, option_ppi);
+		lsm_dom_view_set_viewport_pixels (view, &viewport);
+		lsm_dom_view_get_size_pixels (LSM_DOM_VIEW (view), &width, &height, NULL);
+
+		if (option_debug_mask)
+			lsm_dom_view_set_debug (view, "mask", TRUE);
+		if (option_debug_pattern)
+			lsm_dom_view_set_debug (view, "pattern", TRUE);
+		if (option_debug_filter)
+			lsm_dom_view_set_debug (view, "filter", TRUE);
+		if (option_debug_group)
+			lsm_dom_view_set_debug (view, "group", TRUE);
+		if (option_debug_text)
+			lsm_dom_view_set_debug (view, "text", TRUE);
+
+		surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width + 2, height + 2);
+		cairo = cairo_create (surface);
+		cairo_surface_destroy (surface);
+
+		lsm_dom_view_render (LSM_DOM_VIEW (view), cairo, 1, 1);
+
+		statistic->elapsed_time +=  g_timer_elapsed (timer, NULL);
+		statistic->rendered_count++;
+		g_timer_destroy (timer);
+
+		if (!dry_run)
+			cairo_surface_write_to_png (surface, png_filename);
+
+		if (check) {
+			cairo_surface_t *reference_surface;
+
+			reference_surface = cairo_image_surface_create_from_png (reference_png_filename);
+			if (reference_surface != NULL) {
+				gboolean same;
+
+				same = compare_surfaces (test_name, surface, reference_surface); 
+				cairo_surface_destroy (reference_surface);
+
+				if (same)
+					statistic->success_count++;
+				else
+					statistic->failed_count++;
+				statistic->comparison_count++;
+			}
+		} else
+			g_printf ("\n");
+
+		cairo_destroy (cairo);
+
+		g_object_unref (view);
+		g_object_unref (document);
+
+		lasem_test_html ("<table border=\"1\" cellpadding=\"8\">\n");
+		lasem_test_html ("<tr>");
+
+		lasem_test_html ("<td><a href=\"%s\"><img border=\"0\" src=\"%s\"/></a></td>",
+				   filename, png_filename);
+		lasem_test_html ("<td><img src=\"%s\"/></td>", reference_png_filename);
+
+		lasem_test_html ("<td>");
+
+		if (is_mathml) {
+			regex = g_regex_new ("<math>", 0, 0, &error);
+			assert (error == NULL);
+
+			filtered_buffer = g_regex_replace (regex, xml,
+							   -1, 0,
+							   "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">",
+							   0, NULL);
+			g_regex_unref (regex);
+
+			lasem_test_html ("%s", filtered_buffer);
+
+			g_free (filtered_buffer);
+		}
+
+		if (is_svg) {
+			lasem_test_html ("<object type=\"image/svg+xml\" data=\"");
+			lasem_test_html ("%s", filename);
+			lasem_test_html ("\" width=\"%dpx\"/>", width + 2);
+		}
+
+		lasem_test_html ("</td>");
+		lasem_test_html ("</tr>\n");
+		lasem_test_html ("</table>\n");
+
+		if (!is_xml && !g_file_test (reference_png_filename, G_FILE_TEST_IS_REGULAR) && !dry_run) {
+			FILE *file;
+			int result __attribute__((unused));
+			char *cmd;
+
+			file = fopen ("lsmmathmltest.tmp", "w");
+			fprintf (file, "\\documentclass[10pt]{article}\n");
+			fprintf (file, "\\usepackage{amsmath}\n");
+			fprintf (file, "\\usepackage{amsfonts}\n");
+			fprintf (file, "\\usepackage{amssymb}\n");
+			fprintf (file, "\\usepackage{pst-plot}\n");
+			fprintf (file, "\\usepackage{color}\n");
+			fprintf (file, "\\pagestyle{empty}\n");
+			fprintf (file, "\\begin{document}\n");
+			fprintf (file, "%s\n", buffer);
+			fprintf (file, "\\end{document}\n");
+			fclose (file);
+
+			result = system ("latex --interaction=nonstopmode lsmmathmltest.tmp");
+			result = system ("dvips -E lsmmathmltest.dvi -o lsmmathmltest.ps");
+
+			cmd = g_strdup_printf ("convert -density 120 lsmmathmltest.ps %s", reference_png_filename);
+			result = system (cmd);
+			g_free (cmd);
+
+			result = system ("rm lsmmathmltest.tmp");
+			result = system ("rm lsmmathmltest.dvi");
+			result = system ("rm lsmmathmltest.log");
+			result = system ("rm lsmmathmltest.aux");
+			result = system ("rm lsmmathmltest.ps");
+		}
+
+		if (xml != buffer && !dry_run) {
+			char *xml_filename;
+
+			xml_filename = g_strdup_printf ("%s.xml", test_name);
+
+			g_file_set_contents (xml_filename, xml, -1, NULL);
+
+			g_free (xml_filename);
+			g_free (buffer);
+			itex2MML_free_string (xml);
+		} else
+			g_free (xml);
+	}
+
+	g_free (png_filename);
+	g_free (reference_png_filename);
+
+	g_free (test_name);
+}
+
+static void
+lasem_test_process_dir (const char *name, gboolean compare, gboolean dry_run, Statistic *statistic)
+{
+	GDir *directory;
+	GError *error = NULL;
+	const char *entry;
+	char *filename;
+	unsigned int n_files = 0;
+
+	directory = g_dir_open (name, 0, &error);
+	assert (error == NULL);
+
+	g_printf ("In directory %s\n", name);
+
+	lasem_test_html ("<h1>%s</h1>", name);
+
+	do {
+		entry = g_dir_read_name (directory);
+		if (entry != NULL &&
+		    strstr (entry, "ignore-") != entry &&
+		    strcmp (entry, "images") != 0)
+		{
+			filename = g_build_filename (name, entry, NULL);
+
+			if (g_file_test (filename, G_FILE_TEST_IS_DIR))
+				lasem_test_process_dir (filename, compare, dry_run, statistic);
+			else if (g_file_test (filename, G_FILE_TEST_IS_REGULAR) &&
+				 g_regex_match (regex_mml, filename, 0, NULL)) {
+				lasem_test_render (filename, compare, dry_run, statistic);
+				n_files++;
+			}
+
+			g_free (filename);
+		}
+	} while (entry != NULL);
+
+	g_dir_close (directory);
+}
+
+static gboolean
+check_for_compare (void)
+{
+	char *result, *output;
+
+	g_spawn_command_line_sync ("compare --version", &output, &result, NULL, NULL);
+
+	g_free (output);
+
+	if (result != NULL) {
+		g_free (result);
+		return TRUE;
+	}
+
+	g_printf ("Compare utility not found.\nPlease install ImageMagick.\n");
+	return FALSE;
+}
+
+int
+main (int argc, char **argv)
+{
+	GOptionContext *context;
+	GError *error = NULL;
+	unsigned int i;
+	unsigned int n_input_files = 0;
+	Statistic statistic = {0, 0, 0, 0, 0};
+
+	if (!check_for_compare())
+		return EXIT_FAILURE;
+
+#ifdef HAVE_UNISTD_H
+	if (isatty (2)) {
+		fail_face = "\033[41m\033[37m\033[1m";
+		success_face = "\033[42m\033[37m\033[1m";
+		normal_face = "\033[m";
+	}
+#endif
+
+	lasem_test_html_file = fopen (XML_FILENAME, "w");
+
+	lasem_test_html ("<?xml version=\"1.0\"?>");
+	lasem_test_html ("<!DOCTYPE html PUBLIC "
+			   "\"-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN\" "
+			   "\"http://www.w3.org/Math/DTD/mathml2/xhtml-math11-f.dtd\">");
+	lasem_test_html ("<html xmlns=\"http://www.w3.org/1999/xhtml\">\n");
+	lasem_test_html ("<body>\n");
+
+#if !GLIB_CHECK_VERSION(2,36,0)
+	g_type_init ();
+#endif
+
+	context = g_option_context_new (NULL);
+	g_option_context_add_main_entries (context, entries, NULL);
+
+	if (!g_option_context_parse (context, &argc, &argv, &error))
+	{
+		g_option_context_free (context);
+		g_print ("Option parsing failed: %s\n", error->message);
+		return 1;
+	}
+
+	g_option_context_free (context);
+
+	lsm_debug_enable (option_debug_domains);
+
+	if (option_fatal_warning)
+		g_log_set_fatal_mask ("Lasem", G_LOG_FATAL_MASK | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);
+
+	regex_mml = g_regex_new ("\\.(mml|tex|svg)$", 0, 0, &error);
+	assert (error == NULL);
+
+	n_input_files = option_input_filenames != NULL ? g_strv_length (option_input_filenames) : 0;
+	if (n_input_files == 1 && g_file_test (option_input_filenames[0], G_FILE_TEST_IS_DIR))
+		lasem_test_process_dir (option_input_filenames[0], TRUE, option_dry_run, &statistic);
+	else {
+		if (n_input_files > 0)
+			for (i = 0; i < n_input_files; i++)
+				lasem_test_render (option_input_filenames[i], TRUE, option_dry_run, &statistic);
+		else
+			lasem_test_process_dir (".", TRUE, option_dry_run, &statistic);
+	}
+
+	lasem_test_html ("</body>\n");
+	lasem_test_html ("</html>\n");
+
+	if (lasem_test_html_file != NULL)
+		fclose (lasem_test_html_file);
+
+	g_regex_unref (regex_mml);
+
+	g_printf ("%d files processed in %g seconds.\n", statistic.rendered_count, statistic.elapsed_time);
+	if (statistic.comparison_count > 0)
+		g_printf ("%s%d/%d%s comparison failures.\n",
+			  statistic.failed_count > 0 ? fail_face : success_face,
+			  statistic.failed_count,
+			  statistic.comparison_count,
+			  normal_face);
+
+	return 0;
+}
+
+/* vim: set sw=8 sts=8: -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 8 -*- */