/* 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 <glib.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#ifdef SYMBIAN

#include "mrt2_glib2_test.h"

#endif /*SYMBIAN*/

typedef struct _TestResult TestResult;

struct _TestResult

{

  gint argc;

  const gchar **argv;

};

static const gchar *

test_command_lines[] =

{

  /*  0 */ "foo bar",

  /*  1 */ "foo 'bar'",

  /*  2 */ "foo \"bar\"",

  /*  3 */ "foo '' 'bar'",

  /*  4 */ "foo \"bar\"'baz'blah'foo'\\''blah'\"boo\"",

  /*  5 */ "foo \t \tblah\tfoo\t\tbar  baz",

  /*  6 */ "foo '    spaces more spaces lots of     spaces in this   '  \t",

  /*  7 */ "foo \\\nbar",

  /*  8 */ "foo '' ''",

  /*  9 */ "foo \\\" la la la",

  /* 10 */ "foo \\ foo woo woo\\ ",

  /* 11 */ "foo \"yada yada \\$\\\"\"",

  /* 12 */ "foo \"c:\\\\\"",

  NULL

};

static const gchar *result0[] = { "foo", "bar", NULL };

static const gchar *result1[] = { "foo", "bar", NULL };

static const gchar *result2[] = { "foo", "bar", NULL };

static const gchar *result3[] = { "foo", "", "bar", NULL };

static const gchar *result4[] = { "foo", "barbazblahfoo'blahboo", NULL };

static const gchar *result5[] = { "foo", "blah", "foo", "bar", "baz", NULL };

static const gchar *result6[] = { "foo", "    spaces more spaces lots of     spaces in this   ", NULL };

static const gchar *result7[] = { "foo", "bar", NULL };

static const gchar *result8[] = { "foo", "", "", NULL };

static const gchar *result9[] = { "foo", "\"", "la", "la", "la", NULL };

static const gchar *result10[] = { "foo", " foo", "woo", "woo ", NULL };

static const gchar *result11[] = { "foo", "yada yada $\"", NULL };

static const gchar *result12[] = { "foo", "c:\\", NULL };

static const TestResult

correct_results[] =

{

  { G_N_ELEMENTS (result0) - 1, result0 },

  { G_N_ELEMENTS (result1) - 1, result1 },

  { G_N_ELEMENTS (result2) - 1, result2 },

  { G_N_ELEMENTS (result3) - 1, result3 },

  { G_N_ELEMENTS (result4) - 1, result4 },

  { G_N_ELEMENTS (result5) - 1, result5 },

  { G_N_ELEMENTS (result6) - 1, result6 },

  { G_N_ELEMENTS (result7) - 1, result7 },

  { G_N_ELEMENTS (result8) - 1, result8 },

  { G_N_ELEMENTS (result9) - 1, result9 },

  { G_N_ELEMENTS (result10) - 1, result10 },

  { G_N_ELEMENTS (result11) - 1, result11 },

  { G_N_ELEMENTS (result12) - 1, result12 }

};

static void

print_test (const gchar *cmdline, gint argc, gchar **argv,

            const TestResult *result)

{

  gint i;

  g_print("Command line was: '%s'\n", cmdline);

  g_print("Expected result (%d args):\n", result->argc);

  i = 0;

  while (result->argv[i])

    {

      g_print(" %3d '%s'\n", i, result->argv[i]);

      ++i;

    }  

  g_print("Actual result (%d args):\n", argc);

  i = 0;

  while (argv[i])

    {

      g_print(" %3d '%s'\n", i, argv[i]);

      ++i;

    }

}

static void

do_argv_test (const gchar *cmdline, const TestResult *result)

{

  gint argc;

  gchar **argv;

  GError *err;

  gint i;

  err = NULL;

  if (!g_shell_parse_argv (cmdline, &argc, &argv, &err))

    {

      g_print("Error parsing command line that should work fine: %s\n",

               err->message);

      g_assert(FALSE && "shell-test");

      exit (1);

    }

  if (argc != result->argc)

    {

      g_print("Expected and actual argc don't match\n");

      print_test (cmdline, argc, argv, result);

      exit (1);

    }

  i = 0;

  while (argv[i])

    {

      if (strcmp (argv[i], result->argv[i]) != 0)

        {

          g_print("Expected and actual arg %d do not match\n", i);

          print_test (cmdline, argc, argv, result);

          exit (1);

        }

      ++i;

    }

  if (argv[i] != NULL)

    {

      g_print("argv didn't get NULL-terminated\n");

      exit (1);

    }

}

static void

run_tests (void)

{

  gint i;

  i = 0;

  while (test_command_lines[i])

    {

      do_argv_test (test_command_lines[i], &correct_results[i]);

      ++i;

    }

}

static gboolean any_test_failed = FALSE;

