/* GLIB - Library of useful routines for C programming

 * Copyright (C) 2001 Matthias Clasen <matthiasc@poet.de>

 *

 * 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

#include <string.h>

#include <stdio.h>

#include "glib.h"

#include "glib/gpattern.h"

#ifdef SYMBIAN

#include "mrt2_glib2_test.h"

#endif /*SYMBIAN*/

static gboolean noisy = FALSE;

static void

verbose (const gchar *format, ...)

{

  gchar *msg;

  va_list args;

  va_start (args, format);

  msg = g_strdup_vprintf (format, args);

  va_end (args);

  if (noisy) 

    g_print (msg);

  g_free (msg);

}

/* keep enum and structure of gpattern.c and patterntest.c in sync */

typedef enum

{

  G_MATCH_ALL,       /* "*A?A*" */

  G_MATCH_ALL_TAIL,  /* "*A?AA" */

  G_MATCH_HEAD,      /* "AAAA*" */

  G_MATCH_TAIL,      /* "*AAAA" */

  G_MATCH_EXACT,     /* "AAAAA" */

  G_MATCH_LAST

} GMatchType;

struct _GPatternSpec

{

  GMatchType match_type;

  guint      pattern_length;

  guint      min_length;

  guint      max_length;

  gchar     *pattern;

};

static gchar *

match_type_name (GMatchType match_type)

{

  switch (match_type)

    {

    case G_MATCH_ALL: 

      return "G_MATCH_ALL";

      break;

    case G_MATCH_ALL_TAIL:

      return "G_MATCH_ALL_TAIL";

      break;

    case G_MATCH_HEAD:

      return "G_MATCH_HEAD";

      break;

    case G_MATCH_TAIL:

      return "G_MATCH_TAIL";

      break;

    case G_MATCH_EXACT:

      return "G_MATCH_EXACT";

      break;

    default:

      return "unknown GMatchType";

      break;

    }

}

static gboolean

test_compilation (gchar *src, 

		  GMatchType match_type, 

		  gchar *pattern,

		  guint min)

{

  GPatternSpec *spec; 

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

  spec = g_pattern_spec_new (src);

  if (spec->match_type != match_type)

    {

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

	       match_type_name (spec->match_type), 

	       match_type_name (match_type));

	  g_assert(FALSE && "patterntest");

      return FALSE;

    }

  if (strcmp (spec->pattern, pattern) != 0)

    {

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

	       spec->pattern,

	       pattern);

	g_assert(FALSE && "patterntest");	       

      return FALSE;

    }

  if (spec->pattern_length != strlen (spec->pattern))

    {

      g_print ("failed \t(pattern_length: %d, expected %d)\n",

	       spec->pattern_length,

	       (gint)strlen (spec->pattern));

	  g_assert(FALSE && "patterntest");

      return FALSE;

    }

  if (spec->min_length != min)

    {

      g_print ("failed \t(min_length: %d, expected %d)\n",

	       spec->min_length,

	       min);

	  g_assert(FALSE && "patterntest");

      return FALSE;

    }

  verbose ("passed (%s: \"%s\")\n",

	   match_type_name (spec->match_type),

	   spec->pattern);

  return TRUE;

}

static gboolean

test_match (gchar *pattern, 

	    gchar *string, 

	    gboolean match)

{

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

  if (g_pattern_match_simple (pattern, string) != match)

    {

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

      g_assert(FALSE && "patterntest");

      return FALSE;

    }

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

  return TRUE;

}

static gboolean

test_equal (gchar *pattern1,

	    gchar *pattern2,

	    gboolean expected)

{

  GPatternSpec *p1 = g_pattern_spec_new (pattern1);

  GPatternSpec *p2 = g_pattern_spec_new (pattern2);

  gboolean equal = g_pattern_spec_equal (p1, p2);

  verbose ("comparing \"%s\" with \"%s\" \t", pattern1, pattern2);

  if (expected != equal)

    {

      g_print ("failed \t{%s, %u, \"%s\"} %s {%s, %u, \"%s\"}\n",

	       match_type_name (p1->match_type), p1->pattern_length, p1->pattern,

	       expected ? "!=" : "==",

	       match_type_name (p2->match_type), p2->pattern_length, p2->pattern);

    g_assert(FALSE && "patterntest");

    }

  else

    verbose ("passed (%s)\n", equal ? "equal" : "unequal");

  g_pattern_spec_free (p1);

  g_pattern_spec_free (p2);

  return expected == equal;

}

#define TEST_COMPILATION(src, type, pattern, min) { \

  total++; \

  if (test_compilation (src, type, pattern, min)) \

    passed++; \

  else \

    failed++; \

}

#define TEST_MATCH(pattern, string, match) { \

  total++; \

  if (test_match (pattern, string, match)) \

    passed++; \

  else \

    failed++; \

}

#define TEST_EQUAL(pattern1, pattern2, match) { \

  total++; \

  if (test_equal (pattern1, pattern2, match)) \

    passed++; \

  else \

    failed++; \

}

int

main (int argc, char** argv)

