Symaptic: os/ossrv/glib/tsrc/BC/tests/keyfile-test.c@bde4ae8d615e

     1 /* Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. */

     2 #include <glib.h>

     3 #include <locale.h>

     4 #include <string.h>

     5 #include <stdlib.h>

     6 #include <stdio.h>

     8 #ifdef SYMBIAN

     9 #include "mrt2_glib2_test.h"

    10 #endif /*SYMBIAN*/

    13 static GKeyFile *

    14 load_data (const gchar   *data,

    15 	   GKeyFileFlags  flags)

    16 {

    17   GKeyFile *keyfile;

    18   GError *error = NULL;

    20   keyfile = g_key_file_new ();

    21   g_key_file_load_from_data (keyfile, data, -1, flags, &error);

    22   if (error)

    23     {

    24       g_print ("Could not load data: %s\n", error->message);

    26       g_assert(FALSE && "keyfile-test failed");

    28       #ifdef SYMBIAN

    29   	  testResultXml("keyfile-test");

    30   	  #endif /* EMULATOR */

    32       exit (1);

    33     }

    35   return keyfile;

    36 }

    38 static void

    39 check_error (GError **error,

    40 	     GQuark   domain,

    41 	     gint     code)

    42 {

    43   if (*error == NULL)

    44     {

    45       g_print ("Missing an error\n");

    47       g_assert(FALSE && "keyfile-test failed");

    49       #ifdef SYMBIAN

    50   	  testResultXml("keyfile-test");

    51   	  #endif /* EMULATOR */

    53       exit (1);

    54     }

    56   if ((*error)->domain != domain)

    57     {

    58       g_print ("Wrong error domain: got %s, expected %s\n",

    59 	       g_quark_to_string ((*error)->domain),

    60 	       g_quark_to_string (domain));

    62       g_assert(FALSE && "keyfile-test failed");

    64       #ifdef SYMBIAN

    65   	  testResultXml("keyfile-test");

    66   	  #endif /* EMULATOR */

    68       exit (1);

    69     }

    71   if ((*error)->code != code)

    72     {

    73       g_print ("Wrong error code: got %d, expected %d\n",

    74 	       (*error)->code, code);

    76       g_assert(FALSE && "keyfile-test failed");

    78       #ifdef SYMBIAN

    79   	  testResultXml("keyfile-test");

    80   	  #endif /* EMULATOR */

    82       exit (1);

    83     }

    85   g_error_free (*error);

    86   *error = NULL;

    87 }

    89 static void

    90 check_no_error (GError **error)

    91 {

    92   if (*error != NULL)

    93     {

    94       g_print ("Unexpected error: (%s, %d) %s\n",

    95 	       g_quark_to_string ((*error)->domain),

    96 	       (*error)->code, (*error)->message);

    98       g_assert(FALSE && "keyfile-test failed");

   100       #ifdef SYMBIAN

   101   	  testResultXml("keyfile-test");

   102   	  #endif /* EMULATOR */

   104       exit (1);

   105     }

   106 }

   108 static void

   109 check_string_value (GKeyFile    *keyfile,

   110 		    const gchar *group,

   111 		    const gchar *key,

   112 		    const gchar *expected)

   113 {

   114   GError *error = NULL;

   115   gchar *value;

   117   value = g_key_file_get_string (keyfile, group, key, &error);

   118   check_no_error (&error);

   119   g_assert (value != NULL);

   121   if (strcmp (value, expected) != 0)

   122     {

   123       g_print ("Group %s key %s: "

   124 	       "expected string value '%s', actual value '%s'\n",

   125 	       group, key, expected, value);

   127       g_assert(FALSE && "keyfile-test failed");

   129       #ifdef SYMBIAN

   130   	  testResultXml("keyfile-test");

   131   	  #endif /* EMULATOR */

   133       exit (1);

   134     }

   136   g_free (value);

   137 }

   139 static void

   140 check_locale_string_value (GKeyFile    *keyfile,

   141 			   const gchar *group,

   142 			   const gchar *key,

   143 			   const gchar *locale,

   144 			   const gchar *expected)

   145 {

   146   GError *error = NULL;

   147   gchar *value;

   149   value = g_key_file_get_locale_string (keyfile, group, key, locale, &error);

   150   check_no_error (&error);

   151   g_assert (value != NULL);

   153   if (strcmp (value, expected) != 0)

   154     {

   155       g_print ("Group %s key %s locale %s: "

   156 	       "expected string value '%s', actual value '%s'\n",

   157 	       group, key, locale, expected, value);

   160       g_assert(FALSE && "keyfile-test failed");

   162       #ifdef SYMBIAN

   163   	  testResultXml("keyfile-test");

   164   	  #endif /* EMULATOR */

   166       exit (1);

   167     }

   169   g_free (value);

   170 }

   172 static void

   173 check_string_list_value (GKeyFile    *keyfile,

   174 			 const gchar *group,

   175 			 const gchar *key,

   176 			 ...)

   177 {

   178   gint i;

   179   gchar *v, **value;

   180   va_list args;

   181   gsize len;

   182   GError *error = NULL;

   184   value = g_key_file_get_string_list (keyfile, group, key, &len, &error);

   185   check_no_error (&error);

   186   g_assert (value != NULL);

   188   va_start (args, key);

   189   i = 0;

   190   v = va_arg (args, gchar*);

   191   while (v)

   192     {

   193       if (value[i] == NULL)

   194 	{

   195 	  g_print ("Group %s key %s: list too short (%d)\n",

   196 		   group, key, i);

   198       g_assert(FALSE && "keyfile-test failed");

   200       #ifdef SYMBIAN

   201   	  testResultXml("keyfile-test");

   202   	  #endif /* EMULATOR */

   204 	  exit (1);

   205 	}

   206       if (strcmp (v, value[i]) != 0)

   207 	{

   208 	  g_print ("Group %s key %s: mismatch at %d, expected %s, got %s\n",

   209 		   group, key, i, v, value[i]);

   212       g_assert(FALSE && "keyfile-test failed");

   214       #ifdef SYMBIAN

   215   	  testResultXml("keyfile-test");

   216   	  #endif /* EMULATOR */

   218 	  exit (1);

   219 	}

   221       i++;

   222       v = va_arg (args, gchar*);

   223     }

   225   va_end (args);

   227   g_strfreev (value);

   228 }

   230 static void

   231 check_integer_list_value (GKeyFile    *keyfile,

   232 			  const gchar *group,

   233 			  const gchar *key,

   234 			  ...)

   235 {

   236   gint i;

   237   gint v, *value;

   238   va_list args;

   239   gsize len;

   240   GError *error = NULL;

   242   value = g_key_file_get_integer_list (keyfile, group, key, &len, &error);

   243   check_no_error (&error);

   244   g_assert (value != NULL);

   246   va_start (args, key);

   247   i = 0;

   248   v = va_arg (args, gint);

   249   while (v != -100)

   250     {

   251       if (i == len)

   252 	{

   253 	  g_print ("Group %s key %s: list too short (%d)\n",

   254 		   group, key, i);

   256       g_assert(FALSE && "keyfile-test failed");

   258       #ifdef SYMBIAN

   259   	  testResultXml("keyfile-test");

   260   	  #endif /* EMULATOR */

   262 	  exit (1);

   263 	}

   264       if (value[i] != v)

   265 	{

   266 	  g_print ("Group %s key %s: mismatch at %d, expected %d, got %d\n",

   267 		   group, key, i, v, value[i]);

   269       g_assert(FALSE && "keyfile-test failed");

   271       #ifdef SYMBIAN

   272   	  testResultXml("keyfile-test");

   273   	  #endif /* EMULATOR */

   275 	  exit (1);

   276 	}

   278       i++;

   279       v = va_arg (args, gint);

   280     }

   282   va_end (args);

   284   g_free (value);

   285 }

   287 static void

   288 check_boolean_list_value (GKeyFile    *keyfile,

   289 			  const gchar *group,

   290 			  const gchar *key,

   291 			  ...)

   292 {

   293   gint i;

   294   gboolean v, *value;

   295   va_list args;

   296   gsize len;

   297   GError *error = NULL;

   299   value = g_key_file_get_boolean_list (keyfile, group, key, &len, &error);

   300   check_no_error (&error);

   301   g_assert (value != NULL);

   303   va_start (args, key);

   304   i = 0;

   305   v = va_arg (args, gboolean);

   306   while (v != -100)

   307     {

   308       if (i == len)

   309 	{

   310 	  g_print ("Group %s key %s: list too short (%d)\n",

   311 		   group, key, i);

   313       g_assert(FALSE && "keyfile-test failed");

   315       #ifdef SYMBIAN

   316   	  testResultXml("keyfile-test");

   317   	  #endif /* EMULATOR */

   319 	  exit (1);

   320 	}

   321       if (value[i] != v)

   322 	{

   323 	  g_print ("Group %s key %s: mismatch at %d, expected %d, got %d\n",

   324 		   group, key, i, v, value[i]);

   326       g_assert(FALSE && "keyfile-test failed");

   328       #ifdef SYMBIAN

   329   	  testResultXml("keyfile-test");

   330   	  #endif /* EMULATOR */

   332 	  exit (1);

   333 	}

   335       i++;

   336       v = va_arg (args, gboolean);

   337     }

   339   va_end (args);

   341   g_free (value);

   342 }

   344 static void

   345 check_boolean_value (GKeyFile    *keyfile,

   346 		     const gchar *group,

   347 		     const gchar *key,

   348 		     gboolean     expected)

   349 {

   350   GError *error = NULL;

   351   gboolean value;

   353   value = g_key_file_get_boolean (keyfile, group, key, &error);

   354   check_no_error (&error);

   356   if (value != expected)

   357     {

   358       g_print ("Group %s key %s: "

   359 	       "expected boolean value '%s', actual value '%s'\n",

   360 	       group, key,

   361 	       expected ? "true" : "false",

   362 	       value ? "true" : "false");

   364       g_assert(FALSE && "keyfile-test failed");

   366       #ifdef SYMBIAN

   367   	  testResultXml("keyfile-test");

   368   	  #endif /* EMULATOR */

   370       exit (1);

   371     }

   372 }

   374 static void

   375 check_integer_value (GKeyFile    *keyfile,

   376 		     const gchar *group,

   377 		     const gchar *key,

   378 		     gint         expected)

   379 {

   380   GError *error = NULL;

   381   gint value;

   383   value = g_key_file_get_integer (keyfile, group, key, &error);

   384   check_no_error (&error);

   386   if (value != expected)

   387     {

   388       g_print ("Group %s key %s: "

   389 	       "expected integer value %d, actual value %d\n",

   390 	       group, key, expected, value);

   392       g_assert(FALSE && "keyfile-test failed");

   394       #ifdef SYMBIAN

   395   	  testResultXml("keyfile-test");

   396   	  #endif /* EMULATOR */

   398       exit (1);

   399     }

   400 }

   402 static void

   403 check_name (const gchar *what,

   404 	    const gchar *value,

   405 	    const gchar *expected,

   406 	    gint         position)

   407 {

   408   if (!value || strcmp (expected, value) != 0)

   409     {

   410       g_print ("Wrong %s returned: got '%s' at %d, expected '%s'\n",

   411 	       what, value, position, expected);

   413       g_assert(FALSE && "keyfile-test failed");

   415       #ifdef SYMBIAN

   416   	  testResultXml("keyfile-test");

   417   	  #endif /* EMULATOR */

   419       exit (1);

   420     }

   421 }

   423 static void

   424 check_length (const gchar *what,

   425 	      gint         n_items,

   426 	      gint         length,

   427 	      gint         expected)

   428 {

   429   if (n_items != length || length != expected)

   430     {

   431       g_print ("Wrong number of %s returned: got %d items, length %d, expected %d\n",

   432 	       what, n_items, length, expected);

   434       g_assert(FALSE && "keyfile-test failed");

   436       #ifdef SYMBIAN

   437   	  testResultXml("keyfile-test");

   438   	  #endif /* EMULATOR */

   440       exit (1);

   441     }

   442 }

   445 /* check that both \n and \r\n are accepted as line ends,

   446  * and that stray \r are passed through

   447  */

   448 static void

   449 test_line_ends (void)

   450 {

   451   GKeyFile *keyfile;

   453   const gchar *data =

   454     "[group1]\n"

   455     "key1=value1\n"

   456     "key2=value2\r\n"

   457     "[group2]\r\n"

   458     "key3=value3\r\r\n"

   459     "key4=value4\n";

   461   keyfile = load_data (data, 0);

   463   check_string_value (keyfile, "group1", "key1", "value1");

   464   check_string_value (keyfile, "group1", "key2", "value2");

   465   check_string_value (keyfile, "group2", "key3", "value3\r");

   466   check_string_value (keyfile, "group2", "key4", "value4");

   468   g_key_file_free (keyfile);

   469 }

   471 /* check handling of whitespace

   472  */

   473 static void

   474 test_whitespace (void)

   475 {

   476   GKeyFile *keyfile;

   478   const gchar *data =

   479     "[group1]\n"

   480     "key1 = value1\n"

   481     "key2\t=\tvalue2\n"

   482     " [ group2 ] \n"

   483     "key3  =  value3  \n"

   484     "key4  =  value \t4\n"

   485     "  key5  =  value5\n";

   487   keyfile = load_data (data, 0);

   489   check_string_value (keyfile, "group1", "key1", "value1");

   490   check_string_value (keyfile, "group1", "key2", "value2");

   491   check_string_value (keyfile, " group2 ", "key3", "value3  ");

   492   check_string_value (keyfile, " group2 ", "key4", "value \t4");

   493   check_string_value (keyfile, " group2 ", "key5", "value5");

   495   g_key_file_free (keyfile);

   496 }

   498 /* check handling of comments

   499  */

   500 static void

   501 test_comments (void)

   502 {

   503   GKeyFile *keyfile;

   504   gchar **names;

   505   gsize len;

   506   GError *error = NULL;

   507   gchar *comment;

   509   const gchar *data =

   510     "# top comment\n"

   511     "# top comment, continued\n"

   512     "[group1]\n"

   513     "key1 = value1\n"

   514     "# key comment\n"

   515     "# key comment, continued\n"

   516     "key2 = value2\n"

   517     "# line end check\r\n"

   518     "key3 = value3\n"

   519     "key4 = value4\n"

   520     "# group comment\n"

   521     "# group comment, continued\n"

   522     "[group2]\n";

   524   const gchar *top_comment= " top comment\n top comment, continued\n";

   525   const gchar *group_comment= " group comment\n group comment, continued\n";

   526   const gchar *key_comment= " key comment\n key comment, continued\n";

   528   keyfile = load_data (data, 0);

   530   check_string_value (keyfile, "group1", "key1", "value1");

   531   check_string_value (keyfile, "group1", "key2", "value2");

   532   check_string_value (keyfile, "group1", "key3", "value3");

   533   check_string_value (keyfile, "group1", "key4", "value4");

   535   names = g_key_file_get_keys (keyfile, "group1", &len, &error);

   536   check_no_error (&error);

   538   check_length ("keys", g_strv_length (names), len, 4);

   539   check_name ("key", names[0], "key1", 0);

   540   check_name ("key", names[1], "key2", 1);

   541   check_name ("key", names[2], "key3", 2);

   542   check_name ("key", names[3], "key4", 3);

   544   g_strfreev (names);

   546   g_key_file_free (keyfile);

   548   keyfile = load_data (data, G_KEY_FILE_KEEP_COMMENTS);

   550   names = g_key_file_get_keys (keyfile, "group1", &len, &error);

   551   check_no_error (&error);

   553   check_length ("keys", g_strv_length (names), len, 4);

   554   check_name ("key", names[0], "key1", 0);

   555   check_name ("key", names[1], "key2", 1);

   556   check_name ("key", names[2], "key3", 2);

   557   check_name ("key", names[3], "key4", 3);

   559   g_strfreev (names);

   561   comment = g_key_file_get_comment (keyfile, NULL, NULL, &error);

   562   check_no_error (&error);

   563   check_name ("top comment", comment, top_comment, 0);

   564   g_free (comment);

   566   comment = g_key_file_get_comment (keyfile, "group1", "key2", &error);

   567   check_no_error (&error);

   568   check_name ("key comment", comment, key_comment, 0);

   569   g_free (comment);

   571   comment = g_key_file_get_comment (keyfile, "group2", NULL, &error);

   572   check_no_error (&error);

   573   check_name ("group comment", comment, group_comment, 0);

   574   g_free (comment);

   576   g_key_file_free (keyfile);

   577 }

   580 /* check key and group listing */

   581 static void

   582 test_listing (void)

   583 {

   584   GKeyFile *keyfile;

   585   gchar **names;

   586   gsize len;

   587   gchar *start;

   588   GError *error = NULL;

   590   const gchar *data =

   591     "[group1]\n"

   592     "key1=value1\n"

   593     "key2=value2\n"

   594     "[group2]\n"

   595     "key3=value3\n"

   596     "key4=value4\n";

   598   keyfile = load_data (data, 0);

   600   names = g_key_file_get_groups (keyfile, &len);

   601   if (names == NULL)

   602     {

   603       g_print ("Error listing groups\n");

   605       g_assert(FALSE && "keyfile-test failed");

   607       #ifdef SYMBIAN

   608   	  testResultXml("keyfile-test");

   609   	  #endif /* EMULATOR */

   611       exit (1);

   612     }

   614   check_length ("groups", g_strv_length (names), len, 2);

   615   check_name ("group name", names[0], "group1", 0);

   616   check_name ("group name", names[1], "group2", 1);

   618   g_strfreev (names);

   620   names = g_key_file_get_keys (keyfile, "group1", &len, &error);

   621   check_no_error (&error);

   623   check_length ("keys", g_strv_length (names), len, 2);

   624   check_name ("key", names[0], "key1", 0);

   625   check_name ("key", names[1], "key2", 1);

   627   g_strfreev (names);

   629   names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error);

   630   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);

   632   g_strfreev (names);

   634   if (!g_key_file_has_group (keyfile, "group1") ||

   635       !g_key_file_has_group (keyfile, "group2") ||

   636       g_key_file_has_group (keyfile, "group10") ||

   637       g_key_file_has_group (keyfile, "group2 "))

   638     {

   639       g_print ("Group finding trouble\n");

   642       g_assert(FALSE && "keyfile-test failed");

   644       #ifdef SYMBIAN

   645   	  testResultXml("keyfile-test");

   646   	  #endif /* EMULATOR */

   648       exit (1);

   649     }

   651   start = g_key_file_get_start_group (keyfile);

   652   if (!start || strcmp (start, "group1") != 0)

   653     {

   654       g_print ("Start group finding trouble\n");

   657       g_assert(FALSE && "keyfile-test failed");

   659       #ifdef SYMBIAN

   660   	  testResultXml("keyfile-test");

   661   	  #endif /* EMULATOR */

   663       exit (1);

   664     }

   665   g_free (start);

   667   if (!g_key_file_has_key (keyfile, "group1", "key1", &error) ||

   668       !g_key_file_has_key (keyfile, "group2", "key3", &error) ||

   669       g_key_file_has_key (keyfile, "group2", "no-such-key", &error))

   670     {

   671       g_print ("Key finding trouble\n");

   674       g_assert(FALSE && "keyfile-test failed");

   676       #ifdef SYMBIAN

   677   	  testResultXml("keyfile-test");

   678   	  #endif /* EMULATOR */

   681       exit (1);

   682     }

   683   check_no_error (&error);

   685   g_key_file_has_key (keyfile, "no-such-group", "key", &error);

   686   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);

   688   g_key_file_free (keyfile);

   689 }

   691 /* check parsing of string values */

   692 static void

   693 test_string (void)

   694 {

   695   GKeyFile *keyfile;

   696   GError *error = NULL;

   697   gchar *value;

   699   const gchar *data =

   700     "[valid]\n"

   701     "key1=\\s\\n\\t\\r\\\\\n"

   702     "key2=\"quoted\"\n"

   703     "key3='quoted'\n"

   704     "key4=\xe2\x89\xa0\xe2\x89\xa0\n"

   705     "[invalid]\n"

   706     "key1=\\a\\b\\0800xff\n"

   707     "key2=blabla\\\n";

   709   keyfile = load_data (data, 0);

   711   check_string_value (keyfile, "valid", "key1", " \n\t\r\\");

   712   check_string_value (keyfile, "valid", "key2", "\"quoted\"");

   713   check_string_value (keyfile, "valid", "key3", "'quoted'");

   714   check_string_value (keyfile, "valid", "key4", "\xe2\x89\xa0\xe2\x89\xa0");

   716   value = g_key_file_get_string (keyfile, "invalid", "key1", &error);

   717   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   718   g_free (value);

   720   value = g_key_file_get_string (keyfile, "invalid", "key2", &error);

   721   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   722   g_free (value);

   724   g_key_file_free (keyfile);

   725 }

   727 /* check parsing of boolean values */

   728 static void

   729 test_boolean (void)

   730 {

   731   GKeyFile *keyfile;

   732   GError *error = NULL;

   734   const gchar *data =

   735     "[valid]\n"

   736     "key1=true\n"

   737     "key2=false\n"

   738     "key3=1\n"

   739     "key4=0\n"

   740     "[invalid]\n"

   741     "key1=t\n"

   742     "key2=f\n"

   743     "key3=yes\n"

   744     "key4=no\n";

   746   keyfile = load_data (data, 0);

   748   check_boolean_value (keyfile, "valid", "key1", TRUE);

   749   check_boolean_value (keyfile, "valid", "key2", FALSE);

   750   check_boolean_value (keyfile, "valid", "key3", TRUE);

   751   check_boolean_value (keyfile, "valid", "key4", FALSE);

   753   g_key_file_get_boolean (keyfile, "invalid", "key1", &error);

   754   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   756   g_key_file_get_boolean (keyfile, "invalid", "key2", &error);

   757   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   759   g_key_file_get_boolean (keyfile, "invalid", "key3", &error);

   760   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   762   g_key_file_get_boolean (keyfile, "invalid", "key4", &error);

   763   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   765   g_key_file_free (keyfile);

   766 }

   768 /* check parsing of integer values */

   769 static void

   770 test_integer (void)

   771 {

   772   GKeyFile *keyfile;

   773   GError *error = NULL;

   775   const gchar *data =

   776     "[valid]\n"

   777     "key1=0\n"

   778     "key2=1\n"

   779     "key3=-1\n"

   780     "key4=2324431\n"

   781     "key5=-2324431\n"

   782     "key6=000111\n"

   783     "[invalid]\n"

   784     "key1=0xffff\n"

   785     "key2=0.5\n"

   786     "key3=1e37\n"

   787     "key4=ten\n";

   789   keyfile = load_data (data, 0);

   791   check_integer_value (keyfile, "valid", "key1", 0);

   792   check_integer_value (keyfile, "valid", "key2", 1);

   793   check_integer_value (keyfile, "valid", "key3", -1);

   794   check_integer_value (keyfile, "valid", "key4", 2324431);

   795   check_integer_value (keyfile, "valid", "key5", -2324431);

   796   check_integer_value (keyfile, "valid", "key6", 111);

   798   g_key_file_get_integer (keyfile, "invalid", "key1", &error);

   799   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   801   g_key_file_get_integer (keyfile, "invalid", "key2", &error);

   802   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   804   g_key_file_get_integer (keyfile, "invalid", "key3", &error);

   805   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   807   g_key_file_get_integer (keyfile, "invalid", "key4", &error);

   808   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);

   810   g_key_file_free (keyfile);

   811 }

   813 /* check handling of translated strings */

   814 static void

   815 test_locale_string (void)

   816 {

   817   GKeyFile *keyfile;

   818   GError *error = NULL;

   819   gchar *value;

   821   const gchar *data =

   822     "[valid]\n"

   823     "key1=v1\n"

   824     "key1[de]=v1-de\n"

   825     "key1[de_DE]=v1-de_DE\n"

   826     "key1[de_DE.UTF8]=v1-de_DE.UTF8\n"

   827     "key1[fr]=v1-fr\n"

   828     "key1[en] =v1-en\n"

   829     "key1[sr@Latn]=v1-sr\n";

   831   keyfile = load_data (data, G_KEY_FILE_KEEP_TRANSLATIONS);

   833   check_locale_string_value (keyfile, "valid", "key1", "it", "v1");

   834   check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");

   835   check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de_DE");

   836   check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de_DE.UTF8");

   837   check_locale_string_value (keyfile, "valid", "key1", "fr", "v1-fr");

   838   check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1-fr");

   839   check_locale_string_value (keyfile, "valid", "key1", "en", "v1-en");

   840   check_locale_string_value (keyfile, "valid", "key1", "sr@Latn", "v1-sr");

   842   g_key_file_free (keyfile);

   844   /* now test that translations are thrown away */

   846   g_setenv ("LANGUAGE", "de", TRUE);

   847   setlocale (LC_ALL, "");

   849   keyfile = load_data (data, 0);

   851   check_locale_string_value (keyfile, "valid", "key1", "it", "v1");

   852   check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");

   853   check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de");

   854   check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de");

   855   check_locale_string_value (keyfile, "valid", "key1", "fr", "v1");

   856   check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1");

   857   check_locale_string_value (keyfile, "valid", "key1", "en", "v1");

   859   g_key_file_free (keyfile);

   860 }

   862 static void

   863 test_lists (void)

   864 {

   865   GKeyFile *keyfile;

   867   const gchar *data =

   868     "[valid]\n"

   869     "key1=v1;v2\n"

   870     "key2=v1;v2;\n"

   871     "key3=v1,v2\n"

   872     "key4=v1\\;v2\n"

   873     "key5=true;false\n"

   874     "key6=1;0;-1\n"

   875     "key7= 1 ; 0 ; -1 \n"

   876     "key8=v1\\,v2\n";

   878   keyfile = load_data (data, 0);

   880   check_string_list_value (keyfile, "valid", "key1", "v1", "v2", NULL);

   881   check_string_list_value (keyfile, "valid", "key2", "v1", "v2", NULL);

   882   check_string_list_value (keyfile, "valid", "key3", "v1,v2", NULL);

   883   check_string_list_value (keyfile, "valid", "key4", "v1;v2", NULL);

   884   check_boolean_list_value (keyfile, "valid", "key5", TRUE, FALSE, -100);

   885   check_integer_list_value (keyfile, "valid", "key6", 1, 0, -1, -100);

   886   /* maybe these should be valid */

   887   /* check_integer_list_value (keyfile, "valid", "key7", 1, 0, -1, -100);*/

   888   /* check_string_list_value (keyfile, "valid", "key8", "v1\\,v2", NULL);*/

   890   g_key_file_free (keyfile);

   892   /* Now check an alternate separator */

   894   keyfile = load_data (data, 0);

   895   g_key_file_set_list_separator (keyfile, ',');

   897   check_string_list_value (keyfile, "valid", "key1", "v1;v2", NULL);

   898   check_string_list_value (keyfile, "valid", "key2", "v1;v2;", NULL);

   899   check_string_list_value (keyfile, "valid", "key3", "v1", "v2", NULL);

   901   g_key_file_free (keyfile);

   902 }

   904 /* http://bugzilla.gnome.org/show_bug.cgi?id=165887 */

   905 static void

   906 test_group_remove (void)

   907 {

   908   GKeyFile *keyfile;

   909   gchar **names;

   910   gsize len;

   911   GError *error = NULL;

   913   const gchar *data =

   914     "[group1]\n"

   915     "[group2]\n"

   916     "key1=bla\n"

   917     "key2=bla\n"

   918     "[group3]\n"

   919     "key1=bla\n"

   920     "key2=bla\n";

   922   keyfile = load_data (data, 0);

   924   names = g_key_file_get_groups (keyfile, &len);

   925   if (names == NULL)

   926     {

   927       g_print ("Error listing groups\n");

   929       g_assert(FALSE && "keyfile-test failed");

   931       #ifdef SYMBIAN

   932   	  testResultXml("keyfile-test");

   933   	  #endif /* EMULATOR */

   935       exit (1);

   936     }

   938   check_length ("groups", g_strv_length (names), len, 3);

   939   check_name ("group name", names[0], "group1", 0);

   940   check_name ("group name", names[1], "group2", 1);

   941   check_name ("group name", names[2], "group3", 2);

   943   g_key_file_remove_group (keyfile, "group1", &error);

   944   check_no_error (&error);

   946   g_strfreev (names);

   948   names = g_key_file_get_groups (keyfile, &len);

   949   if (names == NULL)

   950     {

   951       g_print ("Error listing groups\n");

   953       g_assert(FALSE && "keyfile-test failed");

   955       #ifdef SYMBIAN

   956   	  testResultXml("keyfile-test");

   957   	  #endif /* EMULATOR */

   959       exit (1);

   960     }

   962   check_length ("groups", g_strv_length (names), len, 2);

   963   check_name ("group name", names[0], "group2", 0);

   964   check_name ("group name", names[1], "group3", 1);

   966   g_key_file_remove_group (keyfile, "group2", &error);

   967   check_no_error (&error);

   969   g_strfreev (names);

   971   names = g_key_file_get_groups (keyfile, &len);

   972   if (names == NULL)

   973     {

   974       g_print ("Error listing groups\n");

   976       g_assert(FALSE && "keyfile-test failed");

   978       #ifdef SYMBIAN

   979   	  testResultXml("keyfile-test");

   980   	  #endif /* EMULATOR */

   982       exit (1);

   983     }

   985   check_length ("groups", g_strv_length (names), len, 1);

   986   check_name ("group name", names[0], "group3", 0);

   988   g_key_file_remove_group (keyfile, "no such group", &error);

   989   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);

   991   g_strfreev (names);

   993   g_key_file_free (keyfile);

   994 }

   996 /* http://bugzilla.gnome.org/show_bug.cgi?id=165980 */

   997 static void

   998 test_key_remove (void)

   999 {

  1000   GKeyFile *keyfile;

  1001   gchar *value;

  1002   GError *error = NULL;

  1004   const gchar *data =

  1005     "[group1]\n"

  1006     "key1=bla\n"

  1007     "key2=bla\n";

  1009   keyfile = load_data (data, 0);

  1011   check_string_value (keyfile, "group1", "key1", "bla");

  1013   g_key_file_remove_key (keyfile, "group1", "key1", &error);

  1014   check_no_error (&error);

  1016   value = g_key_file_get_string (keyfile, "group1", "key1", &error);

  1017   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);

  1018   g_free (value);

  1020   g_key_file_remove_key (keyfile, "group1", "key1", &error);

  1021   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);

  1023   g_key_file_remove_key (keyfile, "no such group", "key1", &error);

  1024   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);

  1026   g_key_file_free (keyfile);

  1027 }

  1029 /* http://bugzilla.gnome.org/show_bug.cgi?id=316309 */

  1030 static void

  1031 test_groups (void)

  1032 {

  1033   GKeyFile *keyfile;

  1035   const gchar *data =

  1036     "[1]\n"

  1037     "key1=123\n"

  1038     "[2]\n"

  1039     "key2=123\n";

  1041   keyfile = load_data (data, 0);

  1043   check_string_value (keyfile, "1", "key1", "123");

  1044   check_string_value (keyfile, "2", "key2", "123");

  1046   g_key_file_free (keyfile);

  1047 }

  1050 int

  1051 main (int argc, char *argv[])

  1052 {

  1053   #ifdef SYMBIAN

  1054   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);

  1055   g_set_print_handler(mrtPrintHandler);

  1056   #endif /*SYMBIAN*/

  1059   test_line_ends ();

  1060   test_whitespace ();

  1061   test_comments ();

  1062   test_listing ();

  1063   test_string ();

  1064   test_boolean ();

  1065   test_integer ();

  1066   test_locale_string ();

  1067   test_lists ();

  1068   test_group_remove ();

  1069   test_key_remove ();

  1070   test_groups ();

  1072   #ifdef SYMBIAN

  1073   testResultXml("keyfile-test");

  1074   #endif /* EMULATOR */

  1076   return 0;

  1077 }

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--