modules/rostests/winetests/ntdll/path.c

   1 /*
   2  * Unit test suite for ntdll path functions
   3  *
   4  * Copyright 2002 Alexandre Julliard
   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 "ntdll_test.h"
  22
  23 static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
  24                                                    LPCSTR src, DWORD srclen );
  25 static NTSTATUS (WINAPI *pRtlUnicodeToMultiByteN)(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
  26 static UINT (WINAPI *pRtlDetermineDosPathNameType_U)( PCWSTR path );
  27 static ULONG (WINAPI *pRtlIsDosDeviceName_U)( PCWSTR dos_name );
  28 static NTSTATUS (WINAPI *pRtlOemStringToUnicodeString)(UNICODE_STRING *, const STRING *, BOOLEAN );
  29 static BOOLEAN (WINAPI *pRtlIsNameLegalDOS8Dot3)(const UNICODE_STRING*,POEM_STRING,PBOOLEAN);
  30 static DWORD (WINAPI *pRtlGetFullPathName_U)(const WCHAR*,ULONG,WCHAR*,WCHAR**);
  31 static NTSTATUS (WINAPI *pRtlDosPathNameToNtPathName_U_WithStatus)(const WCHAR*, UNICODE_STRING*, WCHAR**, CURDIR*);
  32
  33 static void test_RtlDetermineDosPathNameType_U(void)
  34 {
  35     struct test
  36     {
  37         const char *path;
  38         UINT ret;
  39     };
  40
  41     static const struct test tests[] =
  42     {
  43         { "\\\\foo", 1 },
  44         { "//foo", 1 },
  45         { "\\/foo", 1 },
  46         { "/\\foo", 1 },
  47         { "\\\\", 1 },
  48         { "//", 1 },
  49         { "c:\\foo", 2 },
  50         { "c:/foo", 2 },
  51         { "c://foo", 2 },
  52         { "c:\\", 2 },
  53         { "c:/", 2 },
  54         { "c:foo", 3 },
  55         { "c:f\\oo", 3 },
  56         { "c:foo/bar", 3 },
  57         { "\\foo", 4 },
  58         { "/foo", 4 },
  59         { "\\", 4 },
  60         { "/", 4 },
  61         { "foo", 5 },
  62         { "", 5 },
  63         { "\0:foo", 5 },
  64         { "\\\\.\\foo", 6 },
  65         { "//./foo", 6 },
  66         { "/\\./foo", 6 },
  67         { "\\\\.foo", 1 },
  68         { "//.foo", 1 },
  69         { "\\\\.", 7 },
  70         { "//.", 7 },
  71         { NULL, 0 }
  72     };
  73
  74     const struct test *test;
  75     WCHAR buffer[MAX_PATH];
  76     UINT ret;
  77
  78     if (!pRtlDetermineDosPathNameType_U)
  79     {
  80         win_skip("RtlDetermineDosPathNameType_U is not available\n");
  81         return;
  82     }
  83
  84     for (test = tests; test->path; test++)
  85     {
  86         pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
  87         ret = pRtlDetermineDosPathNameType_U( buffer );
  88         ok( ret == test->ret, "Wrong result %d/%d for %s\n", ret, test->ret, test->path );
  89     }
  90 }
  91
  92
  93 static void test_RtlIsDosDeviceName_U(void)
  94 {
  95     struct test
  96     {
  97         const char *path;
  98         WORD pos;
  99         WORD len;
 100         BOOL fails;
 101     };
 102
 103     static const struct test tests[] =
 104     {
 105         { "\\\\.\\CON",    8, 6, TRUE },  /* fails on win8 */
 106         { "\\\\.\\con",    8, 6, TRUE },  /* fails on win8 */
 107         { "\\\\.\\CON2",   0, 0 },
 108         { "",              0, 0 },
 109         { "\\\\foo\\nul",  0, 0 },
 110         { "c:\\nul:",      6, 6 },
 111         { "c:\\nul\\",     0, 0 },
 112         { "c:\\nul\\foo",  0, 0 },
 113         { "c:\\nul::",     6, 6, TRUE },  /* fails on nt4 */
 114         { "c:\\nul::::::", 6, 6, TRUE },  /* fails on nt4 */
 115         { "c:prn     ",    4, 6 },
 116         { "c:prn.......",  4, 6 },
 117         { "c:prn... ...",  4, 6 },
 118         { "c:NUL  ....  ", 4, 6, TRUE },  /* fails on nt4 */
 119         { "c: . . .",      0, 0 },
 120         { "c:",            0, 0 },
 121         { " . . . :",      0, 0 },
 122         { ":",             0, 0 },
 123         { "c:nul. . . :",  4, 6 },
 124         { "c:nul . . :",   4, 6, TRUE },  /* fails on nt4 */
 125         { "c:nul0",        0, 0 },
 126         { "c:prn:aaa",     4, 6, TRUE },  /* fails on win9x */
 127         { "c:PRN:.txt",    4, 6 },
 128         { "c:aux:.txt...", 4, 6 },
 129         { "c:prn:.txt:",   4, 6 },
 130         { "c:nul:aaa",     4, 6, TRUE },  /* fails on win9x */
 131         { "con:",          0, 6 },
 132         { "lpt1:",         0, 8 },
 133         { "c:com5:",       4, 8 },
 134         { "CoM4:",         0, 8 },
 135         { "lpt9:",         0, 8 },
 136         { "c:\\lpt0.txt",  0, 0 },
 137         { "c:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 138           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 139           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 140           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 141           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 142           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 143           "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\nul.txt", 1000, 6 },
 144         // ReactOS r54114
 145         { "c:\\nul",       6, 6 },
 146         { NULL, 0 }
 147     };
 148
 149     const struct test *test;
 150     WCHAR buffer[2000];
 151     ULONG ret;
 152
 153     if (!pRtlIsDosDeviceName_U)
 154     {
 155         win_skip("RtlIsDosDeviceName_U is not available\n");
 156         return;
 157     }
 158
 159     for (test = tests; test->path; test++)
 160     {
 161         pRtlMultiByteToUnicodeN( buffer, sizeof(buffer), NULL, test->path, strlen(test->path)+1 );
 162         ret = pRtlIsDosDeviceName_U( buffer );
 163         ok( ret == MAKELONG( test->len, test->pos ) ||
 164             (test->fails && broken( ret == 0 )),
 165             "Wrong result (%d,%d)/(%d,%d) for %s\n",
 166             HIWORD(ret), LOWORD(ret), test->pos, test->len, test->path );
 167     }
 168 }
 169
 170 static void test_RtlIsNameLegalDOS8Dot3(void)
 171 {
 172     struct test
 173     {
 174         const char *path;
 175         BOOLEAN result;
 176         BOOLEAN spaces;
 177     };
 178
 179     static const struct test tests[] =
 180     {
 181         { "12345678",     TRUE,  FALSE },
 182         { "123 5678",     TRUE,  TRUE  },
 183         { "12345678.",    FALSE, 2 /*not set*/ },
 184         { "1234 678.",    FALSE, 2 /*not set*/ },
 185         { "12345678.a",   TRUE,  FALSE },
 186         { "12345678.a ",  FALSE, 2 /*not set*/ },
 187         { "12345678.a c", TRUE,  TRUE  },
 188         { " 2345678.a ",  FALSE, 2 /*not set*/ },
 189         { "1 345678.abc", TRUE,  TRUE },
 190         { "1      8.a c", TRUE,  TRUE },
 191         { "1 3 5 7 .abc", FALSE, 2 /*not set*/ },
 192         { "12345678.  c", TRUE,  TRUE },
 193         { "123456789.a",  FALSE, 2 /*not set*/ },
 194         { "12345.abcd",   FALSE, 2 /*not set*/ },
 195         { "12345.ab d",   FALSE, 2 /*not set*/ },
 196         { ".abc",         FALSE, 2 /*not set*/ },
 197         { "12.abc.d",     FALSE, 2 /*not set*/ },
 198         { ".",            TRUE,  FALSE },
 199         { "..",           TRUE,  FALSE },
 200         { "...",          FALSE, 2 /*not set*/ },
 201         { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", FALSE, 2 /*not set*/ },
 202         { NULL, 0 }
 203     };
 204
 205     const struct test *test;
 206     UNICODE_STRING ustr;
 207     OEM_STRING oem, oem_ret;
 208     WCHAR buffer[200];
 209     char buff2[12];
 210     BOOLEAN ret, spaces;
 211
 212     if (!pRtlIsNameLegalDOS8Dot3)
 213     {
 214         win_skip("RtlIsNameLegalDOS8Dot3 is not available\n");
 215         return;
 216     }
 217
 218     ustr.MaximumLength = sizeof(buffer);
 219     ustr.Buffer = buffer;
 220     for (test = tests; test->path; test++)
 221     {
 222         char path[100];
 223         strcpy(path, test->path);
 224         oem.Buffer = path;
 225         oem.Length = strlen(test->path);
 226         oem.MaximumLength = oem.Length + 1;
 227         pRtlOemStringToUnicodeString( &ustr, &oem, FALSE );
 228         spaces = 2;
 229         oem_ret.Length = oem_ret.MaximumLength = sizeof(buff2);
 230         oem_ret.Buffer = buff2;
 231         ret = pRtlIsNameLegalDOS8Dot3( &ustr, &oem_ret, &spaces );
 232         ok( ret == test->result, "Wrong result %d/%d for '%s'\n", ret, test->result, test->path );
 233         ok( spaces == test->spaces, "Wrong spaces value %d/%d for '%s'\n", spaces, test->spaces, test->path );
 234         if (strlen(test->path) <= 12)
 235         {
 236             char str[13];
 237             int i;
 238             strcpy( str, test->path );
 239             for (i = 0; str[i]; i++) str[i] = toupper(str[i]);
 240             ok( oem_ret.Length == strlen(test->path), "Wrong length %d/%d for '%s'\n",
 241                 oem_ret.Length, lstrlenA(test->path), test->path );
 242             ok( !memcmp( oem_ret.Buffer, str, oem_ret.Length ),
 243                 "Wrong string '%.*s'/'%s'\n", oem_ret.Length, oem_ret.Buffer, str );
 244         }
 245     }
 246 }
 247 static void test_RtlGetFullPathName_U(void)
 248 {
 249     static const WCHAR emptyW[] = {0};
 250     static const WCHAR deadbeefW[] = {'d','e','a','d','b','e','e','f',0};
 251
 252     struct test
 253     {
 254         const char *path;
 255         const char *rname;
 256         const char *rfile;
 257         const char *alt_rname;
 258         const char *alt_rfile;
 259     };
 260
 261     static const struct test tests[] =
 262         {
 263             { "c:/test",                     "c:\\test",         "test"},
 264             { "c:/test     ",                "c:\\test",         "test"},
 265             { "c:/test.",                    "c:\\test",         "test"},
 266             { "c:/test  ....   ..   ",       "c:\\test",         "test"},
 267             { "c:/test/  ....   ..   ",      "c:\\test\\",       NULL},
 268             { "c:/test/..",                  "c:\\",             NULL},
 269             { "c:/test/.. ",                 "c:\\test\\",       NULL},
 270             { "c:/TEST",                     "c:\\TEST",         "TEST"},
 271             { "c:/test/file",                "c:\\test\\file",   "file"},
 272             { "c:/test./file",               "c:\\test\\file",   "file"},
 273             { "c:/test.. /file",             "c:\\test.. \\file","file"},
 274             { "c:/test/././file",            "c:\\test\\file",   "file"},
 275             { "c:/test\\.\\.\\file",         "c:\\test\\file",   "file"},
 276             { "c:/test/\\.\\.\\file",        "c:\\test\\file",   "file"},
 277             { "c:/test\\\\.\\.\\file",       "c:\\test\\file",   "file"},
 278             { "c:/test\\test1\\..\\.\\file", "c:\\test\\file",   "file"},
 279             { "c:///test\\.\\.\\file//",     "c:\\test\\file\\", NULL,
 280                                              "c:\\test\\file",   "file"},  /* nt4 */
 281             { "c:///test\\..\\file\\..\\//", "c:\\",             NULL},
 282             { "c:/test../file",              "c:\\test.\\file",  "file",
 283                                              "c:\\test..\\file", "file"},  /* vista */
 284             { "c:\\test",                    "c:\\test",         "test"},
 285             { NULL, NULL, NULL}
 286         };
 287
 288     const struct test *test;
 289     WCHAR pathbufW[2*MAX_PATH], rbufferW[MAX_PATH];
 290     CHAR  rbufferA[MAX_PATH], rfileA[MAX_PATH];
 291     ULONG ret;
 292     WCHAR *file_part;
 293     DWORD reslen;
 294     UINT len;
 295
 296     if (!pRtlGetFullPathName_U)
 297     {
 298         win_skip("RtlGetFullPathName_U is not available\n");
 299         return;
 300     }
 301
 302     file_part = (WCHAR *)0xdeadbeef;
 303     lstrcpyW(rbufferW, deadbeefW);
 304     ret = pRtlGetFullPathName_U(NULL, MAX_PATH, rbufferW, &file_part);
 305     ok(!ret, "Expected RtlGetFullPathName_U to return 0, got %u\n", ret);
 306     ok(!lstrcmpW(rbufferW, deadbeefW),
 307        "Expected the output buffer to be untouched, got %s\n", wine_dbgstr_w(rbufferW));
 308     ok(file_part == (WCHAR *)0xdeadbeef ||
 309        file_part == NULL, /* Win7 */
 310        "Expected file part pointer to be untouched, got %p\n", file_part);
 311
 312     file_part = (WCHAR *)0xdeadbeef;
 313     lstrcpyW(rbufferW, deadbeefW);
 314     ret = pRtlGetFullPathName_U(emptyW, MAX_PATH, rbufferW, &file_part);
 315     ok(!ret, "Expected RtlGetFullPathName_U to return 0, got %u\n", ret);
 316     ok(!lstrcmpW(rbufferW, deadbeefW),
 317        "Expected the output buffer to be untouched, got %s\n", wine_dbgstr_w(rbufferW));
 318     ok(file_part == (WCHAR *)0xdeadbeef ||
 319        file_part == NULL, /* Win7 */
 320        "Expected file part pointer to be untouched, got %p\n", file_part);
 321
 322     for (test = tests; test->path; test++)
 323     {
 324         len= strlen(test->rname) * sizeof(WCHAR);
 325         pRtlMultiByteToUnicodeN(pathbufW , sizeof(pathbufW), NULL, test->path, strlen(test->path)+1 );
 326         ret = pRtlGetFullPathName_U( pathbufW,MAX_PATH, rbufferW, &file_part);
 327         ok( ret == len || (test->alt_rname && ret == strlen(test->alt_rname)*sizeof(WCHAR)),
 328             "Wrong result %d/%d for \"%s\"\n", ret, len, test->path );
 329         ok(pRtlUnicodeToMultiByteN(rbufferA,MAX_PATH,&reslen,rbufferW,(lstrlenW(rbufferW) + 1) * sizeof(WCHAR)) == STATUS_SUCCESS,
 330            "RtlUnicodeToMultiByteN failed\n");
 331         ok(!lstrcmpA(rbufferA,test->rname) || (test->alt_rname && !lstrcmpA(rbufferA,test->alt_rname)),
 332            "Got \"%s\" expected \"%s\"\n",rbufferA,test->rname);
 333         if (file_part)
 334         {
 335             ok(pRtlUnicodeToMultiByteN(rfileA,MAX_PATH,&reslen,file_part,(lstrlenW(file_part) + 1) * sizeof(WCHAR)) == STATUS_SUCCESS,
 336                "RtlUnicodeToMultiByteN failed\n");
 337             ok((test->rfile && !lstrcmpA(rfileA,test->rfile)) ||
 338                (test->alt_rfile && !lstrcmpA(rfileA,test->alt_rfile)),
 339                "Got \"%s\" expected \"%s\"\n",rfileA,test->rfile);
 340         }
 341         else
 342         {
 343             ok( !test->rfile, "Got NULL expected \"%s\"\n", test->rfile );
 344         }
 345     }
 346 }
 347
 348 static void test_RtlDosPathNameToNtPathName_U_WithStatus(void)
 349 {
 350     static const WCHAR emptyW[] = { 0 };
 351     WCHAR path[MAX_PATH];
 352     UNICODE_STRING nameW;
 353     NTSTATUS status;
 354
 355     if (!pRtlDosPathNameToNtPathName_U_WithStatus)
 356     {
 357         win_skip("RtlDosPathNameToNtPathName_U_WithStatus() is not supported.\n");
 358         return;
 359     }
 360
 361     GetCurrentDirectoryW( MAX_PATH, path );
 362
 363     status = pRtlDosPathNameToNtPathName_U_WithStatus( path, &nameW, NULL, NULL );
 364     ok(!status, "Failed convert to nt path, %#x.\n", status);
 365
 366     status = pRtlDosPathNameToNtPathName_U_WithStatus( NULL, &nameW, NULL, NULL );
 367     ok(status == STATUS_OBJECT_NAME_INVALID || broken(status == STATUS_OBJECT_PATH_NOT_FOUND) /* W2k3 */,
 368         "Unexpected status %#x.\n", status);
 369
 370     status = pRtlDosPathNameToNtPathName_U_WithStatus( emptyW, &nameW, NULL, NULL );
 371     ok(status == STATUS_OBJECT_NAME_INVALID || broken(status == STATUS_OBJECT_PATH_NOT_FOUND) /* W2k3 */,
 372         "Unexpected status %#x.\n", status);
 373
 374     RtlFreeUnicodeString( &nameW );
 375 }
 376
 377 START_TEST(path)
 378 {
 379     HMODULE mod = GetModuleHandleA("ntdll.dll");
 380     if (!mod)
 381     {
 382         win_skip("Not running on NT, skipping tests\n");
 383         return;
 384     }
 385
 386     pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN");
 387     pRtlUnicodeToMultiByteN = (void *)GetProcAddress(mod,"RtlUnicodeToMultiByteN");
 388     pRtlDetermineDosPathNameType_U = (void *)GetProcAddress(mod,"RtlDetermineDosPathNameType_U");
 389     pRtlIsDosDeviceName_U = (void *)GetProcAddress(mod,"RtlIsDosDeviceName_U");
 390     pRtlOemStringToUnicodeString = (void *)GetProcAddress(mod,"RtlOemStringToUnicodeString");
 391     pRtlIsNameLegalDOS8Dot3 = (void *)GetProcAddress(mod,"RtlIsNameLegalDOS8Dot3");
 392     pRtlGetFullPathName_U = (void *)GetProcAddress(mod,"RtlGetFullPathName_U");
 393     pRtlDosPathNameToNtPathName_U_WithStatus = (void *)GetProcAddress(mod, "RtlDosPathNameToNtPathName_U_WithStatus");
 394
 395     test_RtlDetermineDosPathNameType_U();
 396     test_RtlIsDosDeviceName_U();
 397     test_RtlIsNameLegalDOS8Dot3();
 398     test_RtlGetFullPathName_U();
 399     test_RtlDosPathNameToNtPathName_U_WithStatus();
 400 }