git.oblomov.eu Git - wine/blob - 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,
 343        "should not create NULL path ret %u err %u\n", ret, GetLastError());
 344
 345     ret = CreateDirectoryW(empty_strW, NULL);
 346     ok(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND,
 347        "should not create empty path ret %u err %u\n", ret, GetLastError());
 348
 349     ret = GetSystemDirectoryW(tmpdir, MAX_PATH);
 350     ok(ret < MAX_PATH, "System directory should fit into MAX_PATH\n");
 351
 352     ret = SetCurrentDirectoryW(tmpdir);
 353     ok(ret == TRUE, "could not chdir to the System directory ret %u err %u\n", ret, GetLastError());
 354
 355     ret = CreateDirectoryW(dotW, NULL);
 356     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
 357        "should not create existing path ret %u err %u\n", ret, GetLastError());
 358
 359     ret = CreateDirectoryW(dotdotW, NULL);
 360     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
 361        "should not create existing path ret %u err %u\n", ret, GetLastError());
 362
 363     GetTempPathW(MAX_PATH, tmpdir);
 364     tmpdir[3] = 0; /* truncate the path */
 365     ret = CreateDirectoryW(tmpdir, NULL);
 366     ok(ret == FALSE && (GetLastError() == ERROR_ACCESS_DENIED || GetLastError() == ERROR_ALREADY_EXISTS),
 367        "should deny access to the drive root ret %u err %u\n", ret, GetLastError());
 368
 369     GetTempPathW(MAX_PATH, tmpdir);
 370     lstrcatW(tmpdir, tmp_dir_name);
 371     ret = CreateDirectoryW(tmpdir, NULL);
 372     ok(ret == TRUE, "CreateDirectoryW should always succeed\n");
 373
 374     ret = CreateDirectoryW(tmpdir, NULL);
 375     ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
 376        "should not create existing path ret %u err %u\n", ret, GetLastError());
 377
 378     ret = RemoveDirectoryW(tmpdir);
 379     ok(ret == TRUE, "RemoveDirectoryW should always succeed\n");
 380
 381     lstrcatW(tmpdir, questionW);
 382     ret = CreateDirectoryW(tmpdir, NULL);
 383     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
 384        "CreateDirectoryW with ? wildcard name should fail with error 183, ret=%s error=%d\n",
 385        ret ? " True" : "False", GetLastError());
 386     ret = RemoveDirectoryW(tmpdir);
 387
 388     tmpdir[lstrlenW(tmpdir) - 1] = '*';
 389     ret = CreateDirectoryW(tmpdir, NULL);
 390     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
 391        "CreateDirectoryW with * wildcard name should fail with error 183, ret=%s error=%d\n",
 392        ret ? " True" : "False", GetLastError());
 393     ret = RemoveDirectoryW(tmpdir);
 394
 395     GetTempPathW(MAX_PATH, tmpdir);
 396     lstrcatW(tmpdir, tmp_dir_name);
 397     lstrcatW(tmpdir, slashW);
 398     lstrcatW(tmpdir, tmp_dir_name);
 399     ret = CreateDirectoryW(tmpdir, NULL);
 400     ok(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND,
 401       "CreateDirectoryW with multiple nonexistent directories in path should fail ret %u err %u\n",
 402        ret, GetLastError());
 403     ret = RemoveDirectoryW(tmpdir);
 404 }
 405
 406 static void test_RemoveDirectoryA(void)
 407 {
 408     char tmpdir[MAX_PATH];
 409     BOOL ret;
 410
 411     GetTempPathA(MAX_PATH, tmpdir);
 412     lstrcatA(tmpdir, "Please Remove Me");
 413     ret = CreateDirectoryA(tmpdir, NULL);
 414     ok(ret == TRUE, "CreateDirectoryA should always succeed\n");
 415
 416     ret = RemoveDirectoryA(tmpdir);
 417     ok(ret == TRUE, "RemoveDirectoryA should always succeed\n");
 418
 419     lstrcatA(tmpdir, "?");
 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     tmpdir[lstrlenA(tmpdir) - 1] = '*';
 427     ret = RemoveDirectoryA(tmpdir);
 428     ok(ret == FALSE && (GetLastError() == ERROR_INVALID_NAME ||
 429                         GetLastError() == ERROR_PATH_NOT_FOUND),
 430        "RemoveDirectoryA with * wildcard name should fail, ret=%s error=%d\n",
 431        ret ? " True" : "False", GetLastError());
 432 }
 433
 434 static void test_RemoveDirectoryW(void)
 435 {
 436     WCHAR tmpdir[MAX_PATH];
 437     BOOL ret;
 438     static const WCHAR tmp_dir_name[] = {'P','l','e','a','s','e',' ','R','e','m','o','v','e',' ','M','e',0};
 439     static const WCHAR questionW[] = {'?',0};
 440
 441     GetTempPathW(MAX_PATH, tmpdir);
 442     lstrcatW(tmpdir, tmp_dir_name);
 443     ret = CreateDirectoryW(tmpdir, NULL);
 444     if (!ret && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 445       return;
 446
 447     ok(ret == TRUE, "CreateDirectoryW should always succeed\n");
 448
 449     ret = RemoveDirectoryW(tmpdir);
 450     ok(ret == TRUE, "RemoveDirectoryW should always succeed\n");
 451
 452     lstrcatW(tmpdir, questionW);
 453     ret = RemoveDirectoryW(tmpdir);
 454     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
 455        "RemoveDirectoryW with wildcard should fail with error 183, ret=%s error=%d\n",
 456        ret ? " True" : "False", GetLastError());
 457
 458     tmpdir[lstrlenW(tmpdir) - 1] = '*';
 459     ret = RemoveDirectoryW(tmpdir);
 460     ok(ret == FALSE && GetLastError() == ERROR_INVALID_NAME,
 461        "RemoveDirectoryW with * wildcard name should fail with error 183, ret=%s error=%d\n",
 462        ret ? " True" : "False", GetLastError());
 463 }
 464
 465 static void test_SetCurrentDirectoryA(void)
 466 {
 467     SetLastError(0);
 468     ok( !SetCurrentDirectoryA( "\\some_dummy_dir" ), "SetCurrentDirectoryA succeeded\n" );
 469     ok( GetLastError() == ERROR_FILE_NOT_FOUND, "wrong error %d\n", GetLastError() );
 470     ok( !SetCurrentDirectoryA( "\\some_dummy\\subdir" ), "SetCurrentDirectoryA succeeded\n" );
 471     ok( GetLastError() == ERROR_PATH_NOT_FOUND, "wrong error %d\n", GetLastError() );
 472 }
 473
 474 START_TEST(directory)
 475 {
 476     test_GetWindowsDirectoryA();
 477     test_GetWindowsDirectoryW();
 478
 479     test_GetSystemDirectoryA();
 480     test_GetSystemDirectoryW();
 481
 482     test_CreateDirectoryA();
 483     test_CreateDirectoryW();
 484
 485     test_RemoveDirectoryA();
 486     test_RemoveDirectoryW();
 487
 488     test_SetCurrentDirectoryA();
 489 }