Test "" and NULL argument handling.
[kopensolaris-gnu/glibc.git] / stdlib / test-canon.c
1 /* Test program for returning the canonical absolute name of a given file.
2    Copyright (C) 1996, 1997 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by David Mosberger <davidm@azstarnet.com>.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    License, or (at your option) any later version.
10
11    The GNU C Library 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.  See the GNU
14    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 /* This file must be run from within a directory called "stdlib".  */
22
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <sys/param.h>
30
31 static char     cwd[PATH_MAX];
32 static size_t   cwd_len;
33
34 struct {
35   const char *  name;
36   const char *  value;
37 } symlinks[] = {
38   {"SYMLINK_LOOP",      "SYMLINK_LOOP"},
39   {"SYMLINK_1",         "."},
40   {"SYMLINK_2",         "//////./../../etc"},
41   {"SYMLINK_3",         "SYMLINK_1"},
42   {"SYMLINK_4",         "SYMLINK_2"},
43   {"SYMLINK_5",         "doesNotExist"},
44 };
45
46 struct {
47   const char * in, * out, * resolved;
48   int error;
49 } tests[] = {
50   /*  0 */
51   {"/",                                 "/"},
52   {"/////////////////////////////////", "/"},
53   {"/.././.././.././..///",             "/"},
54   {"/etc",                              "/etc"},
55   {"/etc/../etc",                       "/etc"},
56   /*  5 */
57   {"/doesNotExist/../etc",              0, "/doesNotExist", ENOENT},
58   {"./././././././././.",               "."},
59   {"/etc/.//doesNotExist",              0, "/etc/doesNotExist", ENOENT},
60   {"./doesExist",                       "./doesExist"},
61   {"./doesExist/",                      "./doesExist"},
62   /* 10 */
63   {"./doesExist/../doesExist",          "./doesExist"},
64   {"foobar",                            0, "./foobar", ENOENT},
65   {".",                                 "."},
66   {"./foobar",                          0, "./foobar", ENOENT},
67   {"SYMLINK_LOOP",                      0, "./SYMLINK_LOOP", ELOOP},
68   /* 15 */
69   {"./SYMLINK_LOOP",                    0, "./SYMLINK_LOOP", ELOOP},
70   {"SYMLINK_1",                         "."},
71   {"SYMLINK_1/foobar",                  0, "./foobar", ENOENT},
72   {"SYMLINK_2",                         "/etc"},
73   {"SYMLINK_3",                         "."},
74   /* 20 */
75   {"SYMLINK_4",                         "/etc"},
76   {"../stdlib/SYMLINK_1",               "."},
77   {"../stdlib/SYMLINK_2",               "/etc"},
78   {"../stdlib/SYMLINK_3",               "."},
79   {"../stdlib/SYMLINK_4",               "/etc"},
80   /* 25 */
81   {"./SYMLINK_5",                       0, "./doesNotExist", ENOENT},
82   {"SYMLINK_5",                         0, "./doesNotExist", ENOENT},
83   {"SYMLINK_5/foobar",                  0, "./doesNotExist", ENOENT},
84   {"doesExist/../../stdlib/doesExist",  "./doesExist"},
85   {"doesExist/.././../stdlib/.",        "."}
86 };
87
88
89 int
90 check_path (const char * result, const char * expected)
91 {
92   int good;
93
94   if (!result)
95     return (expected == NULL);
96
97   if (!expected)
98     return 0;
99
100   if (expected[0] == '.' && (expected[1] == '/' || expected[1] == '\0'))
101     good = (strncmp (result, cwd, cwd_len) == 0
102             && strcmp (result + cwd_len, expected + 1) == 0);
103   else
104     good = (strcmp (expected, result) == 0);
105
106   return good;
107 }
108
109
110 int
111 main (int argc, char ** argv)
112 {
113   char * result;
114   int fd, i, errors = 0;
115   char buf[PATH_MAX];
116
117   getcwd (cwd, sizeof(buf));
118   cwd_len = strlen (cwd);
119
120   errno = 0;
121   if (realpath (NULL, buf) != NULL || errno != EINVAL)
122     {
123       printf ("%s: expected return value NULL and errno set to EINVAL"
124               " for realpath(NULL,...)\n", argv[0]);
125       ++errors;
126     }
127
128   errno = 0;
129   if (realpath ("/", NULL) != NULL || errno != EINVAL)
130     {
131       printf ("%s: expected return value NULL and errno set to EINVAL"
132               " for realpath(...,NULL)\n", argv[0]);
133       ++errors;
134     }
135
136   errno = 0;
137   if (realpath ("", buf) != NULL || errno != ENOENT)
138     {
139       printf ("%s: expected return value NULL and set errno to ENOENT",
140               " for realpath(\"\",...)\n", argv[0]);
141       ++errors;
142     }
143
144   for (i = 0; i < (int) (sizeof (symlinks) / sizeof (symlinks[0])); ++i)
145     symlink (symlinks[i].value, symlinks[i].name);
146
147   fd = open("doesExist", O_CREAT | O_EXCL, 0777);
148
149   for (i = 0; i < (int) (sizeof (tests) / sizeof (tests[0])); ++i)
150     {
151       buf[0] = '\0';
152       result = realpath (tests[i].in, buf);
153
154       if (!check_path (result, tests[i].out))
155         {
156           printf ("%s: flunked test %d (expected `%s', got `%s')\n",
157                   argv[0], i, tests[i].out ? tests[i].out : "NULL",
158                   result ? result : "NULL");
159           ++errors;
160           continue;
161         }
162
163       if (!check_path (buf, tests[i].out ? tests[i].out : tests[i].resolved))
164         {
165           printf ("%s: flunked test %d (expected resolved `%s', got `%s')\n",
166                   argv[0], i, tests[i].out ? tests[i].out : tests[i].resolved,
167                   buf);
168           ++errors;
169           continue;
170         }
171
172       if (!tests[i].out && errno != tests[i].error)
173         {
174           printf ("%s: flunked test %d (expected errno %d, got %d)\n",
175                   argv[0], i, tests[i].error, errno);
176           ++errors;
177           continue;
178         }
179     }
180
181   getcwd (buf, sizeof(buf));
182   if (strcmp (buf, cwd))
183     {
184       printf ("%s: current working directory changed from %s to %s\n",
185               argv[0], cwd, buf);
186       ++errors;
187     }
188
189   if (fd >= 0)
190     unlink("doesExist");
191
192   for (i = 0; i < (int) (sizeof (symlinks) / sizeof (symlinks[0])); ++i)
193     unlink (symlinks[i].name);
194
195   if (errors != 0)
196     {
197       printf ("%d errors.\n", errors);
198       exit (EXIT_FAILURE);
199     }
200
201   puts ("No errors.");
202   return EXIT_SUCCESS;
203 }