mathematical 1.6.17 → 1.6.20

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

@@ -0,0 +1,592 @@
+/* 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#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, gboolean save_png, 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 = -1;
+		}
+
+		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 && save_png)
+			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);
+
+		if (save_png) {
+			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)
+		{
+			gboolean save_png = strstr (entry, "dont-render-") != entry;
+
+			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, save_png, 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;
+
+#if GLIB_CHECK_VERSION(2,50,0)
+	if (g_log_writer_supports_color (STDOUT_FILENO)) {
+		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");
+
+	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, TRUE, &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 -*- */

data/ext/mathematical/lasem/tests/meson.build

@@ -0,0 +1,39 @@
+add_test_setup (
+  'valgrind',
+  exe_wrapper:[
+    'valgrind',
+    '--tool=memcheck',
+    '--leak-check=yes',
+    '--suppressions=' + meson.project_source_root() / 'tests' / 'lasem.supp',
+    '--error-exitcode=1'
+  ],
+  timeout_multiplier:10
+)
+
+tests = [
+	['dom',		[]],
+	['str', 	[]],
+	['filter', 	[]],
+	['suite',	['-DSUITE_DATA_DIRECTORY="@0@/tests/data"'.format (meson.project_source_root ()),
+	                 '-DSUITE_OPTION_FILE="@0@/tests/suite.ini"'.format (meson.project_source_root ())]]
+]
+
+foreach t: tests
+  exe = executable (t[0], '@0@.c'.format (t[0]),
+    c_args: [t[1]],
+    link_with: lasem_library,
+    dependencies: lasem_dependencies,
+    include_directories: [library_inc])
+  test (t[0], exe)
+endforeach
+
+examples = [
+	['lsm-test',			'lsmtest.c']
+]
+
+foreach example: examples
+  exe = executable (example[0], example[1],
+    link_with: lasem_library,
+    dependencies: lasem_dependencies,
+    include_directories: [library_inc])
+endforeach

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

@@ -0,0 +1,44 @@
+#include <glib.h>
+#include <lsmstr.h>
+#include <lsm.h>
+
+static void
+str_consolidate_test (void)
+{
+	char *string;
+
+	string = g_strdup ("   consolidate \n \t   test   \t \r a b c \n ");
+	lsm_str_consolidate (string);
+	g_assert_cmpstr (string, ==, "consolidate test a b c");
+	g_free (string);
+
+	string = g_strdup ("    ");
+	lsm_str_consolidate (string);
+	g_assert_cmpstr (string, ==, "");
+	g_free (string);
+
+	string = g_strdup ("");
+	lsm_str_consolidate (string);
+	g_assert_cmpstr (string, ==, "");
+	g_free (string);
+
+	string = NULL;
+	lsm_str_consolidate (string);
+	g_assert (string == NULL);
+}
+
+int
+main (int argc, char *argv[])
+{
+	int result;
+
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add_func ("/str/str-consolidate", str_consolidate_test);
+
+	result = g_test_run();
+
+	lsm_shutdown ();
+
+	return result;
+}