2 * Unit test suite for Get*PathNamesA and (Get|Set)CurrentDirectoryA.
4 * Copyright 2002 Geoffrey Hausheer
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/test.h"
27 #define HAS_TRAIL_SLASH_A(string) (string[lstrlenA(string)-1]=='\\')
29 #define LONGFILE "Long File test.path"
30 #define SHORTFILE "pathtest.pth"
31 #define SHORTDIR "shortdir"
32 #define LONGDIR "Long Directory"
33 #define NONFILE_SHORT "noexist.pth"
34 #define NONFILE_LONG "Non Existant File"
35 #define NONDIR_SHORT "notadir"
36 #define NONDIR_LONG "Non Existant Directory"
38 #define NOT_A_VALID_DRIVE '@'
40 /* the following characters don't work well with GetFullPathNameA
41 in Win98. I don't know if this is a FAT thing, or if it is an OS thing
42 but I don't test these characters now.
43 NOTE: Win2k allows GetFullPathNameA to work with them though
46 static const CHAR funny_chars[]="!@#$%^&*()=+{}[],?'`\"";
47 static const CHAR is_char_ok[] ="111111101111111110110";
48 static const CHAR wine_todo[] ="111111101100110000110";
50 static DWORD (WINAPI *pGetLongPathNameA)(LPCSTR,LPSTR,DWORD);
52 /* a structure to deal with wine todos somewhat cleanly */
62 /* function that tests GetFullPathNameA, GetShortPathNameA,GetLongPathNameA */
63 /* NOTE: the passfail structure is used to allow cutomizeable todo checking
64 for wine. It is not very pretty, but it sure beats duplicating this
65 function lots of times
67 static void test_ValidPathA(CHAR *curdir, CHAR *subdir, CHAR *filename,
68 CHAR *shortstr, SLpassfail *passfail, CHAR *errstr) {
69 CHAR tmpstr[MAX_PATH],
70 fullpath[MAX_PATH], /*full path to the file (not short/long) */
71 subpath[MAX_PATH], /*relative path to the file */
72 fullpathshort[MAX_PATH], /*absolue path to the file (short format) */
73 fullpathlong[MAX_PATH], /*absolute path to the file (long format) */
74 curdirshort[MAX_PATH], /*absolute path to the current dir (short) */
75 curdirlong[MAX_PATH]; /*absolute path to the current dir (long) */
76 LPSTR strptr; /*ptr to the filename portion of the path */
78 /* if passfail is NULL, we can perform all checks within this function,
79 otherwise, we will return the relevant data in the passfail struct, so
80 we must initialize it first
83 passfail->shortlen=-1;passfail->s2llen=-1;passfail->longlen=-1;
84 passfail->shorterror=0;passfail->s2lerror=0;passfail->longerror=0;
86 /* GetLongPathNameA is only supported on Win2k+ and Win98+ */
87 if(pGetLongPathNameA) {
88 ok((len=pGetLongPathNameA(curdir,curdirlong,MAX_PATH)),
89 "%s: GetLongPathNameA failed",errstr);
90 /*GetLongPathNameA can return a trailing '\\' but shouldn't do so here */
91 ok(! HAS_TRAIL_SLASH_A(curdirlong),
92 "%s: GetLongPathNameA should not have a trailing \\",errstr);
94 ok((len=GetShortPathNameA(curdir,curdirshort,MAX_PATH)),
95 "%s: GetShortPathNameA failed",errstr);
96 /*GetShortPathNameA can return a trailing '\\' but shouldn't do so here */
97 ok(! HAS_TRAIL_SLASH_A(curdirshort),
98 "%s: GetShortPathNameA should not have a trailing \\",errstr);
99 /* build relative and absolute paths from inputs */
100 if(lstrlenA(subdir)) {
101 sprintf(subpath,"%s\\%s",subdir,filename);
103 lstrcpyA(subpath,filename);
105 sprintf(fullpath,"%s\\%s",curdir,subpath);
106 sprintf(fullpathshort,"%s\\%s",curdirshort,subpath);
107 sprintf(fullpathlong,"%s\\%s",curdirlong,subpath);
108 /* Test GetFullPathNameA functionality */
109 len=GetFullPathNameA(subpath,MAX_PATH,tmpstr,&strptr);
110 ok(len, "GetFullPathNameA failed for: '%s'",subpath);
111 if(HAS_TRAIL_SLASH_A(subpath)) {
112 /* Wine strips off the trailing '\\'. Neither Win98 nor Win2k do this. */
115 "%s: GetFullPathNameA should not return a filename ptr",errstr);
116 ok(lstrcmpiA(fullpath,tmpstr)==0,
117 "%s: GetFullPathNameA returned '%s' instead of '%s'",
118 errstr,tmpstr,fullpath);
121 ok(lstrcmpiA(strptr,filename)==0,
122 "%s: GetFullPathNameA returned '%s' instead of '%s'",
123 errstr,strptr,filename);
124 ok(lstrcmpiA(fullpath,tmpstr)==0,
125 "%s: GetFullPathNameA returned '%s' instead of '%s'",
126 errstr,tmpstr,fullpath);
128 /* Test GetShortPathNameA functionality */
130 len=GetShortPathNameA(fullpathshort,shortstr,MAX_PATH);
132 ok(len, "%s: GetShortPathNameA failed",errstr);
134 passfail->shortlen=len;
135 passfail->shorterror=GetLastError();
137 /* Test GetLongPathNameA functionality
138 We test both conversion from GetFullPathNameA and from GetShortPathNameA
140 if(pGetLongPathNameA) {
143 len=pGetLongPathNameA(shortstr,tmpstr,MAX_PATH);
146 "%s: GetLongPathNameA failed during Short->Long conversion", errstr);
147 ok(lstrcmpiA(fullpathlong,tmpstr)==0,
148 "%s: GetLongPathNameA returned '%s' instead of '%s'",
149 errstr,tmpstr,fullpathlong);
151 passfail->s2llen=len;
152 passfail->s2lerror=GetLastError();
156 len=pGetLongPathNameA(fullpath,tmpstr,MAX_PATH);
158 ok(len, "%s: GetLongPathNameA failed",errstr);
159 if(HAS_TRAIL_SLASH_A(fullpath)) {
160 /* Wine strips off the trailing '\\' Neither Win98 nor Win2k do this */
162 ok(lstrcmpiA(fullpathlong,tmpstr)==0,
163 "%s: GetLongPathNameA returned '%s' instead of '%s'",
164 errstr,tmpstr,fullpathlong);
167 ok(lstrcmpiA(fullpathlong,tmpstr)==0,
168 "%s: GetLongPathNameA returned '%s' instead of '%s'",
169 errstr,tmpstr,fullpathlong);
172 passfail->longlen=len;
173 passfail->longerror=GetLastError();
178 /* split path into leading directory, and 8.3 filename */
179 static void test_SplitShortPathA(CHAR *path,CHAR *dir,CHAR *eight,CHAR *three) {
180 DWORD len,done,error;
184 ext=len; fil=len; done=0; error=0;
185 /* walk backwards over path looking for '.' or '\\' seperators */
186 for(i=len-1;(i>=0) && (!done);i--) {
188 if(ext!=len) error=1; else ext=i;
189 else if(path[i]=='\\') {
198 /* Check that we didn't find a trailing '\\' or multiple '.' */
199 ok(!error,"Illegal file found in 8.3 path '%s'",path);
200 /* Seperate dir, root, and extension */
201 if(ext!=len) lstrcpyA(three,path+ext+1); else lstrcpyA(three,"");
203 lstrcpynA(eight,path+fil+1,ext-fil);
204 lstrcpynA(dir,path,fil+1);
206 lstrcpynA(eight,path,ext+1);
209 /* Validate that root and extension really are 8.3 */
210 ok(lstrlenA(eight)<=8 && lstrlenA(three)<=3,
211 "GetShortPathNAmeA did not return an 8.3 path");
214 /* Check that GetShortPathNameA returns a valid 8.3 path */
215 static void test_LongtoShortA(CHAR *teststr,CHAR *goodstr,
216 CHAR *ext,CHAR *errstr) {
217 CHAR dir[MAX_PATH],eight[MAX_PATH],three[MAX_PATH];
219 test_SplitShortPathA(teststr,dir,eight,three);
220 ok(lstrcmpiA(dir,goodstr)==0,
221 "GetShortPathNameA returned '%s' instead of '%s'",dir,goodstr);
222 ok(lstrcmpiA(three,ext)==0,
223 "GetShortPathNameA returned '%s' with incorrect extension",three);
226 /* Test that Get(Short|Long|Full)PathNameA work correctly with interesting
227 characters in the filename.
228 'valid' indicates whether this would be an allowed filename
229 'todo' indictaes that wine doesn't get this right yet.
230 NOTE: We always call this routine with a non-existant filename, so
231 Get(Short|Long)PathNameA should never pass, but GetFullPathNameA
234 static void test_FunnyChars(CHAR *curdir,CHAR *filename,
235 INT valid,INT todo,CHAR *errstr) {
236 CHAR tmpstr[MAX_PATH];
239 test_ValidPathA(curdir,"",filename,tmpstr,&passfail,errstr);
242 ok(passfail.shortlen==0,
243 "%s: GetShortPathNameA passed when it shouldn't have",errstr);
246 ok(passfail.shortlen==0,
247 "%s: GetShortPathNameA passed when it shouldn't have",errstr);
252 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
253 "%s: GetShortPathA returned %ld and not %d",
254 errstr,passfail.shorterror,ERROR_FILE_NOT_FOUND);
257 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
258 "%s: GetShortPathA returned %ld and not %d",
259 errstr,passfail.shorterror,ERROR_FILE_NOT_FOUND);
264 /* Win2k returns ERROR_INVALID_NAME, Win98, wine return ERROR_FILE_NOT_FOUND */
265 ok(passfail.shorterror==ERROR_INVALID_NAME ||
266 passfail.shorterror==ERROR_FILE_NOT_FOUND,
267 "%s: GetShortPathA returned %ld and not %d or %d",
268 errstr,passfail.shorterror,ERROR_INVALID_NAME,ERROR_FILE_NOT_FOUND);
271 ok(passfail.shorterror==ERROR_INVALID_NAME ||
272 passfail.shorterror==ERROR_FILE_NOT_FOUND,
273 "%s: GetShortPathA returned %ld and not %d or %d",
274 errstr,passfail.shorterror,ERROR_INVALID_NAME,ERROR_FILE_NOT_FOUND);
277 if(pGetLongPathNameA) {
278 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
280 ok(passfail.longerror==ERROR_FILE_NOT_FOUND,
281 "%s: GetLongPathA returned %ld and not %d",
282 errstr,passfail.longerror,ERROR_FILE_NOT_FOUND);
284 ok(passfail.longerror==ERROR_INVALID_NAME ||
285 passfail.longerror==ERROR_FILE_NOT_FOUND,
286 "%s: GetLongPathA returned %ld and not %d or %d'",
287 errstr, passfail.longerror,ERROR_INVALID_NAME,ERROR_FILE_NOT_FOUND);
292 /* Routine to test that SetCurrentDirectory behaves as expected. */
293 static void test_setdir(CHAR *olddir,CHAR *newdir,
294 CHAR *cmprstr, INT pass,CHAR *errstr)
296 CHAR tmppath[MAX_PATH], *dirptr;
297 DWORD val,len,chklen;
299 val=SetCurrentDirectoryA(newdir);
300 len=GetCurrentDirectoryA(MAX_PATH,tmppath);
301 /* if 'pass' then the SetDirectoryA was supposed to pass */
303 dirptr=(cmprstr==NULL) ? newdir : cmprstr;
304 chklen=lstrlenA(dirptr);
305 ok(val,"%s: SetCurrentDirectoryA failed",errstr);
307 "%s: SetCurrentDirectory did not change the directory, though it passed",
309 ok(lstrcmpiA(dirptr,tmppath)==0,
310 "%s: SetCurrentDirectory did not change the directory, though it passed",
312 ok(SetCurrentDirectoryA(olddir),
313 "%s: Couldn't set directory to it's original value",errstr);
315 /* else thest that it fails correctly */
316 chklen=lstrlenA(olddir);
318 "%s: SetCurrentDirectoryA passed when it should have failed",errstr);
320 "%s: SetCurrentDirectory changed the directory, though it failed",
322 ok(lstrcmpiA(olddir,tmppath)==0,
323 "%s: SetCurrentDirectory changed the directory, though it failed",
327 static void test_InitPathA(CHAR *newdir, CHAR *curDrive, CHAR *otherDrive)
329 CHAR tmppath[MAX_PATH], /*path to TEMP */
332 DWORD len,len1,drives;
336 *curDrive = *otherDrive = NOT_A_VALID_DRIVE;
338 /* Get the current drive letter */
339 if( GetCurrentDirectoryA( MAX_PATH, tmpstr))
340 *curDrive = tmpstr[0];
342 trace( "Unable to discover current drive, some tests will not be conducted.\n");
344 /* Test GetTempPathA */
345 len=GetTempPathA(MAX_PATH,tmppath);
346 ok(len!=0 && len < MAX_PATH,"GetTempPathA failed");
347 ok(HAS_TRAIL_SLASH_A(tmppath),
348 "GetTempPathA returned a path that did not end in '\\'");
349 lstrcpyA(tmpstr,"aaaaaaaa");
350 len1=GetTempPathA(len,tmpstr);
352 "GetTempPathA should return string length %ld instead of %ld",len+1,len1);
354 /* Test GetTmpFileNameA
355 The only test we do here is whether GetTempFileNameA passes or not.
356 We do not thoroughly test this function yet (specifically, whether
357 it behaves correctly when 'unique' is non zero)
359 ok((id=GetTempFileNameA(tmppath,"path",0,newdir)),"GetTempFileNameA failed");
360 sprintf(tmpstr,"pat%.4x.tmp",id);
361 sprintf(tmpstr1,"pat%x.tmp",id);
362 ok(lstrcmpiA(newdir+(lstrlenA(newdir)-lstrlenA(tmpstr)),tmpstr)==0 ||
363 lstrcmpiA(newdir+(lstrlenA(newdir)-lstrlenA(tmpstr1)),tmpstr1)==0,
364 "GetTempPath returned '%s' which doesn't match '%s' or '%s'",
365 newdir,tmpstr,tmpstr1);
367 /* Find first valid drive letter that is neither newdir[0] nor curDrive */
368 drives = GetLogicalDrives() & ~(1<<(newdir[0]-'A'));
369 if( *curDrive != NOT_A_VALID_DRIVE)
370 drives &= ~(1<<(*curDrive-'A'));
372 for( *otherDrive='A'; (drives & 1) == 0; drives>>=1, (*otherDrive)++);
374 trace( "Could not find alternative drive, some tests will not be conducted.\n");
376 /* Do some CreateDirectoryA tests */
377 /* It would be nice to do test the SECURITY_ATTRIBUTES, but I don't
378 really understand how they work.
379 More formal tests should be done along with CreateFile tests
381 ok(CreateDirectoryA(newdir,NULL)==0,
382 "CreateDirectoryA succeeded even though a file of the same name exists");
383 ok(DeleteFileA(newdir),"Couldn't delete the temporary file we just created");
384 ok(CreateDirectoryA(newdir,NULL),"CreateDirectoryA failed");
385 /* Create some files to test other functions. Note, we will test CreateFileA
388 sprintf(tmpstr,"%s\\%s",newdir,SHORTDIR);
389 ok(CreateDirectoryA(tmpstr,NULL),"CreateDirectoryA failed");
390 sprintf(tmpstr,"%s\\%s",newdir,LONGDIR);
391 ok(CreateDirectoryA(tmpstr,NULL),"CreateDirectoryA failed");
392 sprintf(tmpstr,"%s\\%s\\%s",newdir,SHORTDIR,SHORTFILE);
393 hndl=CreateFileA(tmpstr,GENERIC_WRITE,0,NULL,
394 CREATE_NEW,FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
395 ok(hndl!=INVALID_HANDLE_VALUE,"CreateFileA failed");
396 ok(CloseHandle(hndl),"CloseHandle failed");
397 sprintf(tmpstr,"%s\\%s\\%s",newdir,SHORTDIR,LONGFILE);
398 hndl=CreateFileA(tmpstr,GENERIC_WRITE,0,NULL,
399 CREATE_NEW,FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
400 ok(hndl!=INVALID_HANDLE_VALUE,"CreateFileA failed");
401 ok(CloseHandle(hndl),"CloseHandle failed");
402 sprintf(tmpstr,"%s\\%s\\%s",newdir,LONGDIR,SHORTFILE);
403 hndl=CreateFileA(tmpstr,GENERIC_WRITE,0,NULL,
404 CREATE_NEW,FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
405 ok(hndl!=INVALID_HANDLE_VALUE,"CreateFileA failed");
406 ok(CloseHandle(hndl),"CloseHandle failed");
407 sprintf(tmpstr,"%s\\%s\\%s",newdir,LONGDIR,LONGFILE);
408 hndl=CreateFileA(tmpstr,GENERIC_WRITE,0,NULL,
409 CREATE_NEW,FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
410 ok(hndl!=INVALID_HANDLE_VALUE,"CreateFileA failed");
411 ok(CloseHandle(hndl),"CloseHandle failed");
414 /* Test GetCurrentDirectory & SetCurrentDirectory */
415 static void test_CurrentDirectoryA(CHAR *origdir, CHAR *newdir)
417 CHAR tmpstr[MAX_PATH],tmpstr1[MAX_PATH];
419 /* Save the original directory, so that we can return to it at the end
422 len=GetCurrentDirectoryA(MAX_PATH,origdir);
423 ok(len!=0 && len < MAX_PATH,"GetCurrentDirectoryA failed");
424 ok(lstrcmpiA(origdir+(len-1),"\\")!=0,
425 "GetCurrentDirectoryA should not have a trailing \\");
426 /* Make sure that CetCurrentDirectoryA doesn't overwrite the buffer when the
427 buffer size is too small to hold the current directory
429 lstrcpyA(tmpstr,"aaaaaaa");
430 len1=GetCurrentDirectoryA(len,tmpstr);
431 ok(len1==len+1, "GetCurrentDirectoryA returned %ld instead of %ld",len1,len+1);
432 ok(lstrcmpiA(tmpstr,"aaaaaaa")==0,
433 "GetCurrentDirectoryA should not have modified the buffer");
434 /* SetCurrentDirectoryA shouldn't care whether the string has a
437 sprintf(tmpstr,"%s\\",newdir);
438 test_setdir(origdir,tmpstr,newdir,1,"check 1");
439 test_setdir(origdir,newdir,NULL,1,"check 2");
440 /* Set the directory to the working area. We just tested that this works,
441 so why check it again.
443 SetCurrentDirectoryA(newdir);
444 /* Check that SetCurrentDirectory fails when a non-existant dir is specified */
445 sprintf(tmpstr,"%s\\%s\\%s",newdir,SHORTDIR,NONDIR_SHORT);
446 test_setdir(newdir,tmpstr,NULL,0,"check 3");
447 /* Check that SetCurrentDirectory fails for a non-existant lond directory */
448 sprintf(tmpstr,"%s\\%s\\%s",newdir,SHORTDIR,NONDIR_LONG);
449 test_setdir(newdir,tmpstr,NULL,0,"check 4");
450 /* Check that SetCurrentDirectory passes with a long directory */
451 sprintf(tmpstr,"%s\\%s",newdir,LONGDIR);
452 test_setdir(newdir,tmpstr,NULL,1,"check 5");
453 /* Check that SetCurrentDirectory passes with a short relative directory */
454 sprintf(tmpstr,"%s",SHORTDIR);
455 sprintf(tmpstr1,"%s\\%s",newdir,SHORTDIR);
456 test_setdir(newdir,tmpstr,tmpstr1,1,"check 6");
457 /* starting with a '.' */
458 sprintf(tmpstr,".\\%s",SHORTDIR);
459 test_setdir(newdir,tmpstr,tmpstr1,1,"check 7");
460 /* Check that SetCurrentDirectory passes with a short relative directory */
461 sprintf(tmpstr,"%s",LONGDIR);
462 sprintf(tmpstr1,"%s\\%s",newdir,LONGDIR);
463 test_setdir(newdir,tmpstr,tmpstr1,1,"check 8");
464 /* starting with a '.' */
465 sprintf(tmpstr,".\\%s",LONGDIR);
466 test_setdir(newdir,tmpstr,tmpstr1,1,"check 9");
469 /* Cleanup the mess we made while executing these tests */
470 static void test_CleanupPathA(CHAR *origdir, CHAR *curdir)
472 CHAR tmpstr[MAX_PATH];
473 sprintf(tmpstr,"%s\\%s\\%s",curdir,SHORTDIR,SHORTFILE);
474 ok(DeleteFileA(tmpstr),"DeleteFileA failed");
475 sprintf(tmpstr,"%s\\%s\\%s",curdir,SHORTDIR,LONGFILE);
476 ok(DeleteFileA(tmpstr),"DeleteFileA failed");
477 sprintf(tmpstr,"%s\\%s\\%s",curdir,LONGDIR,SHORTFILE);
478 ok(DeleteFileA(tmpstr),"DeleteFileA failed");
479 sprintf(tmpstr,"%s\\%s\\%s",curdir,LONGDIR,LONGFILE);
480 ok(DeleteFileA(tmpstr),"DeleteFileA failed");
481 sprintf(tmpstr,"%s\\%s",curdir,SHORTDIR);
482 ok(RemoveDirectoryA(tmpstr),"RemoveDirectoryA failed");
483 sprintf(tmpstr,"%s\\%s",curdir,LONGDIR);
484 ok(RemoveDirectoryA(tmpstr),"RemoveDirectoryA failed");
485 ok(SetCurrentDirectoryA(origdir),"SetCurrentDirectoryA failed");
486 ok(RemoveDirectoryA(curdir),"RemoveDirectoryA failed");
489 /* This routine will test Get(Full|Short|Long)PathNameA */
490 static void test_PathNameA(CHAR *curdir, CHAR curDrive, CHAR otherDrive)
492 CHAR curdir_short[MAX_PATH],
493 longdir_short[MAX_PATH];
494 CHAR tmpstr[MAX_PATH],tmpstr1[MAX_PATH];
495 LPSTR strptr; /*ptr to the filename portion of the path */
498 CHAR dir[MAX_PATH],eight[MAX_PATH],three[MAX_PATH];
501 /* Get the short form of the current directory */
502 ok((len=GetShortPathNameA(curdir,curdir_short,MAX_PATH)),
503 "GetShortPathNameA failed");
504 ok(!HAS_TRAIL_SLASH_A(curdir_short),
505 "GetShortPathNameA should not have a trailing \\");
506 /* Get the short form of the absolute-path to LONGDIR */
507 sprintf(tmpstr,"%s\\%s",curdir_short,LONGDIR);
508 ok((len=GetShortPathNameA(tmpstr,longdir_short,MAX_PATH)),
509 "GetShortPathNameA failed");
510 ok(lstrcmpiA(longdir_short+(len-1),"\\")!=0,
511 "GetShortPathNameA should not have a trailing \\");
513 /* Check the cases where both file and directory exist first */
514 /* Start with a 8.3 directory, 8.3 filename */
515 test_ValidPathA(curdir,SHORTDIR,SHORTFILE,tmpstr,NULL,"test1");
516 sprintf(tmpstr1,"%s\\%s\\%s",curdir_short,SHORTDIR,SHORTFILE);
517 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
518 "GetShortPathNameA returned '%s' instead of '%s'",tmpstr,tmpstr1);
519 /* Now try a 8.3 directory, long file name */
520 test_ValidPathA(curdir,SHORTDIR,LONGFILE,tmpstr,NULL,"test2");
521 sprintf(tmpstr1,"%s\\%s",curdir_short,SHORTDIR);
522 test_LongtoShortA(tmpstr,tmpstr1,"PAT","test2");
523 /* Next is a long directory, 8.3 file */
524 test_ValidPathA(curdir,LONGDIR,SHORTFILE,tmpstr,NULL,"test3");
525 sprintf(tmpstr1,"%s\\%s",longdir_short,SHORTFILE);
526 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
527 "GetShortPathNameA returned '%s' instead of '%s'",tmpstr,tmpstr1);
528 /*Lastly a long directory, long file */
529 test_ValidPathA(curdir,LONGDIR,LONGFILE,tmpstr,NULL,"test4");
530 test_LongtoShortA(tmpstr,longdir_short,"PAT","test4");
532 /* Now check all of the invalid file w/ valid directory combinations */
533 /* Start with a 8.3 directory, 8.3 filename */
534 test_ValidPathA(curdir,SHORTDIR,NONFILE_SHORT,tmpstr,&passfail,"test5");
536 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
537 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
538 "GetShortPathA should have returned 'ERROR_FILE_NOT_FOUND'");
540 if(pGetLongPathNameA) {
541 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
542 ok(passfail.longerror==ERROR_FILE_NOT_FOUND,
543 "GetlongPathA should have returned 'ERROR_FILE_NOT_FOUND'");
545 /* Now try a 8.3 directory, long file name */
546 test_ValidPathA(curdir,SHORTDIR,NONFILE_LONG,tmpstr,&passfail,"test6");
547 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
548 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
549 "GetShortPathA should have returned 'ERROR_FILE_NOT_FOUND'");
550 if(pGetLongPathNameA) {
551 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
552 ok(passfail.longerror==ERROR_FILE_NOT_FOUND,
553 "GetlongPathA should have returned 'ERROR_FILE_NOT_FOUND'");
555 /* Next is a long directory, 8.3 file */
556 test_ValidPathA(curdir,LONGDIR,NONFILE_SHORT,tmpstr,&passfail,"test7");
558 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
559 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
560 "GetShortPathA should have returned 'ERROR_FILE_NOT_FOUND'");
562 if(pGetLongPathNameA) {
563 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
564 ok(passfail.longerror==ERROR_FILE_NOT_FOUND,
565 "GetlongPathA should have returned 'ERROR_FILE_NOT_FOUND'");
567 /*Lastly a long directory, long file */
568 test_ValidPathA(curdir,LONGDIR,NONFILE_LONG,tmpstr,&passfail,"test8");
569 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
570 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
571 "GetShortPathA should have returned 'ERROR_FILE_NOT_FOUND'");
572 if(pGetLongPathNameA) {
573 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
574 ok(passfail.longerror==ERROR_FILE_NOT_FOUND,
575 "GetlongPathA should have returned 'ERROR_FILE_NOT_FOUND'");
577 /* Now try again with directories that don't exist */
578 /* 8.3 directory, 8.3 filename */
579 test_ValidPathA(curdir,NONDIR_SHORT,SHORTFILE,tmpstr,&passfail,"test9");
581 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
582 ok(passfail.shorterror==ERROR_PATH_NOT_FOUND ||
583 passfail.shorterror==ERROR_FILE_NOT_FOUND,
584 "GetShortPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
585 passfail.shorterror);
587 if(pGetLongPathNameA) {
588 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
589 ok(passfail.longerror==ERROR_PATH_NOT_FOUND ||
590 passfail.longerror==ERROR_FILE_NOT_FOUND,
591 "GetLongPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
594 /* Now try a 8.3 directory, long file name */
595 test_ValidPathA(curdir,NONDIR_SHORT,LONGFILE,tmpstr,&passfail,"test10");
596 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
597 ok(passfail.shorterror==ERROR_PATH_NOT_FOUND ||
598 passfail.shorterror==ERROR_FILE_NOT_FOUND,
599 "GetShortPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
600 passfail.shorterror);
601 if(pGetLongPathNameA) {
602 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
603 ok(passfail.longerror==ERROR_PATH_NOT_FOUND ||
604 passfail.longerror==ERROR_FILE_NOT_FOUND,
605 "GetLongPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
608 /* Next is a long directory, 8.3 file */
609 test_ValidPathA(curdir,NONDIR_LONG,SHORTFILE,tmpstr,&passfail,"test11");
610 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
611 ok(passfail.shorterror==ERROR_PATH_NOT_FOUND ||
612 passfail.shorterror==ERROR_FILE_NOT_FOUND,
613 "GetShortPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
614 passfail.shorterror);
615 if(pGetLongPathNameA) {
616 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
617 ok(passfail.longerror==ERROR_PATH_NOT_FOUND ||
618 passfail.longerror==ERROR_FILE_NOT_FOUND,
619 "GetLongPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
622 /*Lastly a long directory, long file */
623 test_ValidPathA(curdir,NONDIR_LONG,LONGFILE,tmpstr,&passfail,"test12");
624 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
625 ok(passfail.shorterror==ERROR_PATH_NOT_FOUND ||
626 passfail.shorterror==ERROR_FILE_NOT_FOUND,
627 "GetShortPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
628 passfail.shorterror);
629 if(pGetLongPathNameA) {
630 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
631 ok(passfail.longerror==ERROR_PATH_NOT_FOUND ||
632 passfail.longerror==ERROR_FILE_NOT_FOUND,
633 "GetLongPathA returned %ld and not 'ERROR_PATH_NOT_FOUND'",
636 /* Next try directories ending with '\\' */
637 /* Existing Directories */
638 sprintf(tmpstr,"%s\\",SHORTDIR);
639 test_ValidPathA(curdir,"",tmpstr,tmpstr1,NULL,"test13");
640 sprintf(tmpstr,"%s\\",LONGDIR);
641 test_ValidPathA(curdir,"",tmpstr,tmpstr1,NULL,"test14");
642 /* Non-existant directories */
643 sprintf(tmpstr,"%s\\",NONDIR_SHORT);
644 test_ValidPathA(curdir,"",tmpstr,tmpstr1,&passfail,"test15");
646 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
647 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
648 "GetShortPathA returned %ld and not 'ERROR_FILE_NOT_FOUND'",
649 passfail.shorterror);
651 if(pGetLongPathNameA) {
652 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
653 ok(passfail.longerror==ERROR_FILE_NOT_FOUND,
654 "GetLongPathA returned %ld and not 'ERROR_FILE_NOT_FOUND'",
657 sprintf(tmpstr,"%s\\",NONDIR_LONG);
658 test_ValidPathA(curdir,"",tmpstr,tmpstr1,&passfail,"test16");
659 ok(passfail.shortlen==0,"GetShortPathNameA passed when it shouldn't have");
660 ok(passfail.shorterror==ERROR_FILE_NOT_FOUND,
661 "GetShortPathA returned %ld and not 'ERROR_FILE_NOT_FOUND'",
662 passfail.shorterror);
663 if(pGetLongPathNameA) {
664 ok(passfail.longlen==0,"GetLongPathNameA passed when it shouldn't have");
665 ok(passfail.longerror==ERROR_FILE_NOT_FOUND,
666 "GetLongPathA returned %ld and not 'ERROR_FILE_NOT_FOUND'",
669 /* Test GetFullPathNameA with drive letters */
670 if( curDrive != NOT_A_VALID_DRIVE) {
671 sprintf(tmpstr,"%c:\\%s\\%s",curDrive,SHORTDIR,SHORTFILE);
672 ok(GetFullPathNameA(tmpstr,MAX_PATH,tmpstr1,&strptr),"GetFullPathNameA failed");
673 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
674 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,tmpstr);
675 ok(lstrcmpiA(SHORTFILE,strptr)==0,
676 "GetLongPathNameA returned part '%s' instead of '%s'",strptr,SHORTFILE);
678 /* Without a leading slash, insert the current directory if on the current drive */
679 sprintf(tmpstr,"%c:%s\\%s",curdir[0],SHORTDIR,SHORTFILE);
680 ok(GetFullPathNameA(tmpstr,MAX_PATH,tmpstr1,&strptr),"GetFullPathNameA failed");
681 sprintf(tmpstr,"%s\\%s\\%s",curdir,SHORTDIR,SHORTFILE);
682 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
683 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,tmpstr);
684 ok(lstrcmpiA(SHORTFILE,strptr)==0,
685 "GetLongPathNameA returned part '%s' instead of '%s'",strptr,SHORTFILE);
686 /* Otherwise insert the missing leading slash */
687 if( otherDrive != NOT_A_VALID_DRIVE) {
688 sprintf(tmpstr,"%c:%s\\%s",otherDrive,SHORTDIR,SHORTFILE);
689 ok(GetFullPathNameA(tmpstr,MAX_PATH,tmpstr1,&strptr),"GetFullPathNameA failed for %s", tmpstr);
690 sprintf(tmpstr,"%c:\\%s\\%s",otherDrive,SHORTDIR,SHORTFILE);
691 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
692 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,tmpstr);
693 ok(lstrcmpiA(SHORTFILE,strptr)==0,
694 "GetLongPathNameA returned part '%s' instead of '%s'",strptr,SHORTFILE);
696 /* Xilinx tools like to mix Unix and DOS formats, which Windows handles fine.
698 if( curDrive != NOT_A_VALID_DRIVE) {
699 sprintf(tmpstr,"%c:/%s\\%s",curDrive,SHORTDIR,SHORTFILE);
700 ok(GetFullPathNameA(tmpstr,MAX_PATH,tmpstr1,&strptr),"GetFullPathNameA failed");
701 sprintf(tmpstr,"%c:\\%s\\%s",curDrive,SHORTDIR,SHORTFILE);
702 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
703 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,tmpstr);
704 ok(lstrcmpiA(SHORTFILE,strptr)==0,
705 "GetLongPathNameA returned part '%s' instead of '%s'",strptr,SHORTFILE);
708 sprintf(tmpstr,"%c:%s/%s",curdir[0],SHORTDIR,SHORTFILE);
709 ok(GetFullPathNameA(tmpstr,MAX_PATH,tmpstr1,&strptr),"GetFullPathNameA failed");
710 sprintf(tmpstr,"%s\\%s\\%s",curdir,SHORTDIR,SHORTFILE);
711 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
712 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,tmpstr);
713 ok(lstrcmpiA(SHORTFILE,strptr)==0,
714 "GetLongPathNameA returned part '%s' instead of '%s'",strptr,SHORTFILE);
715 /* Windows will insert a drive letter in front of an absolute UNIX path, but
716 Wine probably shouldn't. */
717 sprintf(tmpstr,"/%s/%s",SHORTDIR,SHORTFILE);
718 ok(GetFullPathNameA(tmpstr,MAX_PATH,tmpstr1,&strptr),"GetFullPathNameA failed");
720 if( curDrive != NOT_A_VALID_DRIVE) {
721 sprintf(tmpstr,"C:\\%s\\%s",SHORTDIR,SHORTFILE);
722 ok(lstrcmpiA(tmpstr,tmpstr1)==0,
723 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,tmpstr);
726 /* This passes in Wine because it still contains the pointer from the previous test */
727 ok(lstrcmpiA(SHORTFILE,strptr)==0,
728 "GetLongPathNameA returned part '%s' instead of '%s'",strptr,SHORTFILE);
730 /* Now try some relative paths */
731 ok(GetShortPathNameA(LONGDIR,tmpstr,MAX_PATH),"GetShortPathNameA failed");
732 test_SplitShortPathA(tmpstr,dir,eight,three);
733 if(pGetLongPathNameA) {
734 ok(pGetLongPathNameA(tmpstr,tmpstr1,MAX_PATH),"GetShortPathNameA failed");
736 ok(lstrcmpiA(tmpstr1,LONGDIR)==0,
737 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,LONGDIR);
740 sprintf(tmpstr,".\\%s",LONGDIR);
741 ok(GetShortPathNameA(tmpstr,tmpstr1,MAX_PATH),"GetShortPathNameA failed");
742 test_SplitShortPathA(tmpstr1,dir,eight,three);
743 ok(lstrcmpiA(dir,".")==0,"GetShortPathNameA did not keep relative directory");
744 if(pGetLongPathNameA) {
745 ok(pGetLongPathNameA(tmpstr1,tmpstr1,MAX_PATH),"GetShortPathNameA failed");
747 ok(lstrcmpiA(tmpstr1,tmpstr)==0,
748 "GetLongPathNameA returned '%s' instead of '%s'",tmpstr1,tmpstr);
751 /* Check out Get*PathNameA on some funny characters */
752 for(i=0;i<lstrlenA(funny_chars);i++) {
754 valid=(is_char_ok[i]=='0') ? 0 : 1;
755 todo=(wine_todo[i]=='0') ? 0 : 1;
756 sprintf(tmpstr1,"check%d-1",i);
757 sprintf(tmpstr,"file%c000.ext",funny_chars[i]);
758 test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1);
759 sprintf(tmpstr1,"check%d-2",i);
760 sprintf(tmpstr,"file000.e%ct",funny_chars[i]);
761 test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1);
762 sprintf(tmpstr1,"check%d-3",i);
763 sprintf(tmpstr,"%cfile000.ext",funny_chars[i]);
764 test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1);
765 sprintf(tmpstr1,"check%d-4",i);
766 sprintf(tmpstr,"file000%c.ext",funny_chars[i]);
767 test_FunnyChars(curdir,tmpstr,valid,todo,tmpstr1);
768 sprintf(tmpstr1,"check%d-5",i);
769 sprintf(tmpstr,"Long %c File",funny_chars[i]);
770 test_FunnyChars(curdir,tmpstr,valid,0,tmpstr1);
771 sprintf(tmpstr1,"check%d-6",i);
772 sprintf(tmpstr,"%c Long File",funny_chars[i]);
773 test_FunnyChars(curdir,tmpstr,valid,0,tmpstr1);
774 sprintf(tmpstr1,"check%d-7",i);
775 sprintf(tmpstr,"Long File %c",funny_chars[i]);
776 test_FunnyChars(curdir,tmpstr,valid,0,tmpstr1);
778 /* ':' is a special case and is allowed only in certain cases */
779 test_FunnyChars(curdir,"file:000.ext",1,1,"check-1");
780 test_FunnyChars(curdir,"file000.e:t" ,1,1,"check-2");
781 test_FunnyChars(curdir,":file000.ext",0,1,"check-3");
782 test_FunnyChars(curdir,"file000:.ext",1,1,"check-4");
783 test_FunnyChars(curdir,"Long : File" ,1,0,"check-5");
784 test_FunnyChars(curdir,": Long File" ,0,0,"check-6");
785 test_FunnyChars(curdir,"Long File :" ,0,0,"check-7");
788 static void test_GetTempPathA(void)
790 UINT len, len_with_null;
793 lstrcpyA(buf, "foo");
794 len = GetTempPathA(MAX_PATH, buf);
795 ok(len <= MAX_PATH, "should fit into MAX_PATH");
796 ok(lstrcmpA(buf, "foo") != 0, "should touch the buffer");
797 ok(len == lstrlenA(buf), "returned length should be equal to the length of string");
798 ok(buf[len - 1] == '\\', "should add back slash");
800 len_with_null = lstrlenA(buf) + 1;
802 /* this one is different from unicode version: ANSI version doesn't
803 * touch the buffer, unicode version truncates the buffer to zero size
805 lstrcpyA(buf, "foo");
806 len = GetTempPathA(1, buf);
807 ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer");
808 /* win2000 adds excessive 0 when TMP variable does not specify full path,
809 * and buffer is not large enough to hold path with backslash.
811 /* FIXME: replace ok by xfail below when it's implemeted */
812 ok(len == len_with_null, "win2000 BUG: expected %u, got %u", len_with_null, len);
814 /* this one is different from unicode version: ANSI version doesn't
815 * touch the buffer, unicode version returns path without backslash
817 lstrcpyA(buf, "foo");
818 len = GetTempPathA(len_with_null - 1, buf);
819 ok(lstrcmpA(buf, "foo") == 0, "should not touch the buffer");
820 /* win2000 adds excessive 0 when TMP variable does not specify full path,
821 * and buffer is not large enough to hold path with backslash.
823 /* FIXME: replace ok by xfail below when it's implemeted */
824 ok(len == len_with_null, "win2000 BUG: expected %u, got %u", len_with_null, len);
826 lstrcpyA(buf, "foo");
827 len = GetTempPathA(len_with_null, buf);
828 ok(lstrcmpA(buf, "foo") != 0, "should touch the buffer");
829 ok(len == lstrlenA(buf), "returned length should be equal to the length of string");
830 ok(buf[len - 1] == '\\', "should add back slash");
831 ok(len == (len_with_null - 1), "should return length without terminating 0");
833 len = GetTempPathA(0, NULL);
834 /* win2000 adds excessive 0 when TMP variable does not specify full path,
835 * and buffer is not large enough to hold path with backslash.
837 /* FIXME: replace ok by xfail below when it's implemeted */
838 ok(len == len_with_null, "win2000 BUG: expected %u, got %u", len_with_null, len);
841 static void test_GetTempPathW(void)
843 UINT len, len_with_null;
845 WCHAR sample[MAX_PATH];
846 static const WCHAR fooW[] = {'f','o','o',0};
849 len = GetTempPathW(MAX_PATH, buf);
850 ok(len <= MAX_PATH, "should fit into MAX_PATH");
851 ok(lstrcmpW(buf, fooW) != 0, "should touch the buffer");
852 ok(len == lstrlenW(buf), "returned length should be equal to the length of string");
853 ok(buf[len - 1] == '\\', "should add back slash");
855 len_with_null = lstrlenW(buf) + 1;
856 lstrcpyW(sample, buf);
857 sample[len_with_null - 2] = 0;
859 /* this one is different from ANSI version: ANSI version doesn't
860 * touch the buffer, unicode version truncates the buffer to zero size
863 len = GetTempPathW(1, buf);
864 ok(lstrcmpW(buf, fooW) != 0, "should touch the buffer");
865 /* win2000 adds excessive 0 when TMP variable does not specify full path,
866 * and buffer is not large enough to hold path with backslash.
868 /* FIXME: replace ok by xfail below when it's implemeted */
869 ok(len == len_with_null, "win2000 BUG: expected %u, got %u", len_with_null, len);
870 ok(buf[0] == 0, "unicode version should truncate the buffer to zero size");
872 /* this one is different from ANSI version: ANSI version doesn't
873 * touch the buffer, unicode version returns path without backslash
876 len = GetTempPathW(len_with_null - 1, buf);
877 ok(lstrcmpW(buf, fooW) != 0, "should touch the buffer");
878 /* win2000 adds excessive 0 when TMP variable does not specify full path,
879 * and buffer is not large enough to hold path with backslash.
881 /* FIXME: replace ok by xfail below when it's implemeted */
882 ok(len == len_with_null, "win2000 BUG: expected %u, got %u", len_with_null, len);
883 /* win2000 fails here when TMP variable does not specify full path,
884 * but buffer is large enough to hold path without backslash.
886 if(len_with_null > 4) /* not the drive root: just do not add backslash */
887 /* FIXME: replace ok by xfail below when it's implemeted */
888 ok(lstrcmpW(sample, buf) == 0, "win2000 BUG: should return path without terminating back slash");
889 else /* drive root: truncate, to avoid returning ambiguous "X:" */
890 /* FIXME: replace ok by xfail below when it's implemeted */
891 ok(buf[0] == 0, "should truncate the buffer to zero size");
894 len = GetTempPathW(len_with_null, buf);
895 ok(lstrcmpW(buf, fooW) != 0, "should touch the buffer");
896 ok(len == lstrlenW(buf), "returned length should be equal to the length of string");
897 ok(buf[len - 1] == '\\', "should add back slash");
898 ok(len == (len_with_null - 1), "should return length without terminating 0");
900 len = GetTempPathW(0, NULL);
901 /* win2000 adds excessive 0 when TMP variable does not specify full path,
902 * and buffer is not large enough to hold path with backslash.
903 * Therefore simple (len == len_with_null) fails.
905 ok(len >= len_with_null, "should reserve space for terminating 0");
908 static void test_GetTempPath(void)
910 char save_TMP[MAX_PATH];
911 char windir[MAX_PATH];
914 GetEnvironmentVariableA("TMP", save_TMP, sizeof(save_TMP));
916 /* test default configuration */
917 trace("TMP=%s\n", save_TMP);
922 GetWindowsDirectoryA(windir, sizeof(windir));
923 SetEnvironmentVariableA("TMP", windir);
924 GetEnvironmentVariableA("TMP", buf, sizeof(buf));
925 trace("TMP=%s\n", buf);
930 GetWindowsDirectoryA(windir, sizeof(windir));
932 SetEnvironmentVariableA("TMP", windir);
933 GetEnvironmentVariableA("TMP", buf, sizeof(buf));
934 trace("TMP=%s\n", buf);
938 /* TMP=C: i.e. use current working directory of the specified drive */
939 GetWindowsDirectoryA(windir, sizeof(windir));
940 SetCurrentDirectoryA(windir);
942 SetEnvironmentVariableA("TMP", windir);
943 GetEnvironmentVariableA("TMP", buf, sizeof(buf));
944 trace("TMP=%s\n", buf);
948 SetEnvironmentVariableA("TMP", save_TMP);
953 CHAR origdir[MAX_PATH],curdir[MAX_PATH], curDrive, otherDrive;
954 pGetLongPathNameA = (void*)GetProcAddress( GetModuleHandleA("kernel32.dll"),
955 "GetLongPathNameA" );
956 test_InitPathA(curdir, &curDrive, &otherDrive);
957 test_CurrentDirectoryA(origdir,curdir);
958 test_PathNameA(curdir, curDrive, otherDrive);
959 test_CleanupPathA(origdir,curdir);