/* GLIB - Library of useful routines for C programming

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

  * Portions copyright (c) 2006-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.

  */

 /*

  * 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 <string.h>

 #include <glib.h>

 #ifdef __SYMBIAN32__

 #include "mrt2_glib2_test.h"

 #endif /*__SYMBIAN32__*/

 /* Bug 311337 */

 static void

 test_iconv_state (void)

 {

   gchar *in = "\xf4\xe5\xf8\xe5\xed";

   gchar *expected = "\xd7\xa4\xd7\x95\xd7\xa8\xd7\x95\xd7\x9d";

   gchar *out;

   gsize bytes_read = 0;

   gsize bytes_written = 0;

   GError *error = NULL;

   out = g_convert (in, -1, "UTF-8", "windows-1255", 

 		   &bytes_read, &bytes_written, &error);

   if (error && error->code == G_CONVERT_ERROR_NO_CONVERSION)

     return; /* silently skip if CP1255 is not supported, see bug 467707 */ 

   g_assert_no_error (error);

   g_assert (bytes_read == 5);

   g_assert (bytes_written == 10);

   g_assert (strcmp (out, expected) == 0);

   g_free (out);

 }

 /* some tests involving "vulgar fraction one half" */

 static void 

 test_one_half (void)

 {

   gchar *in = "\xc2\xbd";

   gchar *out;

   gsize bytes_read = 0;

   gsize bytes_written = 0;

   GError *error = NULL;  

   out = g_convert (in, -1, 

 		   "ISO-8859-1", "UTF-8",

 		   &bytes_read, &bytes_written,

 		   &error);

   g_assert_no_error (error);

   g_assert (bytes_read == 2);

   g_assert (bytes_written == 1);

   g_assert (strcmp (out, "\xbd") == 0);

   g_free (out);

   out = g_convert (in, -1, 

 		   "ISO-8859-15", "UTF-8",

 		   &bytes_read, &bytes_written,

 		   &error);

   g_assert_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE);

   g_assert (bytes_read == 0);

   g_assert (bytes_written == 0);

   g_assert (out == NULL);

   g_clear_error (&error);

   g_free (out);

   out = g_convert_with_fallback (in, -1, 

 				 "ISO-8859-15", "UTF-8",

 				 "a",

 				 &bytes_read, &bytes_written,

 				 &error);

   g_assert_no_error (error);

   g_assert (bytes_read == 2);

   g_assert (bytes_written == 1);

   g_assert (strcmp (out, "a") == 0);

   g_free (out);

 }

 static void

 test_byte_order (void)

 {

   gchar in_be[2] = { 0x03, 0x93}; /* capital gamma */

   gchar in_le[2] = { 0x93, 0x03};

   gchar *expected = "\xce\x93";

   gchar *out;

   gsize bytes_read = 0;

   gsize bytes_written = 0;

   GError *error = NULL;  

   out = g_convert (in_be, sizeof (in_be), 

 		   "UTF-8", "UTF-16BE",

 		   &bytes_read, &bytes_written,

 		   &error);

   g_assert_no_error (error);

   g_assert (bytes_read == 2);

   g_assert (bytes_written == 2);

   g_assert (strcmp (out, expected) == 0);

   g_free (out);

   out = g_convert (in_le, sizeof (in_le), 

 		   "UTF-8", "UTF-16LE",

 		   &bytes_read, &bytes_written,

 		   &error);

   g_assert_no_error (error);

   g_assert (bytes_read == 2);

   g_assert (bytes_written == 2);

   g_assert (strcmp (out, expected) == 0);

   g_free (out);

 }

 static void

 check_utf8_to_ucs4 (const char     *utf8,

 		    glong           utf8_len,

 		    const gunichar *ucs4,

 		    glong           ucs4_len,

 		    glong           error_pos)

 {

   gunichar *result, *result2, *result3;

   glong items_read, items_read2;

   glong items_written, items_written2;

   GError *error, *error2, *error3;

   gint i;

   if (!error_pos)

     {

       /* check the fast conversion */

       result = g_utf8_to_ucs4_fast (utf8, utf8_len, &items_written);

       g_assert (items_written == ucs4_len);

       g_assert (result);

       for (i = 0; i <= items_written; i++)

 	g_assert (result[i] == ucs4[i]);      

       g_free (result);

     }

   error = NULL;

   result = g_utf8_to_ucs4 (utf8, utf8_len, &items_read, &items_written, &error);

   if (utf8_len == strlen (utf8))

     {

       /* check that len == -1 yields identical results */

       error2 = NULL;

       result2 = g_utf8_to_ucs4 (utf8, -1, &items_read2, &items_written2, &error2);

       g_assert (error || items_read2 == items_read);

       g_assert (error || items_written2 == items_written2);

       g_assert (!!result == !!result2);

       g_assert (!!error == !!error2);

       if (result)

 	for (i = 0; i <= items_written; i++)

 	  g_assert (result[i] == result2[i]);

       g_free (result2);

       if (error2)

 	g_error_free (error2);

     }

   error3 = NULL;

   result3 = g_utf8_to_ucs4 (utf8, utf8_len, NULL, NULL, &error3);

   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)

     {

       g_assert_no_error (error);

       g_assert (items_read == error_pos);

       g_assert (items_written == ucs4_len);

       g_assert (result);

       for (i = 0; i <= items_written; i++)

 	g_assert (result[i] == ucs4[i]);

     }

   else if (error_pos)

     {

       g_assert (error != NULL);

       g_assert (result == NULL);

       g_assert (items_read == error_pos);

       g_error_free (error);

       g_assert (error3 != NULL);

       g_assert (result3 == NULL);

       g_error_free (error3);

     }

   else

     {

       g_assert_no_error (error);

       g_assert (items_read == utf8_len);

       g_assert (items_written == ucs4_len);

       g_assert (result);

       for (i = 0; i <= items_written; i++)

 	g_assert (result[i] == ucs4[i]);

       g_assert_no_error (error3);

       g_assert (result3);

       for (i = 0; i <= ucs4_len; i++)

 	g_assert (result3[i] == ucs4[i]);

     }

   g_free (result);

   g_free (result3);

 }

 static void

 check_ucs4_to_utf8 (const gunichar *ucs4,

 		    glong           ucs4_len,

 		    const char     *utf8,

 		    glong           utf8_len,

 		    glong           error_pos)

 {

   gchar *result, *result2, *result3;

   glong items_read, items_read2;

   glong items_written, items_written2;

   GError *error, *error2, *error3;

   error = NULL;

   result = g_ucs4_to_utf8 (ucs4, ucs4_len, &items_read, &items_written, &error);

   if (ucs4[ucs4_len] == 0)

     {

       /* check that len == -1 yields identical results */

       error2 = NULL;

       result2 = g_ucs4_to_utf8 (ucs4, -1, &items_read2, &items_written2, &error2);

       g_assert (error || items_read2 == items_read);

       g_assert (error || items_written2 == items_written);

       g_assert (!!result == !!result2);

       g_assert (!!error == !!error2);

       if (result)

 	g_assert (strcmp (result, result2) == 0);

       g_free (result2);

       if (error2)

 	g_error_free (error2);

     }

   error3 = NULL;

   result3 = g_ucs4_to_utf8 (ucs4, ucs4_len, NULL, NULL, &error3);

   if (error_pos)

     {

       g_assert (error != NULL);

       g_assert (result == NULL);

       g_assert (items_read == error_pos);

       g_error_free (error);

       g_assert (error3 != NULL);

       g_assert (result3 == NULL);

       g_error_free (error3);

     }

   else

     {

       g_assert_no_error (error);

       g_assert (items_read == ucs4_len);

       g_assert (items_written == utf8_len);

       g_assert (result);

       g_assert (strcmp (result, utf8) == 0);

       g_assert_no_error (error3);

       g_assert (result3);

       g_assert (strcmp (result3, utf8) == 0);

     }

   g_free (result);

   g_free (result3);

 }

 static void

 check_utf8_to_utf16 (const char      *utf8,

 		     glong            utf8_len,

 		     const gunichar2 *utf16,

 		     glong            utf16_len,

 		     glong            error_pos)

 {

   gunichar2 *result, *result2, *result3;

   glong items_read, items_read2;

   glong items_written, items_written2;

   GError *error, *error2, *error3;

   gint i;

   error = NULL;

   result = g_utf8_to_utf16 (utf8, utf8_len, &items_read, &items_written, &error);

   if (utf8_len == strlen (utf8))

     {

       /* check that len == -1 yields identical results */

       error2 = NULL;

       result2 = g_utf8_to_utf16 (utf8, -1, &items_read2, &items_written2, &error2);

       g_assert (error || items_read2 == items_read);

       g_assert (error || items_written2 == items_written2);

       g_assert (!!result == !!result2);

       g_assert (!!error == !!error2);

       if (result)

 	for (i = 0; i <= items_written; i++)

 	  g_assert (result[i] == result2[i]);

       g_free (result2);

       if (error2)

 	g_error_free (error2);

     }

   error3 = NULL;

   result3 = g_utf8_to_utf16 (utf8, utf8_len, NULL, NULL, &error3);

   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)

     {

       g_assert_no_error (error);

       g_assert (items_read == error_pos);

       g_assert (items_written == utf16_len);

       g_assert (result);

       for (i = 0; i <= items_written; i++)

 	g_assert (result[i] == utf16[i]);

     }

   else if (error_pos)

     {

       g_assert (error != NULL);

       g_assert (result == NULL);

       g_assert (items_read == error_pos);

       g_error_free (error);

       g_assert (error3 != NULL);

       g_assert (result3 == NULL);

       g_error_free (error3);

     }

   else

     {

       g_assert_no_error (error);

       g_assert (items_read == utf8_len);

       g_assert (items_written == utf16_len);

       g_assert (result);

       for (i = 0; i <= items_written; i++)

 	g_assert (result[i] == utf16[i]);

       g_assert_no_error (error3);

       g_assert (result3);

       for (i = 0; i <= utf16_len; i++)

 	g_assert (result3[i] == utf16[i]);

     }

   g_free (result);

   g_free (result3);

 }

 static void

 check_utf16_to_utf8 (const gunichar2 *utf16,

 		     glong            utf16_len,

 		     const char      *utf8,

 		     glong            utf8_len,

 		     glong            error_pos)

 {

   gchar *result, *result2, *result3;

   glong items_read, items_read2;

   glong items_written, items_written2;

   GError *error, *error2, *error3;

   error = NULL;

   result = g_utf16_to_utf8 (utf16, utf16_len, &items_read, &items_written, &error);

   if (utf16[utf16_len] == 0)

     {

       /* check that len == -1 yields identical results */

       error2 = NULL;

       result2 = g_utf16_to_utf8 (utf16, -1, &items_read2, &items_written2, &error2);

       g_assert (error || items_read2 == items_read);

       g_assert (error || items_written2 == items_written);

       g_assert (!!result == !!result2);

       g_assert (!!error == !!error2);

       if (result)

 	g_assert (strcmp (result, result2) == 0);

       g_free (result2);

       if (error2)

 	g_error_free (error2);

     }

   error3 = NULL;

   result3 = g_utf16_to_utf8 (utf16, utf16_len, NULL, NULL, &error3);

   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)

     {

       g_assert_no_error (error);

       g_assert (items_read == error_pos);

       g_assert (items_read + 1 == utf16_len);

       g_assert (items_written == utf8_len);

       g_assert (result);

       g_assert (strcmp (result, utf8) == 0);

     }

   else if (error_pos)

     {

       g_assert (error != NULL);

       g_assert (result == NULL);

       g_assert (items_read == error_pos);

       g_error_free (error);

       g_assert (error3 != NULL);

       g_assert (result3 == NULL);

       g_error_free (error3);

     }

   else

     {

       g_assert_no_error (error);

       g_assert (items_read == utf16_len);

       g_assert (items_written == utf8_len);

       g_assert (result);

       g_assert (strcmp (result, utf8) == 0);

       g_assert_no_error (error3);

       g_assert (result3);

       g_assert (strcmp (result3, utf8) == 0);

     }

   g_free (result);

   g_free (result3);

 }

 static void

 check_ucs4_to_utf16 (const gunichar  *ucs4,

 		     glong            ucs4_len,

 		     const gunichar2 *utf16,

 		     glong            utf16_len,

 		     glong            error_pos)

 {

   gunichar2 *result, *result2, *result3;

   glong items_read, items_read2;

   glong items_written, items_written2;

   GError *error, *error2, *error3;

   gint i;

   error = NULL;

   result = g_ucs4_to_utf16 (ucs4, ucs4_len, &items_read, &items_written, &error);

   if (ucs4[ucs4_len] == 0)

     {

       /* check that len == -1 yields identical results */

       error2 = NULL;

       result2 = g_ucs4_to_utf16 (ucs4, -1, &items_read2, &items_written2, &error2);

       g_assert (error || items_read2 == items_read);

       g_assert (error || items_written2 == items_written);

       g_assert (!!result == !!result2);

       g_assert (!!error == !!error2);

       if (result)

       for (i = 0; i <= utf16_len; i++)

 	g_assert (result[i] == result2[i]);

       g_free (result2);

       if (error2)

 	g_error_free (error2);

     }

   error3 = NULL;

   result3 = g_ucs4_to_utf16 (ucs4, -1, NULL, NULL, &error3);

   if (error_pos)

     {

       g_assert (error != NULL);

       g_assert (result == NULL);

       g_assert (items_read == error_pos);

       g_error_free (error);

       g_assert (error3 != NULL);

       g_assert (result3 == NULL);

       g_error_free (error3);

     }

   else

     {

       g_assert_no_error (error);

       g_assert (items_read == ucs4_len);

       g_assert (items_written == utf16_len);

       g_assert (result);

       for (i = 0; i <= utf16_len; i++)

 	g_assert (result[i] == utf16[i]);

       g_assert_no_error (error3);

       g_assert (result3);

       for (i = 0; i <= utf16_len; i++)

 	g_assert (result3[i] == utf16[i]);

     }

   g_free (result);

   g_free (result3);

 }

 static void

 check_utf16_to_ucs4 (const gunichar2 *utf16,

 		     glong            utf16_len,

 		     const gunichar  *ucs4,

 		     glong            ucs4_len,

 		     glong            error_pos)

 {

   gunichar *result, *result2, *result3;

   glong items_read, items_read2;

   glong items_written, items_written2;

   GError *error, *error2, *error3;

   gint i;

   error = NULL;

   result = g_utf16_to_ucs4 (utf16, utf16_len, &items_read, &items_written, &error);

   if (utf16[utf16_len] == 0)

     {

       /* check that len == -1 yields identical results */

       error2 = NULL;

       result2 = g_utf16_to_ucs4 (utf16, -1, &items_read2, &items_written2, &error2);

       g_assert (error || items_read2 == items_read);

       g_assert (error || items_written2 == items_written2);

       g_assert (!!result == !!result2);

       g_assert (!!error == !!error2);

       if (result)

 	for (i = 0; i <= items_written; i++)

 	  g_assert (result[i] == result2[i]);

       g_free (result2);

       if (error2)

 	g_error_free (error2);

     }

   error3 = NULL;

   result3 = g_utf16_to_ucs4 (utf16, utf16_len, NULL, NULL, &error3);

   if (error3 && error3->code == G_CONVERT_ERROR_PARTIAL_INPUT)

     {

       g_assert_no_error (error);

       g_assert (items_read == error_pos);

       g_assert (items_read + 1 == utf16_len);

       g_assert (items_written == ucs4_len);

       g_assert (result);

       for (i = 0; i <= items_written; i++)

 	g_assert (result[i] == ucs4[i]);

     }

   else if (error_pos)

     {

       g_assert (error != NULL);

       g_assert (result == NULL);

       g_assert (items_read == error_pos);

       g_error_free (error);

       g_assert (error3 != NULL);

       g_assert (result3 == NULL);

       g_error_free (error3);

     }

   else

     {

       g_assert_no_error (error);

       g_assert (items_read == utf16_len);

       g_assert (items_written == ucs4_len);

       g_assert (result);

       for (i = 0; i <= ucs4_len; i++)

 	g_assert (result[i] == ucs4[i]);

       g_assert_no_error (error3);

       g_assert (result3);

       for (i = 0; i <= ucs4_len; i++)

 	g_assert (result3[i] == ucs4[i]);

     }

   g_free (result);

   g_free (result3);

 }

 static void

 test_unicode_conversions (void)

 {

   char *utf8;

   gunichar ucs4[100];

   gunichar2 utf16[100];

   utf8 = "abc";

   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0x63; ucs4[3] = 0;

   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0x63; utf16[3] = 0;

   check_utf8_to_ucs4 (utf8, 3, ucs4, 3, 0);

   check_ucs4_to_utf8 (ucs4, 3, utf8, 3, 0);

   check_utf8_to_utf16 (utf8, 3, utf16, 3, 0);

   check_utf16_to_utf8 (utf16, 3, utf8, 3, 0);

   check_ucs4_to_utf16 (ucs4, 3, utf16, 3, 0);

   check_utf16_to_ucs4 (utf16, 3, ucs4, 3, 0);

   utf8 = "\316\261\316\262\316\263";

   ucs4[0] = 0x03b1; ucs4[1] = 0x03b2; ucs4[2] = 0x03b3; ucs4[3] = 0;

   utf16[0] = 0x03b1; utf16[1] = 0x03b2; utf16[2] = 0x03b3; utf16[3] = 0;

   check_utf8_to_ucs4 (utf8, 6, ucs4, 3, 0);

   check_ucs4_to_utf8 (ucs4, 3, utf8, 6, 0);

   check_utf8_to_utf16 (utf8, 6, utf16, 3, 0);

   check_utf16_to_utf8 (utf16, 3, utf8, 6, 0);

   check_ucs4_to_utf16 (ucs4, 3, utf16, 3, 0);

   check_utf16_to_ucs4 (utf16, 3, ucs4, 3, 0);

   /* partial utf8 character */

   utf8 = "abc\316";

   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0x63; ucs4[3] = 0;

   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0x63; utf16[3] = 0;

   check_utf8_to_ucs4 (utf8, 4, ucs4, 3, 3);

   check_utf8_to_utf16 (utf8, 4, utf16, 3, 3);

   /* invalid utf8 */

   utf8 = "abc\316\316";

   ucs4[0] = 0; 

   utf16[0] = 0; 

   check_utf8_to_ucs4 (utf8, 5, ucs4, 0, 3);

   check_utf8_to_utf16 (utf8, 5, utf16, 0, 3);

   /* partial utf16 character */

   utf8 = "ab";

   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0;

   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0xd801; utf16[3] = 0;

   check_utf16_to_utf8 (utf16, 3, utf8, 2, 2);

   check_utf16_to_ucs4 (utf16, 3, ucs4, 2, 2);

   /* invalid utf16 */

   utf8 = NULL;

   ucs4[0] = 0;

   utf16[0] = 0x61; utf16[1] = 0x62; utf16[2] = 0xdc01; utf16[3] = 0;

   check_utf16_to_utf8 (utf16, 3, utf8, 0, 2);

   check_utf16_to_ucs4 (utf16, 3, ucs4, 0, 2);

   /* invalid ucs4 */

   utf8 = NULL;

   ucs4[0] = 0x61; ucs4[1] = 0x62; ucs4[2] = 0x80000000; ucs4[3] = 0;

   utf16[0] = 0;

   check_ucs4_to_utf8 (ucs4, 3, utf8, 0, 2);

   check_ucs4_to_utf16 (ucs4, 3, utf16, 0, 2);

 }

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

   test_iconv_state ();

   test_one_half ();

   test_byte_order ();

   test_unicode_conversions ();

   #if __SYMBIAN32__

   testResultXml("convert-test");

   #endif /* EMULATOR */

   return 0;

 }