#define CHECK_STRING_RESULT(expression, expected_value) \

 check_string_result (#expression, __FILE__, __LINE__, expression, expected_value)

static void

check_string_result (const char *expression,

		     const char *file_name,

		     int line_number,

		     char *result,

		     const char *expected)

{

  gboolean match;

  if (expected == NULL)

    match = result == NULL;

  else

    match = result != NULL && strcmp (result, expected) == 0;

  if (!match)

    {

      if (!any_test_failed)

	g_print("\n");

      g_print("FAIL: check failed in %s, line %d\n", file_name, line_number);

      g_print("evaluated: %s\n", expression);

      g_print("expected: %s\n", expected == NULL ? "NULL" : expected);

      g_print("got: %s\n", result == NULL ? "NULL" : result);

      g_assert(FALSE && "shell-test");

      any_test_failed = TRUE;

    }

  g_free (result);

}

static char *

test_shell_unquote (const char *str)

{

  char *result;

  GError *error;

  error = NULL;

  result = g_shell_unquote (str, &error);

  if (error == NULL)

    return result;

  /* Leaks the error, which is no big deal and easy to fix if we

   * decide it matters.

   */

  if (error->domain != G_SHELL_ERROR)

    return g_strdup ("error in domain other than G_SHELL_ERROR");

  /* It would be nice to check the error message too, but that's

   * localized, so it's too much of a pain.

   */

  switch (error->code)

    {

    case G_SHELL_ERROR_BAD_QUOTING:

      return g_strdup ("G_SHELL_ERROR_BAD_QUOTING");

    case G_SHELL_ERROR_EMPTY_STRING:

      return g_strdup ("G_SHELL_ERROR_EMPTY_STRING");

    case G_SHELL_ERROR_FAILED:

      return g_strdup ("G_SHELL_ERROR_FAILED");

    default:

      return g_strdup ("bad error code in G_SHELL_ERROR domain");

    }

}

int

main (int   argc,

      char *argv[])

{

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

  run_tests ();

  CHECK_STRING_RESULT (g_shell_quote (""), "''");

  CHECK_STRING_RESULT (g_shell_quote ("a"), "'a'");

  CHECK_STRING_RESULT (g_shell_quote ("("), "'('");

  CHECK_STRING_RESULT (g_shell_quote ("'"), "''\\'''");

  CHECK_STRING_RESULT (g_shell_quote ("'a"), "''\\''a'");

  CHECK_STRING_RESULT (g_shell_quote ("a'"), "'a'\\'''");

  CHECK_STRING_RESULT (g_shell_quote ("a'a"), "'a'\\''a'");

  CHECK_STRING_RESULT (test_shell_unquote (""), "");

  CHECK_STRING_RESULT (test_shell_unquote ("a"), "a");

  CHECK_STRING_RESULT (test_shell_unquote ("'a'"), "a");

  CHECK_STRING_RESULT (test_shell_unquote ("'('"), "(");

  CHECK_STRING_RESULT (test_shell_unquote ("''\\'''"), "'");

  CHECK_STRING_RESULT (test_shell_unquote ("''\\''a'"), "'a");

  CHECK_STRING_RESULT (test_shell_unquote ("'a'\\'''"), "a'");

  CHECK_STRING_RESULT (test_shell_unquote ("'a'\\''a'"), "a'a");

  CHECK_STRING_RESULT (test_shell_unquote ("\\\\"), "\\");

  CHECK_STRING_RESULT (test_shell_unquote ("\\\n"), "");

  CHECK_STRING_RESULT (test_shell_unquote ("'\\''"), "G_SHELL_ERROR_BAD_QUOTING");

#if defined (_MSC_VER) && (_MSC_VER <= 1200)

  /* using \x22 instead of \" to work around a msvc 5.0, 6.0 compiler bug */

  CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\x22\""), "\"");

#else

  CHECK_STRING_RESULT (test_shell_unquote ("\"\\\"\""), "\"");

#endif

  CHECK_STRING_RESULT (test_shell_unquote ("\""), "G_SHELL_ERROR_BAD_QUOTING");

  CHECK_STRING_RESULT (test_shell_unquote ("'"), "G_SHELL_ERROR_BAD_QUOTING");

  CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\\\""), "\\");

  CHECK_STRING_RESULT (test_shell_unquote ("\x22\\`\""), "`");

  CHECK_STRING_RESULT (test_shell_unquote ("\x22\\$\""), "$");

  CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\n\""), "\n");

  CHECK_STRING_RESULT (test_shell_unquote ("\"\\'\""), "\\'");

  CHECK_STRING_RESULT (test_shell_unquote ("\x22\\\r\""), "\\\r");

  CHECK_STRING_RESULT (test_shell_unquote ("\x22\\n\""), "\\n");

#ifdef SYMBIAN

  testResultXml("shell-test");

#endif /* EMULATOR */	

  return any_test_failed ? 1 : 0;

}