kernel32/tests: Add a couple of tests for write watches.
[wine] / dlls / kernel32 / tests / directory.c
1 /*
2  * Unit test suite for directory functions.
3  *
4  * Copyright 2002 Dmitry Timoshkov
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This 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  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22
23 #include "wine/test.h"
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27
28 /* If you change something in these tests, please do the same
29  * for GetSystemDirectory tests.
30  */
31 static void test_GetWindowsDirectoryA(void)
32 {
33     UINT len, len_with_null;
34     char buf[MAX_PATH];
35
36     len_with_null = GetWindowsDirectoryA(NULL, 0);
37     ok(len_with_null <= MAX_PATH, "should fit into MAX_PATH\n");
38
39     lstrcpyA(buf, "foo");
40     len_with_null = GetWindowsDirectoryA(buf, 1);
41     ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer\n");
42
43     lstrcpyA(buf, "foo");
44     len = GetWindowsDirectoryA(buf, len_with_null - 1);
45     ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer\n");
46     ok(len == len_with_null, "GetWindowsDirectoryW returned %d, expected %d\n",
47        len, len_with_null);
48
49     lstrcpyA(buf, "foo");
50     len = GetWindowsDirectoryA(buf, len_with_null);
51     ok(lstrcmpA(buf, "foo") != 0, "should touch the buffer\n");
52     ok(len == strlen(buf), "returned length should be equal to the length of string\n");
53     ok(len == len_with_null-1, "GetWindowsDirectoryA returned %d, expected %d\n",
54        len, len_with_null-1);
55 }
56
57 static void test_GetWindowsDirectoryW(void)
58 {
59     UINT len, len_with_null;
60     WCHAR buf[MAX_PATH];
61     static const WCHAR fooW[] = {'f','o','o',0};
62
63     len_with_null = GetWindowsDirectoryW(NULL, 0);
64     if (len_with_null==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
65         return;
66     ok(len_with_null <= MAX_PATH, "should fit into MAX_PATH\n");
67
68     lstrcpyW(buf, fooW);
69     len = GetWindowsDirectoryW(buf, 1);
70     ok(lstrcmpW(buf, fooW) == 0, "should not touch the buffer\n");
71     ok(len == len_with_null, "GetWindowsDirectoryW returned %d, expected %d\n",
72        len, len_with_null);
73
74     lstrcpyW(buf, fooW);
75     len = GetWindowsDirectoryW(buf, len_with_null - 1);
76     ok(lstrcmpW(buf, fooW) == 0, "should not touch the buffer\n");
77     ok(len == len_with_null, "GetWindowsDirectoryW returned %d, expected %d\n",
78        len, len_with_null);
79
80     lstrcpyW(buf, fooW);
81     len = GetWindowsDirectoryW(buf, len_with_null);
82     ok(lstrcmpW(buf, fooW) != 0, "should touch the buffer\n");
83     ok(len == lstrlenW(buf), "returned length should be equal to the length of string\n");
84     ok(len == len_with_null-1, "GetWindowsDirectoryW returned %d, expected %d\n",
85        len, len_with_null-1);
86 }
87
88
89 /* If you change something in these tests, please do the same
90  * for GetWindowsDirectory tests.
91  */
92 static void test_GetSystemDirectoryA(void)
93 {
94     UINT len, len_with_null;
95     char buf[MAX_PATH];
96
97     len_with_null = GetSystemDirectoryA(NULL, 0);
98     ok(len_with_null <= MAX_PATH, "should fit into MAX_PATH\n");
99
100     lstrcpyA(buf, "foo");
101     len = GetSystemDirectoryA(buf, 1);
102     ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer\n");
103     ok(len == len_with_null, "GetSystemDirectoryA returned %d, expected %d\n",
104        len, len_with_null);
105
106     lstrcpyA(buf, "foo");
107     len = GetSystemDirectoryA(buf, len_with_null - 1);
108     ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer\n");
109     ok(len == len_with_null, "GetSystemDirectoryA returned %d, expected %d\n",
110        len, len_with_null);
111
112     lstrcpyA(buf, "foo");
113     len = GetSystemDirectoryA(buf, len_with_null);
114     ok(lstrcmpA(buf, "foo") != 0, "should touch the buffer\n");
115     ok(len == strlen(buf), "returned length should be equal to the length of string\n");
116     ok(len == len_with_null-1, "GetSystemDirectoryW returned %d, expected %d\n",
117        len, len_with_null-1);
118 }
119
120 static void test_GetSystemDirectoryW(void)
121 {
122     UINT len, len_with_null;
123     WCHAR buf[MAX_PATH];
124     static const WCHAR fooW[] = {'f','o','o',0};
125
126     len_with_null = GetSystemDirectoryW(NULL, 0);
127     if (len_with_null==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
128         return;
129     ok(len_with_null <= MAX_PATH, "should fit into MAX_PATH\n");
130
131     lstrcpyW(buf, fooW);
132     len = GetSystemDirectoryW(buf, 1);
133     ok(lstrcmpW(buf, fooW) == 0, "should not touch the buffer\n");
134     ok(len == len_with_null, "GetSystemDirectoryW returned %d, expected %d\n",
135        len, len_with_null);
136
137     lstrcpyW(buf, fooW);
138     len = GetSystemDirectoryW(buf, len_with_null - 1);
139     ok(lstrcmpW(buf, fooW) == 0, "should not touch the buffer\n");
140     ok(len == len_with_null, "GetSystemDirectoryW returned %d, expected %d\n",
141        len, len_with_null);
142
143     lstrcpyW(buf, fooW);
144     len = GetSystemDirectoryW(buf, len_with_null);
145     ok(lstrcmpW(buf, fooW) != 0, "should touch the buffer\n");
146     ok(len == lstrlenW(buf), "returned length should be equal to the length of string\n");
147     ok(len == len_with_null-1, "GetSystemDirectoryW returned %d, expected %d\n",
148        len, len_with_null-1);
149 }
150
151 static void test_CreateDirectoryA(void)
152 {
153     char tmpdir[MAX_PATH];
154     BOOL ret;
155
156     ret = CreateDirectoryA(NULL, NULL);
157     ok(ret == FALSE && (GetLastError() == ERROR_PATH_NOT_FOUND ||
158                         GetLastError() == ERROR_INVALID_PARAMETER),
159        "CreateDirectoryA(NULL): ret=%d err=%d\n", ret, GetLastError());
160
161     ret = CreateDirectoryA("", NULL);
162     ok(ret == FALSE && (GetLastError() == ERROR_BAD_PATHNAME ||
163                         GetLastError() == ERROR_PATH_NOT_FOUND),
164        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
165
166     ret = GetSystemDirectoryA(tmpdir, MAX_PATH);
167     ok(ret < MAX_PATH, "System directory should fit into MAX_PATH\n");
168
169     ret = SetCurrentDirectoryA(tmpdir);
170     ok(ret == TRUE, "could not chdir to the System directory\n");
171
172     ret = CreateDirectoryA(".", NULL);
173     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
174        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
175
176
177     ret = CreateDirectoryA("..", NULL);
178     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
179        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
180
181     GetTempPathA(MAX_PATH, tmpdir);
182     tmpdir[3] = 0; /* truncate the path */
183     ret = CreateDirectoryA(tmpdir, NULL);
184     ok(ret == FALSE && (GetLastError() == ERROR_ALREADY_EXISTS ||
185                         GetLastError() == ERROR_ACCESS_DENIED),
186        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
187
188     GetTempPathA(MAX_PATH, tmpdir);
189     lstrcatA(tmpdir, "Please Remove Me");
190     ret = CreateDirectoryA(tmpdir, NULL);
191     ok(ret == TRUE,       "CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
192
193     ret = CreateDirectoryA(tmpdir, NULL);
194     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
195        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
196
197     ret = RemoveDirectoryA(tmpdir);
198     ok(ret == TRUE,
199        "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
200
201
202     lstrcatA(tmpdir, "?");
203     ret = CreateDirectoryA(tmpdir, NULL);
204     ok(ret == FALSE && (GetLastError() == ERROR_INVALID_NAME ||
205                         GetLastError() == ERROR_PATH_NOT_FOUND),
206        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
207     RemoveDirectoryA(tmpdir);
208
209     tmpdir[lstrlenA(tmpdir) - 1] = '*';
210     ret = CreateDirectoryA(tmpdir, NULL);
211     ok(ret == FALSE && (GetLastError() == ERROR_INVALID_NAME ||
212                         GetLastError() == ERROR_PATH_NOT_FOUND),
213        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
214     RemoveDirectoryA(tmpdir);
215
216     GetTempPathA(MAX_PATH, tmpdir);
217     lstrcatA(tmpdir, "Please Remove Me/Please Remove Me");
218     ret = CreateDirectoryA(tmpdir, NULL);
219     ok(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND, 
220        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
221     RemoveDirectoryA(tmpdir);
222
223     /* Test behavior with a trailing dot.
224      * The directory should be created without the dot.
225      */
226     GetTempPathA(MAX_PATH, tmpdir);
227     lstrcatA(tmpdir, "Please Remove Me.");
228     ret = CreateDirectoryA(tmpdir, NULL);
229     ok(ret == TRUE,
230        "CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
231
232     lstrcatA(tmpdir, "/Please Remove Me");
233     ret = CreateDirectoryA(tmpdir, NULL);
234     ok(ret == TRUE,
235        "CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
236     ret = RemoveDirectoryA(tmpdir);
237     ok(ret == TRUE,
238        "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
239
240     GetTempPathA(MAX_PATH, tmpdir);
241     lstrcatA(tmpdir, "Please Remove Me");
242     ret = RemoveDirectoryA(tmpdir);
243     ok(ret == TRUE,
244        "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
245
246     /* Test behavior with two trailing dots.
247      * The directory should be created without the trailing dots.
248      */
249     GetTempPathA(MAX_PATH, tmpdir);
250     lstrcatA(tmpdir, "Please Remove Me..");
251     ret = CreateDirectoryA(tmpdir, NULL);
252     ok(ret == TRUE,
253        "CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
254
255     lstrcatA(tmpdir, "/Please Remove Me");
256     ret = CreateDirectoryA(tmpdir, NULL);
257     ok(ret == TRUE || /* On Win98 */
258        (ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND), /* On NT! */
259        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
260     if (ret == TRUE)
261     {
262         ret = RemoveDirectoryA(tmpdir);
263         ok(ret == TRUE,
264            "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
265     }
266
267     GetTempPathA(MAX_PATH, tmpdir);
268     lstrcatA(tmpdir, "Please Remove Me");
269     ret = RemoveDirectoryA(tmpdir);
270     ok(ret == TRUE,
271        "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
272
273     /* Test behavior with a trailing space.
274      * The directory should be created without the trailing space.
275      */
276     GetTempPathA(MAX_PATH, tmpdir);
277     lstrcatA(tmpdir, "Please Remove Me ");
278     ret = CreateDirectoryA(tmpdir, NULL);
279     ok(ret == TRUE,
280        "CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
281
282     lstrcatA(tmpdir, "/Please Remove Me");
283     ret = CreateDirectoryA(tmpdir, NULL);
284     ok(ret == TRUE || /* On Win98 */
285        (ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND), /* On NT! */
286        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
287     if (ret == TRUE)
288     {
289         ret = RemoveDirectoryA(tmpdir);
290         ok(ret == TRUE,
291            "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
292     }
293
294     GetTempPathA(MAX_PATH, tmpdir);
295     lstrcatA(tmpdir, "Please Remove Me");
296     ret = RemoveDirectoryA(tmpdir);
297     ok(ret == TRUE,
298        "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
299
300     /* Test behavior with a trailing space.
301      * The directory should be created without the trailing spaces.
302      */
303     GetTempPathA(MAX_PATH, tmpdir);
304     lstrcatA(tmpdir, "Please Remove Me  ");
305     ret = CreateDirectoryA(tmpdir, NULL);
306     ok(ret == TRUE,
307        "CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
308
309     lstrcatA(tmpdir, "/Please Remove Me");
310     ret = CreateDirectoryA(tmpdir, NULL);
311     ok(ret == TRUE || /* On Win98 */
312        (ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND), /* On NT! */
313        "CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
314     if (ret == TRUE)
315     {
316         ret = RemoveDirectoryA(tmpdir);
317         ok(ret == TRUE,
318            "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
319     }
320
321     GetTempPathA(MAX_PATH, tmpdir);
322     lstrcatA(tmpdir, "Please Remove Me");
323     ret = RemoveDirectoryA(tmpdir);
324     ok(ret == TRUE,
325        "RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
326 }
327
328 static void test_CreateDirectoryW(void)
329 {
330     WCHAR tmpdir[MAX_PATH];
331     BOOL ret;
332     static const WCHAR empty_strW[] = { 0 };
333     static const WCHAR tmp_dir_name[] = {'P','l','e','a','s','e',' ','R','e','m','o','v','e',' ','M','e',0};
334     static const WCHAR dotW[] = {'.',0};
335     static const WCHAR slashW[] = {'/',0};
336     static const WCHAR dotdotW[] = {'.','.',0};
337     static const WCHAR questionW[] = {'?',0};
338
339     ret = CreateDirectoryW(NULL, NULL);
340     if (!ret && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
341         return;
342     ok(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND, "should not create NULL path\n");
343
344     ret = CreateDirectoryW(empty_strW, NULL);
345     ok(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND, "should not create empty path\n");
346
347     ret = GetSystemDirectoryW(tmpdir, MAX_PATH);
348     ok(ret < MAX_PATH, "System directory should fit into MAX_PATH\n");
349
350     ret = SetCurrentDirectoryW(tmpdir);
351     ok(ret == TRUE, "could not chdir to the System directory\n");
352
353     ret = CreateDirectoryW(dotW, NULL);
354     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS, "should not create existing path\n");
355
356     ret = CreateDirectoryW(dotdotW, NULL);
357     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS, "should not create existing path\n");
358
359     GetTempPathW(MAX_PATH, tmpdir);
360     tmpdir[3] = 0; /* truncate the path */
361     ret = CreateDirectoryW(tmpdir, NULL);
362     ok(ret == FALSE && GetLastError() == ERROR_ACCESS_DENIED, "should deny access to the drive root\n");
363
364     GetTempPathW(MAX_PATH, tmpdir);
365     lstrcatW(tmpdir, tmp_dir_name);
366     ret = CreateDirectoryW(tmpdir, NULL);
367     ok(ret == TRUE, "CreateDirectoryW should always succeed\n");
368
369     ret = CreateDirectoryW(tmpdir, NULL);
370     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS, "should not create existing path\n");
371
372     ret = RemoveDirectoryW(tmpdir);
373     ok(ret == TRUE, "RemoveDirectoryW should always succeed\n");
374
375     lstrcatW(tmpdir, questionW);
376     ret = CreateDirectoryW(tmpdir, NULL);
377     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
378        "CreateDirectoryW with ? wildcard name should fail with error 183, ret=%s error=%d\n",
379        ret ? " True" : "False", GetLastError());
380     ret = RemoveDirectoryW(tmpdir);
381
382     tmpdir[lstrlenW(tmpdir) - 1] = '*';
383     ret = CreateDirectoryW(tmpdir, NULL);
384     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
385        "CreateDirectoryW with * wildcard name should fail with error 183, ret=%s error=%d\n",
386        ret ? " True" : "False", GetLastError());
387     ret = RemoveDirectoryW(tmpdir);
388     
389     GetTempPathW(MAX_PATH, tmpdir);
390     lstrcatW(tmpdir, tmp_dir_name);
391     lstrcatW(tmpdir, slashW);
392     lstrcatW(tmpdir, tmp_dir_name);
393     ret = CreateDirectoryW(tmpdir, NULL);
394     ok(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND, 
395       "CreateDirectoryW with multiple nonexistent directories in path should fail\n");
396     ret = RemoveDirectoryW(tmpdir);
397 }
398
399 static void test_RemoveDirectoryA(void)
400 {
401     char tmpdir[MAX_PATH];
402     BOOL ret;
403
404     GetTempPathA(MAX_PATH, tmpdir);
405     lstrcatA(tmpdir, "Please Remove Me");
406     ret = CreateDirectoryA(tmpdir, NULL);
407     ok(ret == TRUE, "CreateDirectoryA should always succeed\n");
408
409     ret = RemoveDirectoryA(tmpdir);
410     ok(ret == TRUE, "RemoveDirectoryA should always succeed\n");
411
412     lstrcatA(tmpdir, "?");
413     ret = RemoveDirectoryA(tmpdir);
414     ok(ret == FALSE && (GetLastError() == ERROR_INVALID_NAME ||
415                         GetLastError() == ERROR_PATH_NOT_FOUND),
416        "RemoveDirectoryA with ? wildcard name should fail, ret=%s error=%d\n",
417        ret ? " True" : "False", GetLastError());
418
419     tmpdir[lstrlenA(tmpdir) - 1] = '*';
420     ret = RemoveDirectoryA(tmpdir);
421     ok(ret == FALSE && (GetLastError() == ERROR_INVALID_NAME ||
422                         GetLastError() == ERROR_PATH_NOT_FOUND),
423        "RemoveDirectoryA with * wildcard name should fail, ret=%s error=%d\n",
424        ret ? " True" : "False", GetLastError());
425 }
426
427 static void test_RemoveDirectoryW(void)
428 {
429     WCHAR tmpdir[MAX_PATH];
430     BOOL ret;
431     static const WCHAR tmp_dir_name[] = {'P','l','e','a','s','e',' ','R','e','m','o','v','e',' ','M','e',0};
432     static const WCHAR questionW[] = {'?',0};
433
434     GetTempPathW(MAX_PATH, tmpdir);
435     lstrcatW(tmpdir, tmp_dir_name);
436     ret = CreateDirectoryW(tmpdir, NULL);
437     if (!ret && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
438       return;
439
440     ok(ret == TRUE, "CreateDirectoryW should always succeed\n");
441
442     ret = RemoveDirectoryW(tmpdir);
443     ok(ret == TRUE, "RemoveDirectoryW should always succeed\n");
444
445     lstrcatW(tmpdir, questionW);
446     ret = RemoveDirectoryW(tmpdir);
447     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
448        "RemoveDirectoryW with wildcard should fail with error 183, ret=%s error=%d\n",
449        ret ? " True" : "False", GetLastError());
450
451     tmpdir[lstrlenW(tmpdir) - 1] = '*';
452     ret = RemoveDirectoryW(tmpdir);
453     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
454        "RemoveDirectoryW with * wildcard name should fail with error 183, ret=%s error=%d\n",
455        ret ? " True" : "False", GetLastError());
456 }
457
458 static void test_SetCurrentDirectoryA(void)
459 {
460     SetLastError(0);
461     ok( !SetCurrentDirectoryA( "\\some_dummy_dir" ), "SetCurrentDirectoryA succeeded\n" );
462     ok( GetLastError() == ERROR_FILE_NOT_FOUND, "wrong error %d\n", GetLastError() );
463     ok( !SetCurrentDirectoryA( "\\some_dummy\\subdir" ), "SetCurrentDirectoryA succeeded\n" );
464     ok( GetLastError() == ERROR_PATH_NOT_FOUND, "wrong error %d\n", GetLastError() );
465 }
466
467 START_TEST(directory)
468 {
469     test_GetWindowsDirectoryA();
470     test_GetWindowsDirectoryW();
471
472     test_GetSystemDirectoryA();
473     test_GetSystemDirectoryW();
474
475     test_CreateDirectoryA();
476     test_CreateDirectoryW();
477
478     test_RemoveDirectoryA();
479     test_RemoveDirectoryW();
480
481     test_SetCurrentDirectoryA();
482 }