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

 }