LCOV - code coverage report
Current view: top level - gio/tests - g-file.c (source / functions) Coverage Total Hit
Test: unnamed Lines: 99.5 % 196 195
Test Date: 2024-11-26 05:23:01 Functions: 100.0 % 15 15
Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* GLib testing framework examples and tests
       2                 :             :  * Copyright (C) 2008 Red Hat, Inc.
       3                 :             :  * Authors: Tomas Bzatek <tbzatek@redhat.com>
       4                 :             :  *
       5                 :             :  * SPDX-License-Identifier: LicenseRef-old-glib-tests
       6                 :             :  *
       7                 :             :  * This work is provided "as is"; redistribution and modification
       8                 :             :  * in whole or in part, in any medium, physical or electronic is
       9                 :             :  * permitted without restriction.
      10                 :             :  *
      11                 :             :  * This work is distributed in the hope that it will be useful,
      12                 :             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
      14                 :             :  *
      15                 :             :  * In no event shall the authors or contributors be liable for any
      16                 :             :  * direct, indirect, incidental, special, exemplary, or consequential
      17                 :             :  * damages (including, but not limited to, procurement of substitute
      18                 :             :  * goods or services; loss of use, data, or profits; or business
      19                 :             :  * interruption) however caused and on any theory of liability, whether
      20                 :             :  * in contract, strict liability, or tort (including negligence or
      21                 :             :  * otherwise) arising in any way out of the use of this software, even
      22                 :             :  * if advised of the possibility of such damage.
      23                 :             :  */
      24                 :             : 
      25                 :             : #include <glib/glib.h>
      26                 :             : #include <gio/gio.h>
      27                 :             : #include <stdlib.h>
      28                 :             : #include <string.h>
      29                 :             : 
      30                 :             : struct TestPathsWithOper {
      31                 :             :   const char *path1;
      32                 :             :   gboolean equal;
      33                 :             :   gboolean use_uri;
      34                 :             :   const char *path2;
      35                 :             :   const char *path3;
      36                 :             : };
      37                 :             : 
      38                 :             : 
      39                 :             : 
      40                 :             : /* TODO:
      41                 :             :  *   - test on Windows
      42                 :             :  * 
      43                 :             :  **/
      44                 :             : 
      45                 :             : static void
      46                 :           1 : test_g_file_new_null (void)
      47                 :             : {
      48                 :           1 :   const char *paths[] = {"/",
      49                 :             :                          "/tmp///",
      50                 :             :                          "/non-existent-file",
      51                 :             :                          "/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88",
      52                 :             :                          NULL
      53                 :             :   };
      54                 :           1 :   const char *uris[] = {"file:///",
      55                 :             :                         "file:///tmp///",
      56                 :             :                         "non-existent-uri:///some-dir/",
      57                 :             :                         "file:///UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88",
      58                 :             :                         NULL
      59                 :             :   };
      60                 :             :   
      61                 :           1 :   GFile *file = NULL;
      62                 :             :   
      63                 :           1 :   int i = 0;
      64                 :           5 :   while (paths[i])
      65                 :             :     {
      66                 :           4 :       file = g_file_new_for_path (paths[i++]);
      67                 :           4 :       g_assert (file != NULL);
      68                 :           4 :       g_object_unref (file);
      69                 :             :     }
      70                 :             :   
      71                 :           1 :   i = 0;
      72                 :           5 :   while (uris[i])
      73                 :             :     {
      74                 :           4 :       file = g_file_new_for_uri (uris[i++]);
      75                 :           4 :       g_assert (file != NULL);
      76                 :           4 :       g_object_unref(file);
      77                 :             :     }
      78                 :           1 : }
      79                 :             : 
      80                 :             : 
      81                 :             : 
      82                 :             : static gboolean
      83                 :          28 : compare_two_files (const gboolean use_uri, const char *path1, const char *path2)
      84                 :             : {
      85                 :          28 :   GFile *file1 = NULL;
      86                 :          28 :   GFile *file2 = NULL;
      87                 :             :   gboolean equal;
      88                 :             : 
      89                 :          28 :   if (use_uri)
      90                 :             :     {
      91                 :          13 :       file1 = g_file_new_for_uri (path1);
      92                 :          13 :       file2 = g_file_new_for_uri (path2);
      93                 :             :     }
      94                 :             :   else
      95                 :             :     {
      96                 :          15 :       file1 = g_file_new_for_path (path1);
      97                 :          15 :       file2 = g_file_new_for_path (path2);
      98                 :             :     }
      99                 :             : 
     100                 :          28 :   g_assert (file1 != NULL);
     101                 :          28 :   g_assert (file2 != NULL);
     102                 :             :   
     103                 :          28 :   equal = g_file_equal (file1, file2);
     104                 :             :   
     105                 :          28 :   g_object_unref (file1);
     106                 :          28 :   g_object_unref (file2);
     107                 :             :   
     108                 :          28 :   return equal;
     109                 :             : }
     110                 :             : 
     111                 :             : static void
     112                 :           1 : test_g_file_new_for_path (void)
     113                 :             : {
     114                 :           1 :   const struct TestPathsWithOper cmp_paths[] =
     115                 :             :     {
     116                 :             :       {"/", TRUE, 0, "/./", NULL },
     117                 :             :       {"//", TRUE, 0, "//", NULL },
     118                 :             :       {"//", TRUE, 0, "//./", NULL },
     119                 :             :       {"/", TRUE, 0, "/.//", NULL },
     120                 :             :       {"/", TRUE, 0, "/././", NULL },
     121                 :             :       {"/tmp", TRUE, 0, "/tmp/d/../", NULL },
     122                 :             :       {"/", TRUE, 0, "/somedir/../", NULL },
     123                 :             :       {"/", FALSE, 0, "/somedir/.../", NULL },
     124                 :             :       {"//tmp/dir1", TRUE, 0, "//tmp/dir1", NULL },
     125                 :             :       {"/tmp/dir1", TRUE, 0, "///tmp/dir1", NULL },
     126                 :             :       {"/tmp/dir1", TRUE, 0, "////tmp/dir1", NULL },
     127                 :             :       {"/tmp/dir1", TRUE, 0, "/tmp/./dir1", NULL },
     128                 :             :       {"/tmp/dir1", TRUE, 0, "/tmp//dir1", NULL },
     129                 :             :       {"/tmp/dir1", TRUE, 0, "/tmp///dir1///", NULL },
     130                 :             :       {"/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88", TRUE, 0, "/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88/", NULL }
     131                 :             :     };
     132                 :             : 
     133                 :             :   guint i;
     134                 :          16 :   for (i = 0; i < G_N_ELEMENTS (cmp_paths); i++)
     135                 :             :     {
     136                 :          15 :       gboolean equal = compare_two_files (FALSE, cmp_paths[i].path1, cmp_paths[i].path2);
     137                 :          15 :       g_assert_cmpint (equal, ==, cmp_paths[i].equal);
     138                 :             :     }
     139                 :           1 : }
     140                 :             : 
     141                 :             : 
     142                 :             : 
     143                 :             : static void
     144                 :           1 : test_g_file_new_for_uri (void)
     145                 :             : {
     146                 :           1 :   const struct TestPathsWithOper cmp_uris[] = {
     147                 :             :     {"file:///", TRUE, 0, "file:///./", NULL },
     148                 :             :     {"file:////", TRUE, 0, "file:////", NULL },
     149                 :             :     {"file:////", TRUE, 0, "file:////./", NULL },
     150                 :             :     {"file:///", TRUE, 0, "file:///.//", NULL },
     151                 :             :     {"file:///", TRUE, 0, "file:///././", NULL },
     152                 :             :     {"file:///tmp", TRUE, 0, "file:///tmp/d/../", NULL },
     153                 :             :     {"file:///", TRUE, 0, "file:///somedir/../", NULL },
     154                 :             :     {"file:///", FALSE, 0, "file:///somedir/.../", NULL },
     155                 :             :     {"file:////tmp/dir1", TRUE, 0, "file:////tmp/dir1", NULL },
     156                 :             :     {"file:///tmp/dir1", TRUE, 0, "file:///tmp/./dir1", NULL },
     157                 :             :     {"file:///tmp/dir1", TRUE, 0, "file:///tmp//dir1", NULL },
     158                 :             :     {"file:///tmp/dir1", TRUE, 0, "file:///tmp///dir1///", NULL },
     159                 :             :     {"file:///UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88", TRUE, 0, "file:///UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88/", NULL }
     160                 :             :   };
     161                 :             :   
     162                 :             :   guint i;
     163                 :          14 :   for (i = 0; i < G_N_ELEMENTS (cmp_uris); i++)
     164                 :             :     {
     165                 :          13 :       gboolean equal = compare_two_files (TRUE, cmp_uris[i].path1, cmp_uris[i].path2);
     166                 :          13 :       g_assert_cmpint (equal, ==, cmp_uris[i].equal);
     167                 :             :     }
     168                 :           1 : }
     169                 :             : 
     170                 :             : 
     171                 :             : 
     172                 :             : static gboolean
     173                 :           5 : dup_equals (const gboolean use_uri, const char *path)
     174                 :             : {
     175                 :           5 :   GFile *file1 = NULL;
     176                 :           5 :   GFile *file2 = NULL;
     177                 :             :   gboolean equal;
     178                 :             :   
     179                 :           5 :   if (use_uri) 
     180                 :           2 :     file1 = g_file_new_for_uri (path);
     181                 :             :   else
     182                 :           3 :     file1 = g_file_new_for_path (path);
     183                 :             :         
     184                 :           5 :   g_assert (file1 != NULL);
     185                 :             :   
     186                 :           5 :   file2 = g_file_dup (file1);
     187                 :             :   
     188                 :           5 :   g_assert (file2 != NULL);
     189                 :             :   
     190                 :           5 :   equal = g_file_equal (file1, file2);
     191                 :             :   
     192                 :           5 :   g_object_unref (file1);
     193                 :           5 :   g_object_unref (file2);
     194                 :             :         
     195                 :           5 :   return equal;
     196                 :             : }
     197                 :             : 
     198                 :             : static void
     199                 :           1 : test_g_file_dup (void)
     200                 :             : {
     201                 :           1 :   const struct TestPathsWithOper dup_paths[] =
     202                 :             :     {
     203                 :             :       {"/", 0, FALSE, "", NULL },
     204                 :             :       {"file:///", 0, TRUE, "", NULL },
     205                 :             :       {"totalnonsense", 0, FALSE, "", NULL },
     206                 :             :       {"/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88", 0, FALSE, "", NULL },
     207                 :             :       {"file:///UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88", 0, TRUE, "", NULL },
     208                 :             :     };
     209                 :             :   
     210                 :             :   guint i;
     211                 :           6 :   for (i = 0; i < G_N_ELEMENTS (dup_paths); i++)
     212                 :             :     {
     213                 :           5 :       gboolean equal = dup_equals (dup_paths[i].use_uri, dup_paths[i].path1);
     214                 :           5 :       g_assert (equal == TRUE);
     215                 :             :     }
     216                 :           1 : }
     217                 :             : 
     218                 :             : 
     219                 :             : 
     220                 :             : static gboolean
     221                 :           5 : parse_check_utf8 (const gboolean use_uri, const char *path, const char *result_parse_name)
     222                 :             : {
     223                 :           5 :   GFile *file1 = NULL;
     224                 :           5 :   GFile *file2 = NULL;
     225                 :             :   char *parsed_name;
     226                 :             :   gboolean is_utf8_valid;
     227                 :             :   gboolean equal;
     228                 :             :   
     229                 :           5 :   if (use_uri)
     230                 :           2 :     file1 = g_file_new_for_uri (path);
     231                 :             :   else
     232                 :           3 :     file1 = g_file_new_for_path (path);
     233                 :             :         
     234                 :           5 :   g_assert (file1 != NULL);
     235                 :             : 
     236                 :           5 :   parsed_name = g_file_get_parse_name (file1);
     237                 :             :   
     238                 :           5 :   g_assert (parsed_name != NULL);
     239                 :             :   
     240                 :             :   /* UTF-8 validation */
     241                 :           5 :   is_utf8_valid = g_utf8_validate (parsed_name, -1, NULL);
     242                 :           5 :   g_assert (is_utf8_valid == TRUE);
     243                 :             : 
     244                 :           5 :   if (result_parse_name)
     245                 :           3 :     g_assert_cmpstr (parsed_name, ==, result_parse_name);
     246                 :             :   
     247                 :           5 :   file2 = g_file_parse_name (parsed_name);
     248                 :             :   
     249                 :           5 :   g_assert (file2 != NULL);
     250                 :             : 
     251                 :           5 :   equal = g_file_equal (file1, file2);
     252                 :             :         
     253                 :           5 :   g_object_unref (file1);
     254                 :           5 :   g_object_unref (file2);
     255                 :             :   
     256                 :           5 :   g_free (parsed_name);
     257                 :             :   
     258                 :           5 :   return equal;
     259                 :             : }
     260                 :             : 
     261                 :             : static void
     262                 :           1 : test_g_file_get_parse_name_utf8 (void)
     263                 :             : {
     264                 :           1 :   const struct TestPathsWithOper strings[] =
     265                 :             :     {
     266                 :             :       {G_DIR_SEPARATOR_S, 0, FALSE, G_DIR_SEPARATOR_S, NULL },
     267                 :             :       {"file:///", 0, TRUE, G_DIR_SEPARATOR_S, NULL },
     268                 :             :       {"totalnonsense", 0, FALSE, NULL, NULL },
     269                 :             :       {"/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88", 0, FALSE, NULL, NULL  /* Depends on local file encoding */},
     270                 :             :       {"file:///invalid%08/UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88/", 0, TRUE, "file:///invalid%08/UTF-8%20p\xc5\x99\xc3\xadli\xc5\xa1%20\xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd%20k\xc5\xaf\xc5\x88", NULL },
     271                 :             :     };
     272                 :             : 
     273                 :             :   guint i;
     274                 :           6 :   for (i = 0; i < G_N_ELEMENTS (strings); i++)
     275                 :             :     {
     276                 :           5 :       gboolean equal = parse_check_utf8 (strings[i].use_uri, strings[i].path1, strings[i].path2);
     277                 :           5 :       g_assert (equal == TRUE);
     278                 :             :     }
     279                 :           1 : }
     280                 :             : 
     281                 :             : static char *
     282                 :           5 : resolve_arg (const gboolean is_uri_only, const char *arg)
     283                 :             : {
     284                 :           5 :   GFile *file1 = NULL;
     285                 :           5 :   char *uri = NULL;
     286                 :           5 :   char *path = NULL;
     287                 :           5 :   char *s = NULL;
     288                 :             :   
     289                 :           5 :   file1 = g_file_new_for_commandline_arg (arg);
     290                 :           5 :   g_assert (file1 != NULL);
     291                 :             :         
     292                 :             :   /*  Test if we get URI string */
     293                 :           5 :   uri = g_file_get_uri (file1);
     294                 :           5 :   g_assert_cmpstr (uri, !=, NULL);
     295                 :           5 :   g_printerr ("%s\n",uri);
     296                 :             :         
     297                 :             :   /*  Test if we get correct value of the local path */
     298                 :           5 :   path = g_file_get_path (file1);
     299                 :           5 :   if (is_uri_only) 
     300                 :           0 :     g_assert_cmpstr (path, ==, NULL);
     301                 :             :   else
     302                 :           5 :     g_assert (g_path_is_absolute (path) == TRUE);
     303                 :             : 
     304                 :             :   /*  Get the URI scheme and compare it with expected one */
     305                 :           5 :   s = g_file_get_uri_scheme (file1);
     306                 :             :         
     307                 :           5 :   g_object_unref (file1);
     308                 :           5 :   g_free (uri);
     309                 :           5 :   g_free (path);
     310                 :             :   
     311                 :           5 :   return s;
     312                 :             : }
     313                 :             : 
     314                 :             : static void
     315                 :           1 : test_g_file_new_for_commandline_arg (void)
     316                 :             : {
     317                 :             :   /*  TestPathsWithOper.use_uri represents IsURIOnly here */
     318                 :           1 :   const struct TestPathsWithOper arg_data[] =
     319                 :             :     {
     320                 :             :       {"./", 0, FALSE, "file", NULL },
     321                 :             :       {"../", 0, FALSE, "file", NULL },
     322                 :             :       {"/tmp", 0, FALSE, "file", NULL },
     323                 :             :       {"//UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88", 0, FALSE, "file", NULL },
     324                 :             :       {"file:///UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88/", 0, FALSE, "file", NULL },
     325                 :             : #if 0
     326                 :             :       {"http://www.gtk.org/", 0, TRUE, "http", NULL },
     327                 :             :       {"ftp://user:pass@ftp.gimp.org/", 0, TRUE, "ftp", NULL },
     328                 :             : #endif
     329                 :             :     };
     330                 :             :   GFile *file;
     331                 :             :   char *resolved;
     332                 :             :   char *cwd;
     333                 :             :   guint i;
     334                 :             :   
     335                 :           6 :   for (i = 0; i < G_N_ELEMENTS (arg_data); i++)
     336                 :             :     {
     337                 :           5 :       char *s = resolve_arg (arg_data[i].use_uri, arg_data[i].path1);
     338                 :           5 :       g_assert_cmpstr (s, ==, arg_data[i].path2);
     339                 :           5 :       g_free (s);
     340                 :             :     }
     341                 :             :   
     342                 :             :   /* Manual test for getting correct cwd */
     343                 :           1 :   file = g_file_new_for_commandline_arg ("./");
     344                 :           1 :   resolved = g_file_get_path (file);
     345                 :           1 :   cwd = g_get_current_dir ();
     346                 :           1 :   g_assert_cmpstr (resolved, ==, cwd);
     347                 :           1 :   g_object_unref (file);
     348                 :           1 :   g_free (resolved);
     349                 :           1 :   g_free (cwd);
     350                 :           1 : }
     351                 :             : 
     352                 :             : static char*
     353                 :          16 : get_relative_path (const gboolean use_uri, const gboolean should_have_prefix, const char *dir1, const char *dir2)
     354                 :             : {
     355                 :          16 :   GFile *file1 = NULL;
     356                 :          16 :   GFile *file2 = NULL;
     357                 :          16 :   GFile *file3 = NULL;
     358                 :          16 :   gboolean has_prefix = FALSE;
     359                 :          16 :   char *relative_path = NULL;
     360                 :             :   
     361                 :          16 :   if (use_uri)
     362                 :             :     {
     363                 :           8 :       file1 = g_file_new_for_uri (dir1);
     364                 :           8 :       file2 = g_file_new_for_uri (dir2);
     365                 :             :     }
     366                 :             :   else
     367                 :             :     {
     368                 :           8 :       file1 = g_file_new_for_path (dir1);
     369                 :           8 :       file2 = g_file_new_for_path (dir2);
     370                 :             :     }
     371                 :             :   
     372                 :          16 :   g_assert (file1 != NULL);
     373                 :          16 :   g_assert (file2 != NULL);
     374                 :             :   
     375                 :          16 :   has_prefix = g_file_has_prefix (file2, file1);
     376                 :          16 :   g_printerr ("%s %s\n", dir1, dir2);
     377                 :          16 :   g_assert (has_prefix == should_have_prefix);
     378                 :             : 
     379                 :          16 :   relative_path = g_file_get_relative_path (file1, file2);
     380                 :          16 :   if (should_have_prefix)
     381                 :             :     {
     382                 :          12 :       g_assert (relative_path != NULL);
     383                 :             :       
     384                 :          12 :       file3 = g_file_resolve_relative_path (file1, relative_path);
     385                 :          12 :       g_assert (g_file_equal (file2, file3) == TRUE);
     386                 :             :     }
     387                 :             :         
     388                 :          16 :   if (file1)
     389                 :          16 :     g_object_unref (file1);
     390                 :          16 :   if (file2)
     391                 :          16 :     g_object_unref (file2);
     392                 :          16 :   if (file3)
     393                 :          12 :     g_object_unref (file3);
     394                 :             : 
     395                 :          16 :   return relative_path;
     396                 :             : }
     397                 :             : 
     398                 :             : static void
     399                 :           1 : test_g_file_has_prefix (void)
     400                 :             : {
     401                 :             :   /*  TestPathsWithOper.equal represents here if the dir belongs to the directory structure  */
     402                 :           1 :   const struct TestPathsWithOper dirs[] =
     403                 :             :     {
     404                 :             :       /* path1            equal  uri     path2    path3  */
     405                 :             :       {"/dir1", TRUE, FALSE, "/dir1/dir2/dir3/", "dir2" G_DIR_SEPARATOR_S "dir3"},
     406                 :             :       {"/dir1/", TRUE, FALSE, "/dir1/dir2/dir3/", "dir2" G_DIR_SEPARATOR_S "dir3"},
     407                 :             :       {"/dir1", TRUE, FALSE, "/dir1/dir2/dir3", "dir2" G_DIR_SEPARATOR_S "dir3"},
     408                 :             :       {"/dir1/", TRUE, FALSE, "/dir1/dir2/dir3", "dir2" G_DIR_SEPARATOR_S "dir3"},
     409                 :             :       {"/tmp/", FALSE, FALSE, "/something/", NULL},
     410                 :             :       {"/dir1/dir2", FALSE, FALSE, "/dir1/", NULL},
     411                 :             :       {"//dir1/new", TRUE, FALSE, "//dir1/new/dir2/dir3", "dir2" G_DIR_SEPARATOR_S "dir3"},
     412                 :             :       {"/dir/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88", TRUE, FALSE, "/dir/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88/dir2", "dir2"},
     413                 :             :       {"file:///dir1", TRUE, TRUE, "file:///dir1/dir2/dir3/", "dir2" G_DIR_SEPARATOR_S "dir3"},
     414                 :             :       {"file:///dir1/", TRUE, TRUE, "file:///dir1/dir2/dir3/", "dir2" G_DIR_SEPARATOR_S "dir3"},
     415                 :             :       {"file:///dir1", TRUE, TRUE, "file:///dir1/dir2/dir3", "dir2" G_DIR_SEPARATOR_S "dir3"},
     416                 :             :       {"file:///dir1/", TRUE, TRUE, "file:///dir1/dir2/dir3", "dir2" G_DIR_SEPARATOR_S "dir3"},
     417                 :             :       {"file:///tmp/", FALSE, TRUE, "file:///something/", NULL},
     418                 :             :       {"file:///dir1/dir2", FALSE, TRUE, "file:///dir1/", NULL},
     419                 :             :       {"file:////dir1/new", TRUE, TRUE, "file:////dir1/new/dir2/dir3", "dir2" G_DIR_SEPARATOR_S "dir3"},
     420                 :             :       {"file:///dir/UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88", TRUE, TRUE, "file:///dir/UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88/dir2", "dir2"},
     421                 :             : #if 0
     422                 :             :       {"dav://www.gtk.org/plan/", TRUE, TRUE, "dav://www.gtk.org/plan/meetings/20071218.txt", "meetings/20071218.txt"},
     423                 :             :       {"dav://www.gtk.org/plan/meetings", TRUE, TRUE, "dav://www.gtk.org/plan/meetings/20071218.txt", "20071218.txt"},
     424                 :             : #endif
     425                 :             :     };
     426                 :             :   
     427                 :             :   guint i;
     428                 :          17 :   for (i = 0; i < G_N_ELEMENTS (dirs); i++)
     429                 :             :     {
     430                 :          16 :       char *s = get_relative_path (dirs[i].use_uri, dirs[i].equal, dirs[i].path1, dirs[i].path2);
     431                 :          16 :       if (dirs[i].equal) 
     432                 :          12 :         g_assert_cmpstr (s, ==, dirs[i].path3);
     433                 :          16 :       g_free (s);
     434                 :             :     }
     435                 :           1 : }
     436                 :             : 
     437                 :             : static void
     438                 :           9 : roundtrip_parent_child (const gboolean use_uri, const gboolean under_root_descending,
     439                 :             :                         const char *path, const char *dir_holder)
     440                 :             : {
     441                 :           9 :   GFile *files[6] = {NULL};
     442                 :             :   guint i;
     443                 :             :   
     444                 :           9 :   if (use_uri)
     445                 :             :     {
     446                 :           5 :       files[0] = g_file_new_for_uri (path);
     447                 :           5 :       files[1] = g_file_new_for_uri (path);
     448                 :             :     }
     449                 :             :   else
     450                 :             :     {
     451                 :           4 :       files[0] = g_file_new_for_path (path);
     452                 :           4 :       files[1] = g_file_new_for_path (path);
     453                 :             :     }
     454                 :             : 
     455                 :           9 :   g_assert (files[0] != NULL);
     456                 :           9 :   g_assert (files[1] != NULL);
     457                 :             :   
     458                 :           9 :   files[2] = g_file_get_child (files[1], dir_holder); 
     459                 :           9 :   g_assert (files[2] != NULL);
     460                 :             :   
     461                 :           9 :   files[3] = g_file_get_parent (files[2]);
     462                 :           9 :   g_assert (files[3] != NULL);
     463                 :           9 :   g_assert (g_file_equal (files[3], files[0]) == TRUE);
     464                 :             :   
     465                 :           9 :   files[4] = g_file_get_parent (files[3]);
     466                 :             :   /*  Don't go lower beyond the root */
     467                 :           9 :   if (under_root_descending) 
     468                 :           2 :     g_assert (files[4] == NULL);
     469                 :             :   else
     470                 :             :     {
     471                 :           7 :       g_assert (files[4] != NULL);
     472                 :             :       
     473                 :           7 :       files[5] = g_file_get_child (files[4], dir_holder); 
     474                 :           7 :       g_assert (files[5] != NULL);
     475                 :           7 :       g_assert (g_file_equal (files[5], files[0]) == TRUE);
     476                 :             :     }
     477                 :             :   
     478                 :          63 :   for (i = 0; i < G_N_ELEMENTS (files); i++)
     479                 :             :     {
     480                 :          54 :       if (files[i])
     481                 :          50 :         g_object_unref (files[i]);
     482                 :             :     }
     483                 :           9 : }
     484                 :             : 
     485                 :             : static void
     486                 :           1 : test_g_file_get_parent_child (void)
     487                 :             : {
     488                 :           1 :   const struct TestPathsWithOper paths[] =
     489                 :             :     {
     490                 :             :       /* path     root_desc   uri  dir_holder */
     491                 :             :       {"/dir1/dir", FALSE, FALSE, "dir", NULL },
     492                 :             :       {"/dir", FALSE, FALSE, "dir", NULL },
     493                 :             :       {"/", TRUE, FALSE, "dir", NULL },
     494                 :             :       {"/UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88/", FALSE, FALSE, "UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88", NULL },
     495                 :             :       {"file:///dir1/dir", FALSE, TRUE, "dir", NULL },
     496                 :             :       {"file:///dir", FALSE, TRUE, "dir", NULL },
     497                 :             :       {"file:///", TRUE, TRUE, "dir", NULL },
     498                 :             :       {"file:///UTF-8%20p%C5%99%C3%ADli%C5%A1%20%C5%BElu%C5%A5ou%C4%8Dk%C3%BD%20k%C5%AF%C5%88/", FALSE, TRUE, "UTF-8 p\xc5\x99\xc3\xadli\xc5\xa1 \xc5\xbelu\xc5\xa5ou\xc4\x8dk\xc3\xbd k\xc5\xaf\xc5\x88", NULL },
     499                 :             :       {"dav://www.gtk.org/plan/meetings", FALSE, TRUE, "meetings", NULL },
     500                 :             :     };
     501                 :             : 
     502                 :             :   guint i;
     503                 :          10 :   for (i = 0; i < G_N_ELEMENTS (paths); i++)
     504                 :           9 :     roundtrip_parent_child (paths[i].use_uri, paths[i].equal, paths[i].path1, paths[i].path2);
     505                 :           1 : }
     506                 :             : 
     507                 :             : int
     508                 :           1 : main (int   argc,
     509                 :             :       char *argv[])
     510                 :             : {
     511                 :           1 :   g_test_init (&argc, &argv, NULL);
     512                 :             :   
     513                 :             :   
     514                 :             :   /*  Testing whether g_file_new_for_path() or g_file_new_for_uri() always returns non-NULL result  */
     515                 :           1 :   g_test_add_func ("/g-file/test_g_file_new_null", test_g_file_new_null);
     516                 :             :   
     517                 :             :   /*  Testing whether the g_file_new_for_path() correctly canonicalizes strings and two files equals (g_file_equal()) */
     518                 :           1 :   g_test_add_func ("/g-file/test_g_file_new_for_path", test_g_file_new_for_path);
     519                 :             : 
     520                 :             :   /*  Testing whether the g_file_new_for_uri() correctly canonicalizes strings and two files equals (g_file_equal()) */
     521                 :           1 :   g_test_add_func ("/g-file/test_g_file_new_for_uri", test_g_file_new_for_uri);
     522                 :             : 
     523                 :             :   /*  Testing g_file_dup() equals original file via g_file_equal()  */
     524                 :           1 :   g_test_add_func ("/g-file/test_g_file_dup", test_g_file_dup);
     525                 :             : 
     526                 :             :   /*  Testing g_file_get_parse_name() to return correct UTF-8 string    */
     527                 :           1 :   g_test_add_func ("/g-file/test_g_file_get_parse_name_utf8", test_g_file_get_parse_name_utf8);
     528                 :             :   
     529                 :             :   /*  Testing g_file_new_for_commandline_arg() for correct relavive path resolution and correct path/URI guess   */
     530                 :           1 :   g_test_add_func ("/g-file/test_g_file_new_for_commandline_arg", test_g_file_new_for_commandline_arg);
     531                 :             :   
     532                 :             :   /*  Testing g_file_has_prefix(), g_file_get_relative_path() and g_file_resolve_relative_path() to return and process correct relative paths         */
     533                 :           1 :   g_test_add_func ("/g-file/test_g_file_has_prefix", test_g_file_has_prefix);
     534                 :             :   
     535                 :             :   /*  Testing g_file_get_parent() and g_file_get_child()            */
     536                 :           1 :   g_test_add_func ("/g-file/test_g_file_get_parent_child", test_g_file_get_parent_child);
     537                 :             :   
     538                 :           1 :   return g_test_run();
     539                 :             : }
        

Generated by: LCOV version 2.0-1