/*

 * 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; \

}