{

  gint total = 0;

  gint passed = 0;

  gint failed = 0;

  gint i;

  #ifdef SYMBIAN

  g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);

  g_set_print_handler(mrtPrintHandler);

  #endif /*SYMBIAN*/

  for (i = 1; i < argc; i++) 

      if (strcmp ("--noisy", argv[i]) == 0)

	noisy = TRUE;

  TEST_COMPILATION("*A?B*", G_MATCH_ALL, "*A?B*", 3);

  TEST_COMPILATION("ABC*DEFGH", G_MATCH_ALL_TAIL, "HGFED*CBA", 8);

  TEST_COMPILATION("ABCDEF*GH", G_MATCH_ALL, "ABCDEF*GH", 8);

  TEST_COMPILATION("ABC**?***??**DEF*GH", G_MATCH_ALL, "ABC*???DEF*GH", 11);

  TEST_COMPILATION("*A?AA", G_MATCH_ALL_TAIL, "AA?A*", 4);

  TEST_COMPILATION("ABCD*", G_MATCH_HEAD, "ABCD", 4);

  TEST_COMPILATION("*ABCD", G_MATCH_TAIL, "ABCD", 4);

  TEST_COMPILATION("ABCDE", G_MATCH_EXACT, "ABCDE", 5);

  TEST_COMPILATION("A?C?E", G_MATCH_ALL, "A?C?E", 5);

  TEST_COMPILATION("*?x", G_MATCH_ALL_TAIL, "x?*", 2);

  TEST_COMPILATION("?*x", G_MATCH_ALL_TAIL, "x?*", 2);

  TEST_COMPILATION("*?*x", G_MATCH_ALL_TAIL, "x?*", 2);

  TEST_COMPILATION("x*??", G_MATCH_ALL_TAIL, "??*x", 3);

  TEST_EQUAL("*A?B*", "*A?B*", TRUE);

  TEST_EQUAL("A*BCD", "A*BCD", TRUE);

  TEST_EQUAL("ABCD*", "ABCD****", TRUE);

  TEST_EQUAL("A1*", "A1*", TRUE);

  TEST_EQUAL("*YZ", "*YZ", TRUE);

  TEST_EQUAL("A1x", "A1x", TRUE);

  TEST_EQUAL("AB*CD", "AB**CD", TRUE);

  TEST_EQUAL("AB*?*CD", "AB*?CD", TRUE);

  TEST_EQUAL("AB*?CD", "AB?*CD", TRUE);

  TEST_EQUAL("AB*CD", "AB*?*CD", FALSE);

  TEST_EQUAL("ABC*", "ABC?", FALSE);

  TEST_MATCH("*x", "x", TRUE);

  TEST_MATCH("*x", "xx", TRUE);

  TEST_MATCH("*x", "yyyx", TRUE);

  TEST_MATCH("*x", "yyxy", FALSE);

  TEST_MATCH("?x", "x", FALSE);

  TEST_MATCH("?x", "xx", TRUE);

  TEST_MATCH("?x", "yyyx", FALSE);

  TEST_MATCH("?x", "yyxy", FALSE);

  TEST_MATCH("*?x", "xx", TRUE);

  TEST_MATCH("?*x", "xx", TRUE);

  TEST_MATCH("*?x", "x", FALSE);

  TEST_MATCH("?*x", "x", FALSE);

  TEST_MATCH("*?*x", "yx", TRUE);

  TEST_MATCH("*?*x", "xxxx", TRUE);

  TEST_MATCH("x*??", "xyzw", TRUE);

  TEST_MATCH("*x", "\xc3\x84x", TRUE);

  TEST_MATCH("?x", "\xc3\x84x", TRUE);

  TEST_MATCH("??x", "\xc3\x84x", FALSE);

  TEST_MATCH("ab\xc3\xa4\xc3\xb6", "ab\xc3\xa4\xc3\xb6", TRUE);

  TEST_MATCH("ab\xc3\xa4\xc3\xb6", "abao", FALSE);

  TEST_MATCH("ab?\xc3\xb6", "ab\xc3\xa4\xc3\xb6", TRUE);

  TEST_MATCH("ab?\xc3\xb6", "abao", FALSE);

  TEST_MATCH("ab\xc3\xa4?", "ab\xc3\xa4\xc3\xb6", TRUE);

  TEST_MATCH("ab\xc3\xa4?", "abao", FALSE);

  TEST_MATCH("ab??", "ab\xc3\xa4\xc3\xb6", TRUE);

  TEST_MATCH("ab*", "ab\xc3\xa4\xc3\xb6", TRUE);

  TEST_MATCH("ab*\xc3\xb6", "ab\xc3\xa4\xc3\xb6", TRUE);

  TEST_MATCH("ab*\xc3\xb6", "aba\xc3\xb6x\xc3\xb6", TRUE);

  TEST_MATCH("", "", TRUE);

  TEST_MATCH("", "abc", FALSE);

  verbose ("\n%u tests passed, %u failed\n", passed, failed);

#ifdef SYMBIAN

  testResultXml("patterntest");

#endif /* EMULATOR */

  return failed;

}