/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 * Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). 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.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/. 

 */

#undef G_DISABLE_ASSERT

#undef G_LOG_DOMAIN

#include "config.h"

#include <glib.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#ifdef __SYMBIAN32__

#include "mrt2_glib2_test.h"

#endif /*__SYMBIAN32__*/

typedef struct

{

  char *filename;

  char *hostname;

  char *expected_result;

  GConvertError expected_error; /* If failed */

}  ToUriTest;

ToUriTest

to_uri_tests[] = {

  { "/etc", NULL, "file:///etc"},

  { "/etc", "", "file:///etc"},

  { "/etc", "otherhost", "file://otherhost/etc"},

#if defined(G_OS_WIN32) || defined (__SYMBIAN32__)

  { "/etc", "localhost", "file:///etc"},

  { "c:\\windows", NULL, "file:///c:/windows"},

  { "c:\\windows", "localhost", "file:///c:/windows"},

  { "c:\\windows", "otherhost", "file://otherhost/c:/windows"},

  { "\\\\server\\share\\dir", NULL, "file:////server/share/dir"},

  { "\\\\server\\share\\dir", "localhost", "file:////server/share/dir"},

#else

  { "/etc", "localhost", "file://localhost/etc"},

  { "c:\\windows", NULL, NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH}, /* it's important to get this error on Unix */

  { "c:\\windows", "localhost", NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH},

  { "c:\\windows", "otherhost", NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH},

#endif

  { "etc", "localhost", NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH},

#ifndef G_PLATFORM_WIN32

  { "/etc/\xE5\xE4\xF6", NULL, "file:///etc/%E5%E4%F6" },

  { "/etc/\xC3\xB6\xC3\xA4\xC3\xA5", NULL, "file:///etc/%C3%B6%C3%A4%C3%A5"},

#endif

  { "/etc", "\xC3\xB6\xC3\xA4\xC3\xA5", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/etc", "\xE5\xE4\xF6", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/etc/file with #%", NULL, "file:///etc/file%20with%20%23%25"},

  { "", NULL, NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH},

  { "", "", NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH},

  { "", "localhost", NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH},

  { "", "otherhost", NULL, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH},

  { "/0123456789", NULL, "file:///0123456789"},

  { "/ABCDEFGHIJKLMNOPQRSTUVWXYZ", NULL, "file:///ABCDEFGHIJKLMNOPQRSTUVWXYZ"},

  { "/abcdefghijklmnopqrstuvwxyz", NULL, "file:///abcdefghijklmnopqrstuvwxyz"},

  { "/-_.!~*'()", NULL, "file:///-_.!~*'()"},

#if defined(G_OS_WIN32) || defined(__SYMBIAN32__)

  /* As '\\' is a path separator on Win32, it gets turned into '/' in the URI */

  { "/\"#%<>[\\]^`{|}\x7F", NULL, "file:///%22%23%25%3C%3E%5B/%5D%5E%60%7B%7C%7D%7F"},

#else

  /* On Unix, '\\' is a normal character in the file name */

  { "/\"#%<>[\\]^`{|}\x7F", NULL, "file:///%22%23%25%3C%3E%5B%5C%5D%5E%60%7B%7C%7D%7F"},

#endif

  { "/;@+$,", NULL, "file:///%3B@+$,"},

  /* This and some of the following are of course as such illegal file names on Windows,

   * and would not occur in real life.

   */

  { "/:", NULL, "file:///:"},

  { "/?&=", NULL, "file:///%3F&="}, 

  { "/", "0123456789-", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "file://ABCDEFGHIJKLMNOPQRSTUVWXYZ/"},

  { "/", "abcdefghijklmnopqrstuvwxyz", "file://abcdefghijklmnopqrstuvwxyz/"},

  { "/", "_.!~*'()", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/", "\"#%<>[\\]^`{|}\x7F", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/", ";?&=+$,", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/", "/", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/", "@:", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/", "\x80\xFF", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

  { "/", "\xC3\x80\xC3\xBF", NULL, G_CONVERT_ERROR_ILLEGAL_SEQUENCE},

};

typedef struct

{

  char *uri;

  char *expected_filename;

  char *expected_hostname;

  GConvertError expected_error; /* If failed */

}  FromUriTest;

FromUriTest

from_uri_tests[] = {

  { "file:///etc", "\\etc"},

  { "file:/etc", "\\etc"},

#if defined(G_OS_WIN32) || defined(__SYMBIAN32__)

  /* On Win32 we don't return "localhost" hostames, just in case

   * it isn't recognized anyway.

   */

  { "file://localhost/etc", "\\etc", NULL},

  /*{ "file://localhost/etc/%23%25%20file", "\\etc/#% file", NULL},*/

  { "file://localhost/\xE5\xE4\xF6", "\\\xe5\xe4\xf6", NULL},

  { "file://localhost/%E5%E4%F6", "\\\xe5\xe4\xf6", NULL},

#else

  { "file://localhost/etc", "\etc", "localhost"},

  { "file://localhost/etc/%23%25%20file", "/etc/#% file", "localhost"},

  { "file://localhost/\xE5\xE4\xF6", "/\xe5\xe4\xf6", "localhost"},

  { "file://localhost/%E5%E4%F6", "/\xe5\xe4\xf6", "localhost"},

#endif

  { "file://otherhost/etc", "\\etc", "otherhost"},

  /*{ "file://otherhost/etc/%23%25%20file", "/etc/#% file", "otherhost"},*/

  { "file://%C3%B6%C3%A4%C3%A5/etc", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file:////etc/%C3%B6%C3%C3%C3%A5", "\\\\etc\\\xc3\xb6\xc3\xc3\xc3\xa5", NULL},

  { "file://\xE5\xE4\xF6/etc", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://%E5%E4%F6/etc", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file:///some/file#bad", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://some", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file:test", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "http://www.yahoo.com/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file:////etc", "\\\\etc"},

  { "file://///etc", "\\\\\\etc"},

#if defined(G_OS_WIN32) || defined (__SYMBIAN32__)

  /* URIs with backslashes come from some nonstandard application, but accept them anyhow */

  { "file:///c:\\foo", "c:\\foo"},

  { "file:///c:/foo\\bar", "c:\\foo\\bar"},

  /* Accept also the old Netscape drive-letter-and-vertical bar convention */

  { "file:///c|/foo", "c:\\foo"},

  { "file:////server/share/dir", "\\\\server\\share\\dir"},

  { "file://localhost//server/share/foo", "\\\\server\\share\\foo"},

  { "file://otherhost//server/share/foo", "\\\\server\\share\\foo", "otherhost"},

#else

  { "file:///c:\\foo", "/c:\\foo"},

  { "file:///c:/foo", "/c:/foo"},

  { "file:////c:/foo", "//c:/foo"},

#endif

  { "file://0123456789/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://ABCDEFGHIJKLMNOPQRSTUVWXYZ/", "\\", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"},

  { "file://abcdefghijklmnopqrstuvwxyz/", "\\", "abcdefghijklmnopqrstuvwxyz"},

  { "file://-_.!~*'()/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://\"<>[\\]^`{|}\x7F/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://;?&=+$,/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://%C3%80%C3%BF/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://@/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://:/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://#/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://%23/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

  { "file://%2F/", NULL, NULL, G_CONVERT_ERROR_BAD_URI},

};

static gboolean any_failed = FALSE;

static void

run_to_uri_tests (void)

{

  int i;

  gchar *res;

  GError *error;

  for (i = 0; i < G_N_ELEMENTS (to_uri_tests); i++)

    {

      error = NULL;

      res = g_filename_to_uri (to_uri_tests[i].filename,

			       to_uri_tests[i].hostname,

			       &error);

      if (to_uri_tests[i].expected_result == NULL)

	{

	  if (res != NULL)

	    {

	      g_print ("\ng_filename_to_uri() test %d failed, expected to return NULL, actual result: %s\n", i, res);

	      any_failed = TRUE;

	    }

	  else

	    {

	      if (error == NULL)

		{

		  g_print ("\ng_filename_to_uri() test %d failed, returned NULL, but didn't set error\n", i);

		  any_failed = TRUE;

		}

	      else if (error->domain != G_CONVERT_ERROR)

		{

		  g_print ("\ng_filename_to_uri() test %d failed, returned NULL, set non G_CONVERT_ERROR error\n", i);

		  any_failed = TRUE;

		}

	      else if (error->code != to_uri_tests[i].expected_error)

		{

		  g_print ("\ng_filename_to_uri() test %d failed as expected, but set wrong errorcode %d instead of expected %d \n",

			   i, error->code, to_uri_tests[i].expected_error);

		  any_failed = TRUE;

		}

	    }

	}

      else if (res == NULL || strcmp (res, to_uri_tests[i].expected_result) != 0)

	{

	  g_print ("\ng_filename_to_uri() test %d failed, expected result: %s, actual result: %s\n",

		   i, to_uri_tests[i].expected_result, (res) ? res : "NULL");

	  if (error)

	    g_print ("Error message: %s\n", error->message);

	  any_failed = TRUE;

	}

      g_free (res);

    }

}

static void

run_from_uri_tests (void)

{

  int i;

  gchar *res;

  gchar *hostname;

  GError *error;

  for (i = 0; i < G_N_ELEMENTS (from_uri_tests); i++)

    {

      error = NULL;

      res = g_filename_from_uri (from_uri_tests[i].uri,

				 &hostname,

				 &error);

      if (from_uri_tests[i].expected_filename == NULL)

	{

	  if (res != NULL)

	    {

	      g_print ("\ng_filename_from_uri() test %d failed, expected to return NULL, actual result: %s\n", i, res);

	      any_failed = TRUE;

	    }

	  else

	    {

	      if (error == NULL)

		{

		  g_print ("\ng_filename_from_uri() test %d failed, returned NULL, but didn't set error\n", i);

		  any_failed = TRUE;

		}

	      else if (error->domain != G_CONVERT_ERROR)

		{

		  g_print ("\ng_filename_from_uri() test %d failed, returned NULL, set non G_CONVERT_ERROR error\n", i);

		  any_failed = TRUE;

		}

	      else if (error->code != from_uri_tests[i].expected_error)

		{

		  g_print ("\ng_filename_from_uri() test %d failed as expected, but set wrong errorcode %d instead of expected %d \n",

			   i, error->code, from_uri_tests[i].expected_error);

		  any_failed = TRUE;

		}

	    }

	}

      else

	{

#ifdef G_OS_WIN32

	  gchar *slash, *p;

	  p = from_uri_tests[i].expected_filename = g_strdup (from_uri_tests[i].expected_filename);

	  while ((slash = strchr (p, '/')) != NULL)

	    {

	      *slash = '\\';

	      p = slash + 1;

	    }

#endif

	  if (res == NULL || strcmp (res, from_uri_tests[i].expected_filename) != 0)

	    {

	      g_print ("\ng_filename_from_uri() test %d failed, expected result: %s, actual result: %s\n",

		       i, from_uri_tests[i].expected_filename, (res) ? res : "NULL");

	      any_failed = TRUE;

	    }

	  if (from_uri_tests[i].expected_hostname == NULL)

	    {

	      if (hostname != NULL)

		{

		  g_print ("\ng_filename_from_uri() test %d failed, expected no hostname, got: %s\n",

			   i, hostname);

		  any_failed = TRUE;

		}

	    }

	  else if (hostname == NULL ||

		   strcmp (hostname, from_uri_tests[i].expected_hostname) != 0)

	    {

	      g_print ("\ng_filename_from_uri() test %d failed, expected hostname: %s, actual result: %s\n",

		       i, from_uri_tests[i].expected_hostname, (hostname) ? hostname : "NULL");

	      any_failed = TRUE;

	    }

	}

    }

}

static gint

safe_strcmp (const gchar *a, const gchar *b)

{

  return strcmp (a ? a : "", b ? b : "");

}

static gint

safe_strcmp_filename (const gchar *a, const gchar *b)

{

#if !defined(G_OS_WIN32) && !defined(__SYMBIAN32__)

  return safe_strcmp (a, b);

#else

  if (!a || !b)

    return safe_strcmp (a, b);

  else

    {

      while (*a && *b)

	{

	  if ((G_IS_DIR_SEPARATOR (*a) && G_IS_DIR_SEPARATOR (*b)) ||

	      *a == *b)

	    a++, b++;

	  else

	    return (*a - *b);

	}

      return (*a - *b);

    }

#endif

}

static gint

safe_strcmp_hostname (const gchar *a, const gchar *b)

{

#if !defined(G_OS_WIN32) && !defined(__SYMBIAN32__)

  return safe_strcmp (a, b);

#else

  if (safe_strcmp (a, "localhost") == 0 && b == NULL)

    return 0;

  else

    return safe_strcmp (a, b);

#endif

}

static void

run_roundtrip_tests (void)

{

  int i;

  gchar *uri, *hostname, *res;

  GError *error;

  for (i = 0; i < G_N_ELEMENTS (to_uri_tests); i++)

    {

      if (to_uri_tests[i].expected_error != 0)

	continue;

      error = NULL;

      uri = g_filename_to_uri (to_uri_tests[i].filename,

			       to_uri_tests[i].hostname,

			       &error);

      if (error != NULL)

	{

	  g_print ("g_filename_to_uri failed unexpectedly: %s\n", 

		   error->message);

	  any_failed = TRUE;

	  continue;

	}

      error = NULL;

      res = g_filename_from_uri (uri, &hostname, &error);

      if (error != NULL)

	{

	  g_print ("g_filename_from_uri failed unexpectedly: %s\n", 

		   error->message);

	  any_failed = TRUE;

	  continue;

	}

      if (safe_strcmp_filename (to_uri_tests[i].filename, res))

	{

	  g_print ("roundtrip test %d failed, filename modified: "

		   " expected \"%s\", but got \"%s\"\n",

		   i, to_uri_tests[i].filename, res);

	  any_failed = TRUE;

	}

      if (safe_strcmp_hostname (to_uri_tests[i].hostname, hostname))

	{

	  g_print ("roundtrip test %d failed, hostname modified: "

		     " expected \"%s\", but got \"%s\"\n",

		   i, to_uri_tests[i].hostname, hostname);

	  any_failed = TRUE;

	}

    }

}

static void

run_uri_list_tests (void)

{

  /* straight from the RFC */

  gchar *list =

    "# urn:isbn:0-201-08372-8\r\n"

    "http://www.huh.org/books/foo.html\r\n"

    "http://www.huh.org/books/foo.pdf   \r\n"

    "   ftp://ftp.foo.org/books/foo.txt\r\n";

  gchar *expected_uris[] = {

    "http://www.huh.org/books/foo.html",

    "http://www.huh.org/books/foo.pdf",

    "ftp://ftp.foo.org/books/foo.txt"

  };

  gchar **uris;

  gint j;

  uris = g_uri_list_extract_uris (list);

  if (g_strv_length (uris) != 3)

    {

      g_print ("uri list test failed: "

	       " expected %d uris, but got %d\n",

	       3, g_strv_length (uris));

      any_failed = TRUE;

    }

  for (j = 0; j < 3; j++)

    {

      if (safe_strcmp (uris[j], expected_uris[j])) 

	{

	  g_print ("uri list test failed: "

		   " expected \"%s\", but got \"%s\"\n",

		   expected_uris[j], uris[j]);

	  any_failed = TRUE;

	}

    }

  g_strfreev (uris);

  uris = g_uri_list_extract_uris ("# just hot air\r\n# more hot air");

  if (g_strv_length (uris) != 0)

    {

      g_print ("uri list test 2 failed: "

	       " expected %d uris, but got %d (first is \"%s\")\n",

	       0, g_strv_length (uris), uris[0]);

      any_failed = TRUE;

    }

}

int

main (int   argc,

      char *argv[])

{

  #ifdef __SYMBIAN32__

  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 /*__SYMBIAN32__*/

#ifdef G_OS_UNIX

#  ifdef HAVE_UNSETENV  

  unsetenv ("G_BROKEN_FILENAMES");

#  else

  /* putenv with no = isn't standard, but works to unset the variable

   * on some systems

   */

  putenv ("G_BROKEN_FILENAMES");

#  endif  

#endif

  run_to_uri_tests ();

  run_from_uri_tests ();

  run_roundtrip_tests ();

  run_uri_list_tests ();

  #ifdef __SYMBIAN32__

  assert_failed = any_failed;

  testResultXml("uri-test");

  #endif /* EMULATOR */

  return any_failed ? 1 : 0;

}