/*

 * Copyright (C) 2005 - 2006, Marco Barisione <marco@barisione.org>

 * Portions copyright (c) 2009 Nokia Corporation.  All rights reserved.

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#undef G_DISABLE_ASSERT

#undef G_LOG_DOMAIN

#define ENABLE_REGEX

#include <string.h>

#include <locale.h>

#include "glib.h"

#ifdef __SYMBIAN32__

#include "mrt2_glib2_test.h"

#endif /*__SYMBIAN32__*/

#ifdef ENABLE_REGEX

/* U+20AC EURO SIGN (symbol, currency) */

#define EURO "\xe2\x82\xac"

/* U+00E0 LATIN SMALL LETTER A WITH GRAVE (letter, lowercase) */

#define AGRAVE "\xc3\xa0"

/* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE (letter, uppercase) */

#define AGRAVE_UPPER "\xc3\x80"

/* U+00E8 LATIN SMALL LETTER E WITH GRAVE (letter, lowercase) */

#define EGRAVE "\xc3\xa8"

/* U+00F2 LATIN SMALL LETTER O WITH GRAVE (letter, lowercase) */

#define OGRAVE "\xc3\xb2"

/* U+014B LATIN SMALL LETTER ENG (letter, lowercase) */

#define ENG "\xc5\x8b"

/* U+0127 LATIN SMALL LETTER H WITH STROKE (letter, lowercase) */

#define HSTROKE "\xc4\xa7"

/* U+0634 ARABIC LETTER SHEEN (letter, other) */

#define SHEEN "\xd8\xb4"

/* U+1374 ETHIOPIC NUMBER THIRTY (number, other) */

#define ETH30 "\xe1\x8d\xb4"

/* A random value use to mark untouched integer variables. */

#define UNTOUCHED -559038737

static gboolean noisy = FALSE;

static gboolean abort_on_fail = FALSE;

#define PASS passed++

#define FAIL \

  G_STMT_START \

    { \

      failed++; \

      if (abort_on_fail) \

	goto end; \

    } \

  G_STMT_END

/* A replacement for strcmp that doesn't crash with null pointers. */

static gboolean

streq (const gchar *s1, const gchar *s2)

{

  if (s1 == NULL && s2 == NULL)

    return TRUE;

  else if (s1 == NULL)

    return FALSE;

  else if (s2 == NULL)

    return FALSE;

  else

    return strcmp (s1, s2) == 0;

}

static void

verbose (const gchar *format, ...)

{

  /* Function copied from glib/tests/patterntest.c by Matthias Clasen. */

  gchar *msg;

  va_list args;

  va_start (args, format);

  msg = g_strdup_vprintf (format, args);

  va_end (args);

  if (noisy) 

    g_print ("%s", msg);

  g_free (msg);

}

static gboolean

test_new (const gchar        *pattern,

	  GRegexCompileFlags  compile_opts,

	  GRegexMatchFlags    match_opts)

{

  GRegex *regex;

  verbose ("compiling \"%s\" \t", pattern);

  regex = g_regex_new (pattern, compile_opts, match_opts, NULL);

  if (regex == NULL)

    {

      g_print ("failed \t(pattern: \"%s\", compile: %d, match %d)\n",

	       pattern, compile_opts, match_opts);

      return FALSE;

    }

  if (!streq (g_regex_get_pattern (regex), pattern))

    {

      g_print ("failed \t(pattern: \"%s\")\n",

	       pattern);

      g_regex_unref (regex);

      return FALSE;

    }

  g_regex_unref (regex);

  verbose ("passed\n");

  return TRUE;

}

#define TEST_NEW(pattern, compile_opts, match_opts) { \

  total++; \

  if (test_new (pattern, compile_opts, match_opts)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_new_fail (const gchar        *pattern,

	       GRegexCompileFlags  compile_opts,

	       GRegexError         expected_error)

{

  GRegex *regex;

  GError *error = NULL;

  verbose ("compiling \"%s\" (expected a failure) \t", pattern);

  regex = g_regex_new (pattern, compile_opts, 0, &error);

  if (regex != NULL)

    {

      g_print ("failed \t(pattern: \"%s\", compile: %d)\n",

	       pattern, compile_opts);

      g_regex_unref (regex);

      return FALSE;

    }

  if (error->code != expected_error)

    {

      g_print ("failed \t(pattern: \"%s\", compile: %d, got error: %d, "

	       "expected error: %d)\n",

	       pattern, compile_opts, error->code, expected_error);

      g_error_free (error);

      return FALSE;

    }

  verbose ("passed\n");

  return TRUE;

}

#define TEST_NEW_FAIL(pattern, compile_opts, expected_error) { \

  total++; \

  if (test_new_fail (pattern, compile_opts, expected_error)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_match_simple (const gchar        *pattern,

		   const gchar        *string,

		   GRegexCompileFlags  compile_opts,

		   GRegexMatchFlags    match_opts,

		   gboolean            expected)

{

  gboolean match;

  verbose ("matching \"%s\" against \"%s\" \t", string, pattern);

  match = g_regex_match_simple (pattern, string, compile_opts, match_opts);

  if (match != expected)

    {

      g_print ("failed \t(unexpected %s)\n", match ? "match" : "mismatch");

      return FALSE;

    }

  else

    {

      verbose ("passed (%s)\n", match ? "match" : "nomatch");

      return TRUE;

    }

}

#define TEST_MATCH_SIMPLE(pattern, string, compile_opts, match_opts, expected) { \

  total++; \

  if (test_match_simple (pattern, string, compile_opts, match_opts, expected)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_match (const gchar        *pattern,

	    GRegexCompileFlags  compile_opts,

	    GRegexMatchFlags    match_opts,

	    const gchar        *string,

	    gssize              string_len,

	    gint                start_position,

	    GRegexMatchFlags    match_opts2,

	    gboolean            expected)

{

  GRegex *regex;

  gboolean match;

  verbose ("matching \"%s\" against \"%s\" (start: %d, len: %d) \t",

	   string, pattern, start_position, string_len);

  regex = g_regex_new (pattern, compile_opts, match_opts, NULL);

  match = g_regex_match_full (regex, string, string_len,

			      start_position, match_opts2, NULL, NULL);

  if (match != expected)

    {

      gchar *e1 = g_strescape (pattern, NULL);

      gchar *e2 = g_strescape (string, NULL);

      g_print ("failed \t(unexpected %s) '%s' against '%s'\n", match ? "match" : "mismatch", e1, e2);

      g_free (e1);

      g_free (e2);

      g_regex_unref (regex);

      return FALSE;

    }

  if (string_len == -1 && start_position == 0)

    {

      match = g_regex_match (regex, string, match_opts2, NULL);

      if (match != expected)

	{

	  g_print ("failed \t(pattern: \"%s\", string: \"%s\")\n",

		   pattern, string);

	  g_regex_unref (regex);

	  return FALSE;

	}

    }

  g_regex_unref (regex);

  verbose ("passed (%s)\n", match ? "match" : "nomatch");

  return TRUE;

}

#define TEST_MATCH(pattern, compile_opts, match_opts, string, \

		   string_len, start_position, match_opts2, expected) { \

  total++; \

  if (test_match (pattern, compile_opts, match_opts, string, \

		  string_len, start_position, match_opts2, expected)) \

    PASS; \

  else \

    FAIL; \

}

struct _Match

{

  gchar *string;

  gint start, end;

};

typedef struct _Match Match;

static void

free_match (gpointer data, gpointer user_data)

{

  Match *match = data;

  if (match == NULL)

    return;

  g_free (match->string);

  g_free (match);

}

static gboolean

test_match_next (const gchar *pattern,

		 const gchar *string,

		 gssize       string_len,

		 gint         start_position,

		 ...)

{

  GRegex *regex;

  GMatchInfo *match_info;

  va_list args;

  GSList *matches = NULL;

  GSList *expected = NULL;

  GSList *l_exp, *l_match;

  gboolean ret = TRUE;

  verbose ("matching \"%s\" against \"%s\" (start: %d, len: %d) \t",

	   string, pattern, start_position, string_len);

  /* The va_list is a NULL-terminated sequence of: extected matched string,

   * expected start and expected end. */

  va_start (args, start_position);

  while (TRUE)

   {

      Match *match;

      const gchar *expected_string = va_arg (args, const gchar *);

      if (expected_string == NULL)

        break;

      match = g_new0 (Match, 1);

      match->string = g_strdup (expected_string);

      match->start = va_arg (args, gint);

      match->end = va_arg (args, gint);

      expected = g_slist_prepend (expected, match);

    }

  expected = g_slist_reverse (expected);

  va_end (args);

  regex = g_regex_new (pattern, 0, 0, NULL);

  g_regex_match_full (regex, string, string_len,

		      start_position, 0, &match_info, NULL);

  while (g_match_info_matches (match_info))

    {

      Match *match = g_new0 (Match, 1);

      match->string = g_match_info_fetch (match_info, 0);

      match->start = UNTOUCHED;

      match->end = UNTOUCHED;

      g_match_info_fetch_pos (match_info, 0, &match->start, &match->end);

      matches = g_slist_prepend (matches, match);

      g_match_info_next (match_info, NULL);

    }

  g_assert (regex == g_match_info_get_regex (match_info));

  g_assert (string == g_match_info_get_string (match_info));

  g_match_info_free (match_info);

  matches = g_slist_reverse (matches);

  if (g_slist_length (matches) != g_slist_length (expected))

    {

      gint match_count = g_slist_length (matches);

      g_print ("failed \t(got %d %s, expected %d)\n", match_count,

	       match_count == 1 ? "match" : "matches", 

	       g_slist_length (expected));

      ret = FALSE;

      goto exit;

    }

  l_exp = expected;

  l_match =  matches;

  while (l_exp != NULL)

    {

      Match *exp = l_exp->data;

      Match *match = l_match->data;

      if (!streq(exp->string, match->string))

	{

	  g_print ("failed \t(got \"%s\", expected \"%s\")\n",

		   match->string, exp->string);

	  ret = FALSE;

	  goto exit;

	}

      if (exp->start != match->start || exp->end != match->end)

	{

	  g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",

		   match->start, match->end, exp->start, exp->end);

	  ret = FALSE;

	  goto exit;

	}

      l_exp = g_slist_next (l_exp);

      l_match = g_slist_next (l_match);

    }

exit:

  if (ret)

    {

      gint count = g_slist_length (matches);

      verbose ("passed (%d %s)\n", count, count == 1 ? "match" : "matches");

    }

  g_regex_unref (regex);

  g_slist_foreach (expected, free_match, NULL);

  g_slist_free (expected);

  g_slist_foreach (matches, free_match, NULL);

  g_slist_free (matches);

  return ret;

}

#define TEST_MATCH_NEXT0(pattern, string, string_len, start_position) { \

  total++; \

  if (test_match_next (pattern, string, string_len, start_position, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_MATCH_NEXT1(pattern, string, string_len, start_position, \

			      t1, s1, e1) { \

  total++; \

  if (test_match_next (pattern, string, string_len, start_position, \

		       t1, s1, e1, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_MATCH_NEXT2(pattern, string, string_len, start_position, \

			 t1, s1, e1, t2, s2, e2) { \

  total++; \

  if (test_match_next (pattern, string, string_len, start_position, \

		       t1, s1, e1, t2, s2, e2, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_MATCH_NEXT3(pattern, string, string_len, start_position, \

			 t1, s1, e1, t2, s2, e2, t3, s3, e3) { \

  total++; \

  if (test_match_next (pattern, string, string_len, start_position, \

		       t1, s1, e1, t2, s2, e2, t3, s3, e3, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_MATCH_NEXT4(pattern, string, string_len, start_position, \

			 t1, s1, e1, t2, s2, e2, t3, s3, e3, t4, s4, e4) { \

  total++; \

  if (test_match_next (pattern, string, string_len, start_position, \

		       t1, s1, e1, t2, s2, e2, t3, s3, e3, t4, s4, e4, NULL)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_match_count (const gchar      *pattern,

		  const gchar      *string,

		  gint              start_position,

                  GRegexMatchFlags  match_opts,

		  gint              expected_count)

{

  GRegex *regex;

  GMatchInfo *match_info;

  gint count;

  verbose ("fetching match count (string: \"%s\", pattern: \"%s\", start: %d) \t",

	   string, pattern, start_position);

  regex = g_regex_new (pattern, 0, 0, NULL);

  g_regex_match_full (regex, string, -1, start_position,

		      match_opts, &match_info, NULL);

  count = g_match_info_get_match_count (match_info);

  if (count != expected_count)

    {

      g_print ("failed \t(got %d, expected: %d)\n", count, expected_count);

      return FALSE;

    }

  g_match_info_free (match_info);

  g_regex_unref (regex);

  verbose ("passed\n");

  return TRUE;

}

#define TEST_MATCH_COUNT(pattern, string, start_position, match_opts, expected_count) { \

  total++; \

  if (test_match_count (pattern, string, start_position, match_opts, expected_count)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_partial (const gchar *pattern,

	      const gchar *string,

	      gboolean     expected)

{

  GRegex *regex;

  GMatchInfo *match_info;

  verbose ("partial matching (string: \"%s\", pattern: \"%s\") \t",

	   string, pattern);

  regex = g_regex_new (pattern, 0, 0, NULL);

  g_regex_match (regex, string, G_REGEX_MATCH_PARTIAL, &match_info);

  if (expected != g_match_info_is_partial_match (match_info))

    {

      g_print ("failed \t(got %d, expected: %d)\n", !expected, expected);

      g_regex_unref (regex);

      return FALSE;

    }

  if (expected && g_match_info_fetch_pos (match_info, 0, NULL, NULL))

    {

      g_print ("failed \t(got sub-pattern 0)\n");

      g_regex_unref (regex);

      return FALSE;

    }

  if (expected && g_match_info_fetch_pos (match_info, 1, NULL, NULL))

    {

      g_print ("failed \t(got sub-pattern 1)\n");

      g_regex_unref (regex);

      return FALSE;

    }

  g_match_info_free (match_info);

  g_regex_unref (regex);

  verbose ("passed\n");

  return TRUE;

}

#define TEST_PARTIAL(pattern, string, expected) { \

  total++; \

  if (test_partial (pattern, string, expected)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_sub_pattern (const gchar *pattern,

		  const gchar *string,

		  gint         start_position,

		  gint         sub_n,

		  const gchar *expected_sub,

		  gint         expected_start,

		  gint         expected_end)

{

  GRegex *regex;

  GMatchInfo *match_info;

  gchar *sub_expr;

  gint start = UNTOUCHED, end = UNTOUCHED;

  verbose ("fetching sub-pattern %d from \"%s\" (pattern: \"%s\") \t",

	   sub_n, string, pattern);

  regex = g_regex_new (pattern, 0, 0, NULL);

  g_regex_match_full (regex, string, -1, start_position, 0, &match_info, NULL);

  sub_expr = g_match_info_fetch (match_info, sub_n);

  if (!streq(sub_expr, expected_sub))

    {

      g_print ("failed \t(got \"%s\", expected \"%s\")\n",

	       sub_expr, expected_sub);

      g_free (sub_expr);

      g_regex_unref (regex);

      return FALSE;

    }

  g_free (sub_expr);

  g_match_info_fetch_pos (match_info, sub_n, &start, &end);

  if (start != expected_start || end != expected_end)

    {

      g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",

	       start, end, expected_start, expected_end);

      g_regex_unref (regex);

      return FALSE;

    }

  g_match_info_free (match_info);

  g_regex_unref (regex);

  verbose ("passed\n");

  return TRUE;

}

#define TEST_SUB_PATTERN(pattern, string, start_position, sub_n, expected_sub, \

			 expected_start, expected_end) { \

  total++; \

  if (test_sub_pattern (pattern, string, start_position, sub_n, expected_sub, \

			expected_start, expected_end)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_named_sub_pattern (const gchar *pattern,

			GRegexCompileFlags flags,

			const gchar *string,

			gint         start_position,

			const gchar *sub_name,

			const gchar *expected_sub,

			gint         expected_start,

			gint         expected_end)

{

  GRegex *regex;

  GMatchInfo *match_info;

  gint start = UNTOUCHED, end = UNTOUCHED;

  gchar *sub_expr;

  verbose ("fetching sub-pattern \"%s\" from \"%s\" (pattern: \"%s\") \t",

	   sub_name, string, pattern);

  regex = g_regex_new (pattern, flags, 0, NULL);

  g_regex_match_full (regex, string, -1, start_position, 0, &match_info, NULL);

  sub_expr = g_match_info_fetch_named (match_info, sub_name);

  if (!streq (sub_expr, expected_sub))

    {

      g_print ("failed \t(got \"%s\", expected \"%s\")\n",

	       sub_expr, expected_sub);

      g_free (sub_expr);

      g_regex_unref (regex);

      return FALSE;

    }

  g_free (sub_expr);

  g_match_info_fetch_named_pos (match_info, sub_name, &start, &end);

  if (start != expected_start || end != expected_end)

    {

      g_print ("failed \t(got [%d, %d], expected [%d, %d])\n",

	       start, end, expected_start, expected_end);

      g_regex_unref (regex);

      return FALSE;

    }

  g_match_info_free (match_info);

  g_regex_unref (regex);

  verbose ("passed\n");

  return TRUE;

}

#define TEST_NAMED_SUB_PATTERN(pattern, string, start_position, sub_name, \

			       expected_sub, expected_start, expected_end) { \

  total++; \

  if (test_named_sub_pattern (pattern, 0, string, start_position, sub_name, \

			      expected_sub, expected_start, expected_end)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_NAMED_SUB_PATTERN_DUPNAMES(pattern, string, start_position, sub_name, \

					expected_sub, expected_start, expected_end) { \

  total++; \

  if (test_named_sub_pattern (pattern, G_REGEX_DUPNAMES, string, start_position, \

			      sub_name, expected_sub, expected_start, expected_end)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_fetch_all (const gchar *pattern,

		const gchar *string,

		...)

{

  GRegex *regex;

  GMatchInfo *match_info;

  va_list args;

  GSList *expected = NULL;

  GSList *l_exp;

  gchar **matches;

  gint match_count;

  gboolean ret = TRUE;

  gint i;

  verbose ("fetching all sub-patterns from \"%s\" (pattern: \"%s\") \t",

	   string, pattern);

  /* The va_list is a NULL-terminated sequence of extected strings. */

  va_start (args, string);

  while (TRUE)

   {

      gchar *expected_string = va_arg (args, gchar *);

      if (expected_string == NULL)

        break;

      else

        expected = g_slist_prepend (expected, g_strdup (expected_string));

    }

  expected = g_slist_reverse (expected);

  va_end (args);

  regex = g_regex_new (pattern, 0, 0, NULL);

  g_regex_match (regex, string, 0, &match_info);

  matches = g_match_info_fetch_all (match_info);

  if (matches)

    match_count = g_strv_length (matches);

  else

    match_count = 0;

  if (match_count != g_slist_length (expected))

    {

      g_print ("failed \t(got %d %s, expected %d)\n", match_count,

	       match_count == 1 ? "match" : "matches", 

	       g_slist_length (expected));

      ret = FALSE;

      goto exit;

    }

  l_exp = expected;

  for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))

    {

      if (!streq(l_exp->data, matches [i]))

	{

	  g_print ("failed \t(got \"%s\", expected \"%s\")\n",

		   matches [i], (gchar *)l_exp->data);

	  ret = FALSE;

	  goto exit;

	}

    }

  verbose ("passed (%d %s)\n", match_count,

	   match_count == 1 ? "match" : "matches");

exit:

  g_match_info_free (match_info);

  g_regex_unref (regex);

  g_slist_foreach (expected, (GFunc)g_free, NULL);

  g_slist_free (expected);

  g_strfreev (matches);

  return ret;

}

#define TEST_FETCH_ALL0(pattern, string) { \

  total++; \

  if (test_fetch_all (pattern, string, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_FETCH_ALL1(pattern, string, e1) { \

  total++; \

  if (test_fetch_all (pattern, string, e1, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_FETCH_ALL2(pattern, string, e1, e2) { \

  total++; \

  if (test_fetch_all (pattern, string, e1, e2, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_FETCH_ALL3(pattern, string, e1, e2, e3) { \

  total++; \

  if (test_fetch_all (pattern, string, e1, e2, e3, NULL)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_split_simple (const gchar *pattern,

		   const gchar *string,

		   ...)

{

  va_list args;

  GSList *expected = NULL;

  GSList *l_exp;

  gchar **tokens;

  gint token_count;

  gboolean ret = TRUE;

  gint i;

  verbose ("splitting \"%s\" against \"%s\" \t", string, pattern);

  /* The va_list is a NULL-terminated sequence of extected strings. */

  va_start (args, string);

  while (TRUE)

   {

      gchar *expected_string = va_arg (args, gchar *);

      if (expected_string == NULL)

        break;

      else

        expected = g_slist_prepend (expected, g_strdup (expected_string));

    }

  expected = g_slist_reverse (expected);

  va_end (args);

  tokens = g_regex_split_simple (pattern, string, 0, 0);

  if (tokens)

    token_count = g_strv_length (tokens);

  else

    token_count = 0;

  if (token_count != g_slist_length (expected))

    {

      g_print ("failed \t(got %d %s, expected %d)\n", token_count,

	       token_count == 1 ? "match" : "matches", 

	       g_slist_length (expected));

      ret = FALSE;

      goto exit;

    }

  l_exp = expected;

  for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))

    {

      if (!streq(l_exp->data, tokens [i]))

	{

	  g_print ("failed \t(got \"%s\", expected \"%s\")\n",

		   tokens[i], (gchar *)l_exp->data);

	  ret = FALSE;

	  goto exit;

	}

    }

  verbose ("passed (%d %s)\n", token_count,

	   token_count == 1 ? "token" : "tokens");

exit:

  g_slist_foreach (expected, (GFunc)g_free, NULL);

  g_slist_free (expected);

  g_strfreev (tokens);

  return ret;

}

#define TEST_SPLIT_SIMPLE0(pattern, string) { \

  total++; \

  if (test_split_simple (pattern, string, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_SPLIT_SIMPLE1(pattern, string, e1) { \

  total++; \

  if (test_split_simple (pattern, string, e1, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_SPLIT_SIMPLE2(pattern, string, e1, e2) { \

  total++; \

  if (test_split_simple (pattern, string, e1, e2, NULL)) \

    PASS; \

  else \

    FAIL; \

}

#define TEST_SPLIT_SIMPLE3(pattern, string, e1, e2, e3) { \

  total++; \

  if (test_split_simple (pattern, string, e1, e2, e3, NULL)) \

    PASS; \

  else \

    FAIL; \

}

static gboolean

test_split_full (const gchar *pattern,

		 const gchar *string,

		 gint         start_position,

		 gint         max_tokens,

		 ...)

{

  GRegex *regex;

  va_list args;

  GSList *expected = NULL;

  GSList *l_exp;

  gchar **tokens;

  gint token_count;

  gboolean ret = TRUE;

  gint i;

  verbose ("splitting \"%s\" against \"%s\" (start: %d, max: %d) \t",

	   string, pattern, start_position, max_tokens);

  /* The va_list is a NULL-terminated sequence of extected strings. */

  va_start (args, max_tokens);

  while (TRUE)

   {

      gchar *expected_string = va_arg (args, gchar *);

      if (expected_string == NULL)

        break;

      else

        expected = g_slist_prepend (expected, g_strdup (expected_string));

    }

  expected = g_slist_reverse (expected);

  va_end (args);

  regex = g_regex_new (pattern, 0, 0, NULL);

  tokens = g_regex_split_full (regex, string, -1, start_position,

			       0, max_tokens, NULL);

  if (tokens)

    token_count = g_strv_length (tokens);

  else

    token_count = 0;

  if (token_count != g_slist_length (expected))

    {

      g_print ("failed \t(got %d %s, expected %d)\n", token_count,

	       token_count == 1 ? "match" : "matches", 

	       g_slist_length (expected));

      ret = FALSE;

      goto exit;

    }

  l_exp = expected;

  for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))

    {

      if (!streq(l_exp->data, tokens [i]))

	{

	  g_print ("failed \t(got \"%s\", expected \"%s\")\n",

		   tokens[i], (gchar *)l_exp->data);

	  ret = FALSE;

	  goto exit;

	}

    }

  verbose ("passed (%d %s)\n", token_count,

	   token_count == 1 ? "token" : "tokens");

exit:

  g_regex_unref (regex);

  g_slist_foreach (expected, (GFunc)g_free, NULL);

  g_slist_free (expected);

  g_strfreev (tokens);

  return ret;

}

static gboolean

test_split (const gchar *pattern,

	    const gchar *string,

	    ...)

{

  GRegex *regex;

  va_list args;

  GSList *expected = NULL;

  GSList *l_exp;

  gchar **tokens;

  gint token_count;

  gboolean ret = TRUE;

  gint i;

  verbose ("splitting \"%s\" against \"%s\" \t", string, pattern);

  /* The va_list is a NULL-terminated sequence of extected strings. */

  va_start (args, string);

  while (TRUE)

   {

      gchar *expected_string = va_arg (args, gchar *);

      if (expected_string == NULL)

        break;

      else

        expected = g_slist_prepend (expected, g_strdup (expected_string));

    }

  expected = g_slist_reverse (expected);

  va_end (args);

  regex = g_regex_new (pattern, 0, 0, NULL);

  tokens = g_regex_split (regex, string, 0);

  if (tokens)

    token_count = g_strv_length (tokens);

  else

    token_count = 0;

  if (token_count != g_slist_length (expected))

    {

      g_print ("failed \t(got %d %s, expected %d)\n", token_count,

	       token_count == 1 ? "match" : "matches", 

	       g_slist_length (expected));

      ret = FALSE;

      goto exit;

    }

  l_exp = expected;

  for (i = 0; l_exp != NULL; i++, l_exp = g_slist_next (l_exp))

    {

      if (!streq(l_exp->data, tokens [i]))

	{

	  g_print ("failed \t(got \"%s\", expected \"%s\")\n",

		   tokens[i], (gchar *)l_exp->data);

	  ret = FALSE;

	  goto exit;

	}

    }

  verbose ("passed (%d %s)\n", token_count,

	   token_count == 1 ? "token" : "tokens");

exit:

  g_regex_unref (regex);

  g_slist_foreach (expected, (GFunc)g_free, NULL);

  g_slist_free (expected);