2325 lines
90 KiB
C
2325 lines
90 KiB
C
/*
|
|
* Path tests for kernelbase.dll
|
|
*
|
|
* Copyright 2017 Michael Müller
|
|
* Copyright 2018 Zhiyi Zhang
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <windef.h>
|
|
#include <winbase.h>
|
|
#include <stdlib.h>
|
|
#include <winerror.h>
|
|
#include <winnls.h>
|
|
#include <pathcch.h>
|
|
#include <strsafe.h>
|
|
|
|
#include "wine/test.h"
|
|
|
|
HRESULT (WINAPI *pPathAllocCanonicalize)(const WCHAR *path_in, DWORD flags, WCHAR **path_out);
|
|
HRESULT (WINAPI *pPathAllocCombine)(const WCHAR *path1, const WCHAR *path2, DWORD flags, WCHAR **out);
|
|
HRESULT (WINAPI *pPathCchAddBackslash)(WCHAR *out, SIZE_T size);
|
|
HRESULT (WINAPI *pPathCchAddBackslashEx)(WCHAR *out, SIZE_T size, WCHAR **endptr, SIZE_T *remaining);
|
|
HRESULT (WINAPI *pPathCchAddExtension)(WCHAR *path, SIZE_T size, const WCHAR *extension);
|
|
HRESULT (WINAPI *pPathCchAppend)(WCHAR *path1, SIZE_T size, const WCHAR *path2);
|
|
HRESULT (WINAPI *pPathCchAppendEx)(WCHAR *path1, SIZE_T size, const WCHAR *path2, DWORD flags);
|
|
HRESULT (WINAPI *pPathCchCanonicalize)(WCHAR *out, SIZE_T size, const WCHAR *in);
|
|
HRESULT (WINAPI *pPathCchCanonicalizeEx)(WCHAR *out, SIZE_T size, const WCHAR *in, DWORD flags);
|
|
HRESULT (WINAPI *pPathCchCombine)(WCHAR *out, SIZE_T size, const WCHAR *path1, const WCHAR *path2);
|
|
HRESULT (WINAPI *pPathCchCombineEx)(WCHAR *out, SIZE_T size, const WCHAR *path1, const WCHAR *path2, DWORD flags);
|
|
HRESULT (WINAPI *pPathCchFindExtension)(const WCHAR *path, SIZE_T size, const WCHAR **extension);
|
|
BOOL (WINAPI *pPathCchIsRoot)(const WCHAR *path);
|
|
HRESULT (WINAPI *pPathCchRemoveBackslash)(WCHAR *path, SIZE_T path_size);
|
|
HRESULT (WINAPI *pPathCchRemoveBackslashEx)(WCHAR *path, SIZE_T path_size, WCHAR **path_end, SIZE_T *free_size);
|
|
HRESULT (WINAPI *pPathCchRemoveExtension)(WCHAR *path, SIZE_T size);
|
|
HRESULT (WINAPI *pPathCchRemoveFileSpec)(WCHAR *path, SIZE_T size);
|
|
HRESULT (WINAPI *pPathCchRenameExtension)(WCHAR *path, SIZE_T size, const WCHAR *extension);
|
|
HRESULT (WINAPI *pPathCchSkipRoot)(const WCHAR *path, const WCHAR **root_end);
|
|
HRESULT (WINAPI *pPathCchStripPrefix)(WCHAR *path, SIZE_T size);
|
|
HRESULT (WINAPI *pPathCchStripToRoot)(WCHAR *path, SIZE_T size);
|
|
BOOL (WINAPI *pPathIsUNCEx)(const WCHAR *path, const WCHAR **server);
|
|
|
|
struct alloccanonicalize_test
|
|
{
|
|
const CHAR *path_in;
|
|
const CHAR *path_out;
|
|
DWORD flags;
|
|
HRESULT hr;
|
|
};
|
|
|
|
static const struct alloccanonicalize_test alloccanonicalize_tests[] =
|
|
{
|
|
/* Malformed path */
|
|
{"C:a", "C:a", 0, S_OK},
|
|
{"\\\\?\\C:", "C:\\", 0, S_OK},
|
|
{"\\\\?C:\\a", "\\\\?C:\\a", 0, S_OK},
|
|
{"\\\\?UNC\\a", "\\\\?UNC\\a", 0, S_OK},
|
|
{"\\\\?\\UNCa", "\\\\?\\UNCa", 0, S_OK},
|
|
{"\\\\?C:a", "\\\\?C:a", 0, S_OK},
|
|
|
|
/* No . */
|
|
{"", "\\", 0, S_OK},
|
|
{"C:", "C:", 0, S_OK},
|
|
{"C:\\", "C:\\", 0, S_OK},
|
|
{"\\\\?\\C:\\a", "C:\\a", 0, S_OK},
|
|
{"\\\\?\\UNC\\a", "\\\\a", 0, S_OK},
|
|
|
|
/* . */
|
|
{".", "\\", 0, S_OK},
|
|
{"..", "\\", 0, S_OK},
|
|
{"...", "\\", 0, S_OK},
|
|
{"*.", "*.", 0, S_OK},
|
|
{"*..", "*.", 0, S_OK},
|
|
{"*...", "*.", 0, S_OK},
|
|
{"a.", "a", 0, S_OK},
|
|
{"a.b", "a.b", 0, S_OK},
|
|
{"a\\.", "a", 0, S_OK},
|
|
{"a\\.\\b", "a\\b", 0, S_OK},
|
|
{"C:.", "C:\\", 0, S_OK},
|
|
{"C:\\.", "C:\\", 0, S_OK},
|
|
{"C:\\.\\", "C:\\", 0, S_OK},
|
|
{"C:\\a.", "C:\\a", 0, S_OK},
|
|
{"C:\\a\\.", "C:\\a", 0, S_OK},
|
|
{"C:\\a\\\\.", "C:\\a\\", 0, S_OK},
|
|
{"C:\\a\\\\\\.", "C:\\a\\\\", 0, S_OK},
|
|
{"\\.", "\\", 0, S_OK},
|
|
{"\\\\.", "\\\\", 0, S_OK},
|
|
{"\\\\.\\", "\\\\", 0, S_OK},
|
|
{"\\\\\\.", "\\\\", 0, S_OK},
|
|
{"\\\\.\\\\", "\\\\\\", 0, S_OK},
|
|
{"\\\\\\\\.", "\\\\\\", 0, S_OK},
|
|
{"\\?\\.", "\\?", 0, S_OK},
|
|
{"\\\\?\\.", "\\\\?", 0, S_OK},
|
|
{"\\192.168.1.1\\a", "\\192.168.1.1\\a", 0, S_OK},
|
|
{"\\a.168.1.1\\a", "\\a.168.1.1\\a", 0, S_OK},
|
|
{"\\\\192.168.1.1\\a", "\\\\192.168.1.1\\a", 0, S_OK},
|
|
{"\\\\a.168.1.1\\b", "\\\\a.168.1.1\\b", 0, S_OK},
|
|
{"\\\\?\\C:.", "C:\\", 0, S_OK},
|
|
{"\\\\?\\C:\\.", "C:\\", 0, S_OK},
|
|
{"\\\\?\\UNC\\.", "\\\\", 0, S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\.",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", 0, S_OK},
|
|
|
|
/* .. */
|
|
{"a..", "a", 0, S_OK},
|
|
{"a..b", "a..b", 0, S_OK},
|
|
{"a\\..", "\\", 0, S_OK},
|
|
{"a\\..\\", "\\", 0, S_OK},
|
|
{"a\\..\\b", "\\b", 0, S_OK},
|
|
{"C:..", "C:\\", 0, S_OK},
|
|
{"C:\\..", "C:\\", 0, S_OK},
|
|
{"C:\\\\..", "C:\\", 0, S_OK},
|
|
{"C:\\..\\", "C:\\", 0, S_OK},
|
|
{"C:\\a\\..", "C:\\", 0, S_OK},
|
|
{"C:\\a\\\\..", "C:\\a", 0, S_OK},
|
|
{"C:\\a\\\\\\..", "C:\\a\\", 0, S_OK},
|
|
{"C:\\a\\..\\b", "C:\\b", 0, S_OK},
|
|
{"C:\\a\\..\\\\b", "C:\\\\b", 0, S_OK},
|
|
{"\\..", "\\", 0, S_OK},
|
|
{"\\\\..", "\\\\", 0, S_OK},
|
|
{"\\\\\\..", "\\", 0, S_OK},
|
|
{"\\\\..\\", "\\\\", 0, S_OK},
|
|
{"\\\\\\..", "\\", 0, S_OK},
|
|
{"\\\\..\\\\", "\\\\\\", 0, S_OK},
|
|
{"\\\\\\\\..", "\\\\", 0, S_OK},
|
|
{"\\?\\..", "\\", 0, S_OK},
|
|
{"\\a\\..", "\\", 0, S_OK},
|
|
{"\\\\?\\..", "\\", 0, S_OK},
|
|
{"\\\\a\\..", "\\", 0, S_OK},
|
|
{"\\a\\..\\b", "\\b", 0, S_OK},
|
|
{"\\a\\b\\..", "\\a", 0, S_OK},
|
|
{"\\?\\UNC\\..", "\\?", 0, S_OK},
|
|
{"\\?\\C:\\..", "\\?", 0, S_OK},
|
|
{"\\\\?\\C:..", "C:\\", 0, S_OK},
|
|
{"\\\\?\\C:\\..", "C:\\", 0, S_OK},
|
|
{"\\\\?\\UNC\\..", "\\\\", 0, S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}..",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", 0, S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\..",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", 0, S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\..", "\\\\a", 0, S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a\\b\\..",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", 0, S_OK},
|
|
|
|
/* . and .. */
|
|
{"C:\\a\\.\\b\\..\\", "C:\\a\\", 0, S_OK},
|
|
{"\\a\\.\\b\\..\\", "\\a\\", 0, S_OK},
|
|
{"\\?\\a\\.\\b\\..\\", "\\?\\a\\", 0, S_OK},
|
|
{"\\\\.\\a\\.\\b\\..\\", "\\\\a\\", 0, S_OK},
|
|
{"\\\\?\\a\\.\\b\\..\\", "\\\\?\\a\\", 0, S_OK},
|
|
{"\\\\.\\..", "\\\\", 0, S_OK},
|
|
|
|
/* PATHCCH_ALLOW_LONG_PATHS */
|
|
/* Input path with prefix \\?\ and length of MAXPATH + 1, HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) = 0x800700ce */
|
|
{"\\\\?\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", NULL, 0, 0x800700ce},
|
|
/* Input path with prefix C:\ and length of MAXPATH + 1 */
|
|
{"C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", NULL, 0, 0x800700ce},
|
|
{"C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\\\\?\\C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", PATHCCH_ALLOW_LONG_PATHS, S_OK},
|
|
/* Input path with prefix C: and length of MAXPATH + 1 */
|
|
{"C:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\\\\?\\C:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", PATHCCH_ALLOW_LONG_PATHS, S_OK},
|
|
/* Input path with prefix C:\ and length of MAXPATH + 1 and with .. */
|
|
{"C:\\..\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", PATHCCH_ALLOW_LONG_PATHS, S_OK},
|
|
/* Input path with prefix \\?\ and length of MAXPATH + 1 */
|
|
{"\\\\?\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\\\\?\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", PATHCCH_ALLOW_LONG_PATHS, S_OK},
|
|
/* Input path with prefix \ and length of MAXPATH + 1 */
|
|
{"\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", PATHCCH_ALLOW_LONG_PATHS, S_OK},
|
|
/* Input path with length of MAXPATH with PATHCCH_ALLOW_LONG_PATHS disabled*/
|
|
{"C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 0, S_OK},
|
|
/* Input path with length of MAXPATH */
|
|
{"C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", PATHCCH_ALLOW_LONG_PATHS, S_OK},
|
|
|
|
/* Flags added after Windows 10 1709 */
|
|
/* PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS */
|
|
/* PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS without PATHCCH_ALLOW_LONG_PATHS */
|
|
{"", NULL, PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS, E_INVALIDARG},
|
|
/* Input path with prefix C:\ and length of MAXPATH + 1 and PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS */
|
|
{"C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
|
PATHCCH_ALLOW_LONG_PATHS | PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS, S_OK},
|
|
|
|
/* PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS */
|
|
/* PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS without PATHCCH_ALLOW_LONG_PATHS */
|
|
{"", NULL, PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS, E_INVALIDARG},
|
|
/* Both PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS and PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS */
|
|
{"", "\\", PATHCCH_ALLOW_LONG_PATHS | PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS | PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS,
|
|
E_INVALIDARG},
|
|
/* Input path with prefix C:\ and length of MAXPATH + 1 and PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS */
|
|
{"C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\\\\?\\C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
|
PATHCCH_ALLOW_LONG_PATHS | PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS, S_OK},
|
|
/* Input path with prefix C:\ and length of MAXPATH and PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS */
|
|
{"C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "C:\\aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
|
PATHCCH_ALLOW_LONG_PATHS | PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS, S_OK},
|
|
|
|
/* PATHCCH_DO_NOT_NORMALIZE_SEGMENTS */
|
|
/* No effect for spaces */
|
|
{"C:\\a \\", "C:\\a \\", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a\\ ", "C:\\a\\ ", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a ", "C:\\a ", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a ", "C:\\a ", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a. ", "C:\\a. ", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"\\a \\", "\\a \\", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"\\a\\ ", "\\a\\ ", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"\\\\a \\", "\\\\a \\", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"\\\\a\\ ", "\\\\a\\ ", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"\\\\?\\ ", "\\\\?\\ ", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
/* Keep trailing dot */
|
|
{"*..", "*..", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{".", "\\", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"..", "\\", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:.", "C:.", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:..", "C:..", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a\\.", "C:\\a", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a\\..", "C:\\", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a.", "C:\\a.", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
{"C:\\a..", "C:\\a..", PATHCCH_DO_NOT_NORMALIZE_SEGMENTS, S_OK},
|
|
|
|
/* PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH */
|
|
{"C:\\a\\", "\\\\?\\C:\\a\\", PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH, S_OK},
|
|
{"", NULL, PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH | PATHCCH_ALLOW_LONG_PATHS, E_INVALIDARG},
|
|
{"\\a\\", "\\a\\", PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH, S_OK},
|
|
{"\\\\?\\C:\\a\\", "\\\\?\\C:\\a\\", PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH, S_OK},
|
|
/* Implication of PATHCCH_DO_NOT_NORMALIZE_SEGMENTS by PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH */
|
|
{"\\a.", "\\a.", PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH, S_OK},
|
|
|
|
/* PATHCCH_ENSURE_TRAILING_SLASH */
|
|
{"\\", "\\", PATHCCH_ENSURE_TRAILING_SLASH, S_OK},
|
|
{"C:\\", "C:\\", PATHCCH_ENSURE_TRAILING_SLASH, S_OK},
|
|
{"C:\\a\\.", "C:\\a\\", PATHCCH_ENSURE_TRAILING_SLASH, S_OK},
|
|
{"C:\\a", "C:\\a\\", PATHCCH_ENSURE_TRAILING_SLASH, S_OK}
|
|
};
|
|
|
|
static void test_PathAllocCanonicalize(void)
|
|
{
|
|
WCHAR path_inW[1024], path_maxW[PATHCCH_MAX_CCH + 1];
|
|
WCHAR *path_outW;
|
|
CHAR path_outA[1024];
|
|
BOOL skip_new_flags = TRUE;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathAllocCanonicalize)
|
|
{
|
|
win_skip("PathAllocCanonicalize() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* No NULL check for path on Windows */
|
|
if (0)
|
|
{
|
|
hr = pPathAllocCanonicalize(NULL, 0, &path_outW);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathAllocCanonicalize(path_inW, 0, NULL);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* Test longest path */
|
|
for (i = 0; i < ARRAY_SIZE(path_maxW) - 1; i++) path_maxW[i] = 'a';
|
|
path_maxW[PATHCCH_MAX_CCH] = '\0';
|
|
path_outW = (WCHAR *)0xdeadbeef;
|
|
hr = pPathAllocCanonicalize(path_maxW, PATHCCH_ALLOW_LONG_PATHS, &path_outW);
|
|
ok(hr == HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), "expect hr %#x, got %#x\n",
|
|
HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), hr);
|
|
ok(path_outW == NULL, "expect path_outW null, got %p\n", path_outW);
|
|
|
|
path_maxW[PATHCCH_MAX_CCH - 1] = '\0';
|
|
hr = pPathAllocCanonicalize(path_maxW, PATHCCH_ALLOW_LONG_PATHS, &path_outW);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
LocalFree(path_outW);
|
|
|
|
/* Check if flags added after Windows 10 1709 are supported */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathAllocCanonicalize(path_inW, PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS, &path_outW);
|
|
if (hr == E_INVALIDARG) skip_new_flags = FALSE;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(alloccanonicalize_tests); i++)
|
|
{
|
|
const struct alloccanonicalize_test *t = alloccanonicalize_tests + i;
|
|
|
|
if (((PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS | PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS
|
|
| PATHCCH_DO_NOT_NORMALIZE_SEGMENTS | PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH
|
|
| PATHCCH_ENSURE_TRAILING_SLASH)
|
|
& t->flags)
|
|
&& skip_new_flags)
|
|
{
|
|
win_skip("Skip testing new flags added after Windows 10 1709\n");
|
|
return;
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path_in, -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathAllocCanonicalize(path_inW, t->flags, &path_outW);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path_in, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, t->path_out), "path \"%s\" expect output path \"%s\", got \"%s\"\n", t->path_in,
|
|
t->path_out, path_outA);
|
|
LocalFree(path_outW);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct combine_test
|
|
{
|
|
const CHAR *path1;
|
|
const CHAR *path2;
|
|
const CHAR *result;
|
|
};
|
|
|
|
static const struct combine_test combine_tests[] =
|
|
{
|
|
/* normal paths */
|
|
{"C:\\", "a", "C:\\a" },
|
|
{"C:\\b", "..\\a", "C:\\a" },
|
|
{"C:", "a", "C:\\a" },
|
|
{"C:\\", ".", "C:\\" },
|
|
{"C:\\", "..", "C:\\" },
|
|
{"C:\\a", "", "C:\\a" },
|
|
{"\\", "a", "\\a"},
|
|
{"\\a", "b", "\\a\\b" },
|
|
|
|
/* normal UNC paths */
|
|
{"\\\\192.168.1.1\\test", "a", "\\\\192.168.1.1\\test\\a" },
|
|
{"\\\\192.168.1.1\\test", "..", "\\\\192.168.1.1" },
|
|
{"\\\\", "a", "\\\\a"},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", "a",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a"},
|
|
|
|
/* NT paths */
|
|
{"\\\\?\\C:\\", "a", "C:\\a" },
|
|
{"\\\\?\\C:\\", "..", "C:\\" },
|
|
{"\\\\?\\C:", "a", "C:\\a"},
|
|
|
|
/* NT UNC path */
|
|
{"\\\\?\\UNC\\", "a", "\\\\a"},
|
|
{"\\\\?\\UNC\\192.168.1.1\\test", "a", "\\\\192.168.1.1\\test\\a" },
|
|
{"\\\\?\\UNC\\192.168.1.1\\test", "..", "\\\\192.168.1.1" },
|
|
|
|
/* Second path begins with a single backslash */
|
|
{"C:a\\b", "\\1", "C:\\1"},
|
|
{"C:\\a\\b", "\\1", "C:\\1"},
|
|
{"\\a\\b", "\\1", "\\1"},
|
|
{"\\\\a\\b", "\\1", "\\\\a\\b\\1"},
|
|
{"\\\\a\\b\\c", "\\1", "\\\\a\\b\\1"},
|
|
{"\\\\?\\UNC\\a", "\\1", "\\\\a\\1"},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a", "\\1",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\1"},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", "\\1",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\1"},
|
|
{"C:\\a\\b", "\\", "C:\\"},
|
|
|
|
/* Second path is fully qualified */
|
|
{"X:\\", "C:", "C:\\"},
|
|
{"X:\\", "C:\\", "C:\\"},
|
|
{"X:\\", "\\\\", "\\\\"},
|
|
{"X:\\", "\\\\?\\C:", "C:\\"},
|
|
{"X:\\", "\\\\?\\C:\\", "C:\\"},
|
|
{"X:\\", "\\\\?\\UNC\\", "\\\\"},
|
|
{"X:\\", "\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\"},
|
|
|
|
/* Canonicalization */
|
|
{"C:\\a", ".\\b", "C:\\a\\b"},
|
|
{"C:\\a", "..\\b", "C:\\b"},
|
|
|
|
/* Other */
|
|
{"", "", "\\"},
|
|
{"a", "b", "a\\b"}
|
|
};
|
|
|
|
static void test_PathAllocCombine(void)
|
|
{
|
|
WCHAR path1W[PATHCCH_MAX_CCH];
|
|
WCHAR path2W[PATHCCH_MAX_CCH];
|
|
WCHAR *resultW;
|
|
CHAR resultA[PATHCCH_MAX_CCH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathAllocCombine)
|
|
{
|
|
win_skip("PathAllocCombine() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
resultW = (WCHAR *)0xdeadbeef;
|
|
hr = pPathAllocCombine(NULL, NULL, 0, &resultW);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(resultW == NULL, "expect resultW null, got %p\n", resultW);
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "\\a", -1, path1W, ARRAY_SIZE(path1W));
|
|
hr = pPathAllocCombine(path1W, NULL, 0, &resultW);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
WideCharToMultiByte(CP_ACP, 0, resultW, -1, resultA, ARRAY_SIZE(resultA), NULL, NULL);
|
|
ok(!lstrcmpA(resultA, "\\a"), "expect \\a, got %s\n", resultA);
|
|
LocalFree(resultW);
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "\\b", -1, path2W, ARRAY_SIZE(path2W));
|
|
hr = pPathAllocCombine(NULL, path2W, 0, &resultW);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
WideCharToMultiByte(CP_ACP, 0, resultW, -1, resultA, ARRAY_SIZE(resultA), NULL, NULL);
|
|
ok(!lstrcmpA(resultA, "\\b"), "expect \\b, got %s\n", resultA);
|
|
LocalFree(resultW);
|
|
|
|
hr = pPathAllocCombine(path1W, path2W, 0, NULL);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(combine_tests); i++)
|
|
{
|
|
const struct combine_test *t = combine_tests + i;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path1, -1, path1W, ARRAY_SIZE(path1W));
|
|
MultiByteToWideChar(CP_ACP, 0, t->path2, -1, path2W, ARRAY_SIZE(path2W));
|
|
hr = pPathAllocCombine(path1W, path2W, 0, &resultW);
|
|
ok(hr == S_OK, "combine %s %s expect hr %#x, got %#x\n", t->path1, t->path2, S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, resultW, -1, resultA, ARRAY_SIZE(resultA), NULL, NULL);
|
|
ok(!lstrcmpA(resultA, t->result), "combine %s %s expect result %s, got %s\n", t->path1, t->path2, t->result,
|
|
resultA);
|
|
LocalFree(resultW);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_PathCchCombine(void)
|
|
{
|
|
WCHAR expected[PATHCCH_MAX_CCH] = {'C', ':', '\\', 'a', 0};
|
|
WCHAR p1[PATHCCH_MAX_CCH] = {'C', ':', '\\', 0};
|
|
WCHAR p2[PATHCCH_MAX_CCH] = {'a', 0};
|
|
WCHAR output[PATHCCH_MAX_CCH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchCombine)
|
|
{
|
|
win_skip("PathCchCombine() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
hr = pPathCchCombine(output, 5, NULL, NULL);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
|
|
hr = pPathCchCombine(NULL, 2, p1, p2);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombine(output, 0, p1, p2);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
ok(output[0] == 0xffff, "Expected output buffer to be unchanged\n");
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombine(output, 1, p1, p2);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "Expected STRSAFE_E_INSUFFICIENT_BUFFER, got %08x\n", hr);
|
|
ok(output[0] == 0, "Expected output buffer to contain NULL string\n");
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombine(output, 4, p1, p2);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "Expected STRSAFE_E_INSUFFICIENT_BUFFER, got %08x\n", hr);
|
|
ok(output[0] == 0x0, "Expected output buffer to contain NULL string\n");
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombine(output, 5, p1, p2);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
ok(!lstrcmpW(output, expected), "Combination of %s + %s returned %s, expected %s\n", wine_dbgstr_w(p1),
|
|
wine_dbgstr_w(p2), wine_dbgstr_w(output), wine_dbgstr_w(expected));
|
|
|
|
hr = pPathCchCombine(output, PATHCCH_MAX_CCH + 1, p1, p2);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
|
|
hr = pPathCchCombine(output, PATHCCH_MAX_CCH, p1, p2);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(combine_tests); i++)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, combine_tests[i].path1, -1, p1, ARRAY_SIZE(p1));
|
|
MultiByteToWideChar(CP_ACP, 0, combine_tests[i].path2, -1, p2, ARRAY_SIZE(p2));
|
|
MultiByteToWideChar(CP_ACP, 0, combine_tests[i].result, -1, expected, ARRAY_SIZE(expected));
|
|
|
|
hr = pPathCchCombine(output, ARRAY_SIZE(output), p1, p2);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
ok(!lstrcmpW(output, expected), "Combining %s with %s returned %s, expected %s\n", wine_dbgstr_w(p1),
|
|
wine_dbgstr_w(p2), wine_dbgstr_w(output), wine_dbgstr_w(expected));
|
|
}
|
|
}
|
|
|
|
static void test_PathCchCombineEx(void)
|
|
{
|
|
WCHAR expected[MAX_PATH] = {'C',':','\\','a',0};
|
|
WCHAR p1[MAX_PATH] = {'C',':','\\',0};
|
|
WCHAR p2[MAX_PATH] = {'a',0};
|
|
WCHAR output[MAX_PATH];
|
|
HRESULT hr;
|
|
int i;
|
|
|
|
if (!pPathCchCombineEx)
|
|
{
|
|
win_skip("PathCchCombineEx() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
output[0] = 0xff;
|
|
hr = pPathCchCombineEx(output, 5, NULL, NULL, 0);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
ok(output[0] == 0, "Expected output buffer to be empty\n");
|
|
|
|
output[0] = 0xff;
|
|
hr = pPathCchCombineEx(NULL, 2, p1, p2, 0);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
ok(output[0] == 0xff, "Expected output buffer to be unchanged\n");
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombineEx(output, 0, p1, p2, 0);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
ok(output[0] == 0xffff, "Expected output buffer to be unchanged\n");
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombineEx(output, 1, p1, p2, 0);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "Expected STRSAFE_E_INSUFFICIENT_BUFFER, got %08x\n", hr);
|
|
ok(output[0] == 0, "Expected output buffer to contain NULL string\n");
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombineEx(output, 4, p1, p2, 0);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "Expected STRSAFE_E_INSUFFICIENT_BUFFER, got %08x\n", hr);
|
|
ok(output[0] == 0x0, "Expected output buffer to contain NULL string\n");
|
|
|
|
output[0] = 0xff;
|
|
hr = pPathCchCombineEx(output, PATHCCH_MAX_CCH + 1, p1, p2, 0);
|
|
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
|
|
ok(output[0] == 0xff, "Expected output buffer to be 0xff\n");
|
|
|
|
hr = pPathCchCombineEx(output, PATHCCH_MAX_CCH, p1, p2, 0);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
memset(output, 0xff, sizeof(output));
|
|
hr = pPathCchCombineEx(output, 5, p1, p2, 0);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
ok(!lstrcmpW(output, expected),
|
|
"Combination of %s + %s returned %s, expected %s\n",
|
|
wine_dbgstr_w(p1), wine_dbgstr_w(p2), wine_dbgstr_w(output), wine_dbgstr_w(expected));
|
|
|
|
for (i = 0; i < ARRAY_SIZE(combine_tests); i++)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, combine_tests[i].path1, -1, p1, MAX_PATH);
|
|
MultiByteToWideChar(CP_ACP, 0, combine_tests[i].path2, -1, p2, MAX_PATH);
|
|
MultiByteToWideChar(CP_ACP, 0, combine_tests[i].result, -1, expected, MAX_PATH);
|
|
|
|
hr = pPathCchCombineEx(output, MAX_PATH, p1, p2, 0);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
ok(!lstrcmpW(output, expected), "Combining %s with %s returned %s, expected %s\n",
|
|
wine_dbgstr_w(p1), wine_dbgstr_w(p2), wine_dbgstr_w(output), wine_dbgstr_w(expected));
|
|
}
|
|
}
|
|
|
|
struct addbackslash_test
|
|
{
|
|
const char *path;
|
|
const char *result;
|
|
HRESULT hr;
|
|
SIZE_T size;
|
|
SIZE_T remaining;
|
|
};
|
|
|
|
static const struct addbackslash_test addbackslash_tests[] =
|
|
{
|
|
{ "C:", "C:\\", S_OK, MAX_PATH, MAX_PATH - 3 },
|
|
{ "a.txt", "a.txt\\", S_OK, MAX_PATH, MAX_PATH - 6 },
|
|
{ "a/b", "a/b\\", S_OK, MAX_PATH, MAX_PATH - 4 },
|
|
|
|
{ "C:\\", "C:\\", S_FALSE, MAX_PATH, MAX_PATH - 3 },
|
|
{ "C:\\", "C:\\", S_FALSE, 4, 1 },
|
|
|
|
{ "C:", "C:", STRSAFE_E_INSUFFICIENT_BUFFER, 2, 0 },
|
|
{ "C:", "C:", STRSAFE_E_INSUFFICIENT_BUFFER, 3, 1 },
|
|
{ "C:\\", "C:\\", STRSAFE_E_INSUFFICIENT_BUFFER, 2, 0 },
|
|
{ "C:\\", "C:\\", STRSAFE_E_INSUFFICIENT_BUFFER, 3, 0 },
|
|
{ "C:\\", "C:\\", STRSAFE_E_INSUFFICIENT_BUFFER, 0, 0 },
|
|
{ "C:", "C:", STRSAFE_E_INSUFFICIENT_BUFFER, 0, 0 },
|
|
};
|
|
|
|
static void test_PathCchAddBackslash(void)
|
|
{
|
|
WCHAR pathW[MAX_PATH];
|
|
unsigned int i;
|
|
HRESULT hr;
|
|
|
|
if (!pPathCchAddBackslash)
|
|
{
|
|
win_skip("PathCchAddBackslash() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
pathW[0] = 0;
|
|
hr = pPathCchAddBackslash(pathW, 0);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "Unexpected hr %#x.\n", hr);
|
|
ok(pathW[0] == 0, "Unexpected path.\n");
|
|
|
|
pathW[0] = 0;
|
|
hr = pPathCchAddBackslash(pathW, 1);
|
|
ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
|
|
ok(pathW[0] == 0, "Unexpected path.\n");
|
|
|
|
pathW[0] = 0;
|
|
hr = pPathCchAddBackslash(pathW, 2);
|
|
ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
|
|
ok(pathW[0] == 0, "Unexpected path.\n");
|
|
|
|
for (i = 0; i < ARRAY_SIZE(addbackslash_tests); i++)
|
|
{
|
|
const struct addbackslash_test *test = &addbackslash_tests[i];
|
|
char path[MAX_PATH];
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, test->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchAddBackslash(pathW, test->size);
|
|
ok(hr == test->hr, "%u: unexpected return value %#x.\n", i, hr);
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, path, ARRAY_SIZE(path), NULL, NULL);
|
|
ok(!strcmp(path, test->result), "%u: unexpected resulting path %s.\n", i, path);
|
|
}
|
|
}
|
|
|
|
static void test_PathCchAddBackslashEx(void)
|
|
{
|
|
WCHAR pathW[MAX_PATH];
|
|
SIZE_T remaining;
|
|
unsigned int i;
|
|
HRESULT hr;
|
|
WCHAR *ptrW;
|
|
|
|
if (!pPathCchAddBackslashEx)
|
|
{
|
|
win_skip("PathCchAddBackslashEx() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
pathW[0] = 0;
|
|
hr = pPathCchAddBackslashEx(pathW, 0, NULL, NULL);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "Unexpected hr %#x.\n", hr);
|
|
ok(pathW[0] == 0, "Unexpected path.\n");
|
|
|
|
pathW[0] = 0;
|
|
ptrW = (void *)0xdeadbeef;
|
|
remaining = 123;
|
|
hr = pPathCchAddBackslashEx(pathW, 1, &ptrW, &remaining);
|
|
ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
|
|
ok(pathW[0] == 0, "Unexpected path.\n");
|
|
ok(ptrW == pathW, "Unexpected endptr %p.\n", ptrW);
|
|
ok(remaining == 1, "Unexpected remaining size.\n");
|
|
|
|
pathW[0] = 0;
|
|
hr = pPathCchAddBackslashEx(pathW, 2, NULL, NULL);
|
|
ok(hr == S_FALSE, "Unexpected hr %#x.\n", hr);
|
|
ok(pathW[0] == 0, "Unexpected path.\n");
|
|
|
|
for (i = 0; i < ARRAY_SIZE(addbackslash_tests); i++)
|
|
{
|
|
const struct addbackslash_test *test = &addbackslash_tests[i];
|
|
char path[MAX_PATH];
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, test->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchAddBackslashEx(pathW, test->size, NULL, NULL);
|
|
ok(hr == test->hr, "%u: unexpected return value %#x.\n", i, hr);
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, path, ARRAY_SIZE(path), NULL, NULL);
|
|
ok(!strcmp(path, test->result), "%u: unexpected resulting path %s.\n", i, path);
|
|
|
|
ptrW = (void *)0xdeadbeef;
|
|
remaining = 123;
|
|
MultiByteToWideChar(CP_ACP, 0, test->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchAddBackslashEx(pathW, test->size, &ptrW, &remaining);
|
|
ok(hr == test->hr, "%u: unexpected return value %#x.\n", i, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ok(ptrW == (pathW + lstrlenW(pathW)), "%u: unexpected end pointer.\n", i);
|
|
ok(remaining == test->remaining, "%u: unexpected remaining buffer length.\n", i);
|
|
}
|
|
else
|
|
{
|
|
ok(ptrW == NULL, "%u: unexpecred end pointer.\n", i);
|
|
ok(remaining == 0, "%u: unexpected remaining buffer length.\n", i);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct addextension_test
|
|
{
|
|
const CHAR *path;
|
|
const CHAR *extension;
|
|
const CHAR *expected;
|
|
HRESULT hr;
|
|
};
|
|
|
|
static const struct addextension_test addextension_tests[] =
|
|
{
|
|
/* Normal */
|
|
{"", ".exe", ".exe", S_OK},
|
|
{"C:\\", "", "C:\\", S_OK},
|
|
{"C:", ".exe", "C:.exe", S_OK},
|
|
{"C:\\", ".exe", "C:\\.exe", S_OK},
|
|
{"\\", ".exe", "\\.exe", S_OK},
|
|
{"\\\\", ".exe", "\\\\.exe", S_OK},
|
|
{"\\\\?\\C:", ".exe", "\\\\?\\C:.exe", S_OK},
|
|
{"\\\\?\\C:\\", ".exe", "\\\\?\\C:\\.exe", S_OK},
|
|
{"\\\\?\\UNC\\", ".exe", "\\\\?\\UNC\\.exe", S_OK},
|
|
{"\\\\?\\UNC\\192.168.1.1\\", ".exe", "\\\\?\\UNC\\192.168.1.1\\.exe", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", ".exe",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\.exe", S_OK},
|
|
{"C:\\", "exe", "C:\\.exe", S_OK},
|
|
{"C:\\", ".", "C:\\", S_OK},
|
|
{"C:\\1.exe", ".txt", "C:\\1.exe", S_FALSE},
|
|
|
|
/* Extension contains invalid characters but valid for PathCchAddExtension */
|
|
{"C:\\", "./", "C:\\./", S_OK},
|
|
{"C:\\", ".?", "C:\\.?", S_OK},
|
|
{"C:\\", ".%", "C:\\.%", S_OK},
|
|
{"C:\\", ".*", "C:\\.*", S_OK},
|
|
{"C:\\", ".:", "C:\\.:", S_OK},
|
|
{"C:\\", ".|", "C:\\.|", S_OK},
|
|
{"C:\\", ".\"", "C:\\.\"", S_OK},
|
|
{"C:\\", ".<", "C:\\.<", S_OK},
|
|
{"C:\\", ".>", "C:\\.>", S_OK},
|
|
|
|
/* Invalid argument for extension */
|
|
{"C:\\", " exe", NULL, E_INVALIDARG},
|
|
{"C:\\", ". exe", NULL, E_INVALIDARG},
|
|
{"C:\\", " ", NULL, E_INVALIDARG},
|
|
{"C:\\", "\\", NULL, E_INVALIDARG},
|
|
{"C:\\", "..", NULL, E_INVALIDARG},
|
|
{"C:\\", ". ", NULL, E_INVALIDARG},
|
|
{"C:\\", ".\\", NULL, E_INVALIDARG},
|
|
{"C:\\", ".a.", NULL, E_INVALIDARG},
|
|
{"C:\\", ".a ", NULL, E_INVALIDARG},
|
|
{"C:\\", ".a\\", NULL, E_INVALIDARG},
|
|
{"C:\\1.exe", " ", NULL, E_INVALIDARG}
|
|
};
|
|
|
|
struct append_test
|
|
{
|
|
const CHAR *path1;
|
|
const CHAR *path2;
|
|
const CHAR *result;
|
|
};
|
|
|
|
static const struct append_test append_tests[] =
|
|
{
|
|
/* normal paths */
|
|
{"C:\\", "a", "C:\\a"},
|
|
{"C:\\b", "..\\a", "C:\\a"},
|
|
{"C:", "a", "C:\\a"},
|
|
{"C:\\", ".", "C:\\"},
|
|
{"C:\\", "..", "C:\\"},
|
|
{"C:\\a", "", "C:\\a"},
|
|
|
|
/* normal UNC paths */
|
|
{"\\\\192.168.1.1\\test", "a", "\\\\192.168.1.1\\test\\a"},
|
|
{"\\\\192.168.1.1\\test", "..", "\\\\192.168.1.1"},
|
|
{"\\a", "b", "\\a\\b"},
|
|
{"\\", "a", "\\a"},
|
|
{"\\\\", "a", "\\\\a"},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", "a",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a"},
|
|
|
|
/* NT paths */
|
|
{"\\\\?\\C:\\", "a", "C:\\a"},
|
|
{"\\\\?\\C:\\", "..", "C:\\"},
|
|
{"\\\\?\\C:", "a", "C:\\a"},
|
|
|
|
/* NT UNC path */
|
|
{"\\\\?\\UNC\\", "a", "\\\\a"},
|
|
{"\\\\?\\UNC\\192.168.1.1\\test", "a", "\\\\192.168.1.1\\test\\a"},
|
|
{"\\\\?\\UNC\\192.168.1.1\\test", "..", "\\\\192.168.1.1"},
|
|
|
|
/* Second path begins with a single backslash */
|
|
{"C:a\\b", "\\1", "C:a\\b\\1"},
|
|
{"C:\\a\\b", "\\1", "C:\\a\\b\\1"},
|
|
{"\\a\\b", "\\1", "\\a\\b\\1"},
|
|
{"\\\\a\\b", "\\1", "\\\\a\\b\\1"},
|
|
{"\\\\a\\b\\c", "\\1", "\\\\a\\b\\c\\1"},
|
|
{"\\\\?\\UNC\\a", "\\1", "\\\\a\\1"},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a", "\\1",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a\\1"},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", "\\1",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a\\1"},
|
|
{"C:\\a\\b", "\\", "C:\\a\\b"},
|
|
|
|
/* Second path is fully qualified */
|
|
{"X:\\", "C:", "C:\\"},
|
|
{"X:\\", "C:\\", "C:\\"},
|
|
{"X:\\", "\\\\", "\\\\"},
|
|
{"X:\\", "\\\\?\\C:", "C:\\"},
|
|
{"X:\\", "\\\\?\\C:\\", "C:\\"},
|
|
{"X:\\", "\\\\?\\UNC\\", "\\\\"},
|
|
{"X:\\", "\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\"},
|
|
|
|
/* Canonicalization */
|
|
{"C:\\a", ".\\b", "C:\\a\\b"},
|
|
{"C:\\a", "..\\b", "C:\\b"},
|
|
|
|
/* Other */
|
|
{"", "", "\\"},
|
|
{"a", "b", "a\\b"}
|
|
};
|
|
|
|
static void test_PathCchAppend(void)
|
|
{
|
|
WCHAR path1W[PATHCCH_MAX_CCH];
|
|
WCHAR path2W[PATHCCH_MAX_CCH];
|
|
CHAR path1A[PATHCCH_MAX_CCH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchAppend)
|
|
{
|
|
win_skip("PathCchAppend() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "\\a", -1, path1W, ARRAY_SIZE(path1W));
|
|
MultiByteToWideChar(CP_ACP, 0, "\\b", -1, path2W, ARRAY_SIZE(path2W));
|
|
hr = pPathCchAppend(NULL, PATHCCH_MAX_CCH, path2W);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchAppend(path1W, 0, path2W);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchAppend(path1W, PATHCCH_MAX_CCH + 1, path2W);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchAppend(path1W, PATHCCH_MAX_CCH, NULL);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
WideCharToMultiByte(CP_ACP, 0, path1W, -1, path1A, ARRAY_SIZE(path1A), NULL, NULL);
|
|
ok(!lstrcmpA(path1A, "\\a"), "expect \\a, got %s\n", path1A);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(append_tests); i++)
|
|
{
|
|
const struct append_test *t = append_tests + i;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path1, -1, path1W, ARRAY_SIZE(path1W));
|
|
MultiByteToWideChar(CP_ACP, 0, t->path2, -1, path2W, ARRAY_SIZE(path2W));
|
|
hr = pPathCchAppend(path1W, PATHCCH_MAX_CCH, path2W);
|
|
ok(hr == S_OK, "append \"%s\" \"%s\" expect hr %#x, got %#x\n", t->path1, t->path2, S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path1W, -1, path1A, ARRAY_SIZE(path1A), NULL, NULL);
|
|
ok(!lstrcmpA(path1A, t->result), "append \"%s\" \"%s\" expect result \"%s\", got \"%s\"\n", t->path1,
|
|
t->path2, t->result, path1A);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_PathCchAppendEx(void)
|
|
{
|
|
WCHAR path1W[PATHCCH_MAX_CCH];
|
|
WCHAR path2W[PATHCCH_MAX_CCH];
|
|
CHAR path1A[PATHCCH_MAX_CCH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchAppendEx)
|
|
{
|
|
win_skip("PathCchAppendEx() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "\\a", -1, path1W, ARRAY_SIZE(path1W));
|
|
MultiByteToWideChar(CP_ACP, 0, "\\b", -1, path2W, ARRAY_SIZE(path2W));
|
|
hr = pPathCchAppendEx(NULL, ARRAY_SIZE(path1W), path2W, 0);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchAppendEx(path1W, 0, path2W, 0);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(path1W[0] == '\\', "expect path1 unchanged\n");
|
|
|
|
hr = pPathCchAppendEx(path1W, PATHCCH_MAX_CCH + 1, path2W, 0);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(path1W[0] == '\\', "expect path1 unchanged\n");
|
|
|
|
hr = pPathCchAppendEx(path1W, ARRAY_SIZE(path1W), NULL, 0);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
WideCharToMultiByte(CP_ACP, 0, path1W, -1, path1A, ARRAY_SIZE(path1A), NULL, NULL);
|
|
ok(!lstrcmpA(path1A, "\\a"), "expect \\a, got %s\n", path1A);
|
|
|
|
hr = pPathCchAppendEx(path1W, PATHCCH_MAX_CCH, path2W, 0);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(append_tests); i++)
|
|
{
|
|
const struct append_test *t = append_tests + i;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path1, -1, path1W, ARRAY_SIZE(path1W));
|
|
MultiByteToWideChar(CP_ACP, 0, t->path2, -1, path2W, ARRAY_SIZE(path2W));
|
|
hr = pPathCchAppendEx(path1W, PATHCCH_MAX_CCH, path2W, 0);
|
|
ok(hr == S_OK, "append \"%s\" \"%s\" expect hr %#x, got %#x\n", t->path1, t->path2, S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path1W, -1, path1A, ARRAY_SIZE(path1A), NULL, NULL);
|
|
ok(!lstrcmpA(path1A, t->result), "append \"%s\" \"%s\" expect result \"%s\", got \"%s\"\n", t->path1,
|
|
t->path2, t->result, path1A);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_PathCchAddExtension(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH + 1];
|
|
CHAR pathA[PATHCCH_MAX_CCH + 1];
|
|
WCHAR extensionW[MAX_PATH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchAddExtension)
|
|
{
|
|
win_skip("PathCchAddExtension() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* Arguments check */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\", -1, pathW, ARRAY_SIZE(pathW));
|
|
MultiByteToWideChar(CP_ACP, 0, ".exe", -1, extensionW, ARRAY_SIZE(extensionW));
|
|
|
|
hr = pPathCchAddExtension(NULL, PATHCCH_MAX_CCH, extensionW);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchAddExtension(pathW, 0, extensionW);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchAddExtension(pathW, PATHCCH_MAX_CCH, NULL);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* Path length check */
|
|
hr = pPathCchAddExtension(pathW, ARRAY_SIZE("C:\\.exe") - 1, extensionW);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "expect result %#x, got %#x\n", STRSAFE_E_INSUFFICIENT_BUFFER, hr);
|
|
|
|
hr = pPathCchAddExtension(pathW, PATHCCH_MAX_CCH + 1, extensionW);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchAddExtension(pathW, PATHCCH_MAX_CCH, extensionW);
|
|
ok(hr == S_OK, "expect result %#x, got %#x\n", S_OK, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(addextension_tests); i++)
|
|
{
|
|
const struct addextension_test *t = addextension_tests + i;
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
MultiByteToWideChar(CP_ACP, 0, t->extension, -1, extensionW, ARRAY_SIZE(extensionW));
|
|
hr = pPathCchAddExtension(pathW, PATHCCH_MAX_CCH, extensionW);
|
|
ok(hr == t->hr, "path %s extension %s expect result %#x, got %#x\n", t->path, t->extension, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, pathA, ARRAY_SIZE(pathA), NULL, NULL);
|
|
ok(!lstrcmpA(pathA, t->expected), "path %s extension %s expect output path %s, got %s\n", t->path,
|
|
t->extension, t->expected, pathA);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_PathCchCanonicalize(void)
|
|
{
|
|
WCHAR path_inW[MAX_PATH], path_outW[MAX_PATH];
|
|
CHAR path_outA[MAX_PATH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchCanonicalize)
|
|
{
|
|
win_skip("PathCchCanonicalize() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* No NULL check for path pointers on Windows */
|
|
if (0)
|
|
{
|
|
hr = pPathCchCanonicalize(NULL, ARRAY_SIZE(path_outW), path_inW);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* MSDN says NULL path_in result in a backslash added to path_out, but the fact is that it would crash */
|
|
hr = pPathCchCanonicalize(path_outW, ARRAY_SIZE(path_outW), NULL);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
}
|
|
|
|
hr = pPathCchCanonicalize(path_outW, 0, path_inW);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* Test path length */
|
|
for (i = 0; i < MAX_PATH - 3; i++) path_inW[i] = 'a';
|
|
path_inW[MAX_PATH - 3] = '\0';
|
|
memset(path_outW, 0, sizeof(path_outW));
|
|
hr = pPathCchCanonicalize(path_outW, ARRAY_SIZE(path_outW), path_inW);
|
|
ok(hr == HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), "expect hr %#x, got %#x %s\n",
|
|
HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), hr, wine_dbgstr_w(path_outW));
|
|
ok(lstrlenW(path_outW) == 0, "got %d\n", lstrlenW(path_outW));
|
|
|
|
path_inW[0] = 'C';
|
|
path_inW[1] = ':';
|
|
path_inW[2] = '\\';
|
|
hr = pPathCchCanonicalize(path_outW, ARRAY_SIZE(path_outW), path_inW);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
|
|
path_inW[MAX_PATH - 4] = '\0';
|
|
hr = pPathCchCanonicalize(path_outW, ARRAY_SIZE(path_outW), path_inW);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
|
|
/* Insufficient buffer size handling */
|
|
hr = pPathCchCanonicalize(path_outW, 1, path_inW);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "expect hr %#x, got %#x\n", STRSAFE_E_INSUFFICIENT_BUFFER, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(alloccanonicalize_tests); i++)
|
|
{
|
|
const struct alloccanonicalize_test *t = alloccanonicalize_tests + i;
|
|
|
|
/* Skip testing X: path input, this case is different compared to PathAllocCanonicalize */
|
|
/* Skip test cases where a flag is used */
|
|
if (!lstrcmpA("C:", t->path_in) || t->flags) continue;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path_in, -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalize(path_outW, ARRAY_SIZE(path_outW), path_inW);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path_in, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, t->path_out), "path \"%s\" expect output path \"%s\", got \"%s\"\n", t->path_in,
|
|
t->path_out, path_outA);
|
|
}
|
|
}
|
|
|
|
/* X: path input */
|
|
/* Fill a \ at the end of X: if there is enough space */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalize(path_outW, ARRAY_SIZE(path_outW), path_inW);
|
|
ok(hr == S_OK, "path %s expect result %#x, got %#x\n", "C:", S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, "C:\\"), "path \"%s\" expect output path \"%s\", got \"%s\"\n", "C:", "C:\\",
|
|
path_outA);
|
|
}
|
|
|
|
/* Don't fill a \ at the end of X: if there isn't enough space */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalize(path_outW, 3, path_inW);
|
|
ok(hr == S_OK, "path %s expect result %#x, got %#x\n", "C:", S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, "C:"), "path \"%s\" expect output path \"%s\", got \"%s\"\n", "C:", "C:\\", path_outA);
|
|
}
|
|
|
|
/* Don't fill a \ at the end of X: if there is character following X: */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:a", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalize(path_outW, ARRAY_SIZE(path_outW), path_inW);
|
|
ok(hr == S_OK, "path %s expect result %#x, got %#x\n", "C:a", S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, "C:a"), "path \"%s\" expect output path \"%s\", got \"%s\"\n", "C:a", "C:a", path_outA);
|
|
}
|
|
}
|
|
|
|
static void test_PathCchCanonicalizeEx(void)
|
|
{
|
|
WCHAR path_inW[PATHCCH_MAX_CCH + 1], path_outW[PATHCCH_MAX_CCH];
|
|
CHAR path_outA[4096];
|
|
BOOL skip_new_flags = TRUE;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchCanonicalizeEx)
|
|
{
|
|
win_skip("PathCchCanonicalizeEx() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* No NULL check for path pointers on Windows */
|
|
if (0)
|
|
{
|
|
hr = pPathCchCanonicalizeEx(NULL, ARRAY_SIZE(path_outW), path_inW, 0);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* MSDN says NULL path_in result in a backslash added to path_out, but the fact is that it would crash */
|
|
hr = pPathCchCanonicalizeEx(path_outW, ARRAY_SIZE(path_outW), NULL, 0);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
}
|
|
|
|
path_outW[0] = 0xff;
|
|
hr = pPathCchCanonicalizeEx(path_outW, 0, path_inW, 0);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(path_outW[0] = 0xff, "expect path_outW unchanged\n");
|
|
|
|
/* Test path length */
|
|
for (i = 0; i < ARRAY_SIZE(path_inW) - 1; i++) path_inW[i] = 'a';
|
|
path_inW[PATHCCH_MAX_CCH] = '\0';
|
|
hr = pPathCchCanonicalizeEx(path_outW, ARRAY_SIZE(path_outW), path_inW, PATHCCH_ALLOW_LONG_PATHS);
|
|
ok(hr == HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), "expect hr %#x, got %#x\n",
|
|
HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), hr);
|
|
|
|
path_inW[PATHCCH_MAX_CCH - 1] = '\0';
|
|
hr = pPathCchCanonicalizeEx(path_outW, ARRAY_SIZE(path_outW), path_inW, PATHCCH_ALLOW_LONG_PATHS);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
|
|
hr = pPathCchCanonicalizeEx(path_outW, 1, path_inW, PATHCCH_ALLOW_LONG_PATHS);
|
|
ok(hr == HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), "expect hr %#x, got %#x\n",
|
|
HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), hr);
|
|
|
|
/* No root and path > MAX_PATH - 4, return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) */
|
|
path_inW[MAX_PATH - 3] = '\0';
|
|
hr = pPathCchCanonicalizeEx(path_outW, 1, path_inW, 0);
|
|
ok(hr == HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), "expect hr %#x, got %#x\n",
|
|
HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), hr);
|
|
|
|
/* Has root and path > MAX_PATH - 4 */
|
|
path_inW[0] = 'C';
|
|
path_inW[1] = ':';
|
|
path_inW[2] = '\\';
|
|
hr = pPathCchCanonicalizeEx(path_outW, 1, path_inW, 0);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "expect hr %#x, got %#x\n", STRSAFE_E_INSUFFICIENT_BUFFER, hr);
|
|
|
|
path_inW[0] = '\\';
|
|
path_inW[1] = path_inW[2] = 'a';
|
|
hr = pPathCchCanonicalizeEx(path_outW, 1, path_inW, 0);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "expect hr %#x, got %#x\n", STRSAFE_E_INSUFFICIENT_BUFFER, hr);
|
|
|
|
path_inW[0] = path_inW[1] = '\\';
|
|
path_inW[2] = 'a';
|
|
hr = pPathCchCanonicalizeEx(path_outW, 1, path_inW, 0);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "expect hr %#x, got %#x\n", STRSAFE_E_INSUFFICIENT_BUFFER, hr);
|
|
|
|
/* path <= MAX_PATH - 4 */
|
|
path_inW[0] = path_inW[1] = path_inW[2] = 'a';
|
|
path_inW[MAX_PATH - 4] = '\0';
|
|
hr = pPathCchCanonicalizeEx(path_outW, 1, path_inW, 0);
|
|
ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "expect hr %#x, got %#x\n", STRSAFE_E_INSUFFICIENT_BUFFER, hr);
|
|
|
|
/* Check if flags added after Windows 10 1709 are supported */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalizeEx(path_outW, ARRAY_SIZE(path_outW), path_inW, PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS);
|
|
if (hr == E_INVALIDARG) skip_new_flags = FALSE;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(alloccanonicalize_tests); i++)
|
|
{
|
|
const struct alloccanonicalize_test *t = alloccanonicalize_tests + i;
|
|
|
|
/* Skip testing X: path input, this case is different compared to PathAllocCanonicalize */
|
|
if (!lstrcmpA("C:", t->path_in)) continue;
|
|
|
|
if (((PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS | PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS
|
|
| PATHCCH_DO_NOT_NORMALIZE_SEGMENTS | PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH
|
|
| PATHCCH_ENSURE_TRAILING_SLASH)
|
|
& t->flags)
|
|
&& skip_new_flags)
|
|
{
|
|
win_skip("Skip testing new flags added after Windows 10 1709\n");
|
|
return;
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path_in, -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalizeEx(path_outW, ARRAY_SIZE(path_outW), path_inW, t->flags);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path_in, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, t->path_out), "path \"%s\" expect output path \"%s\", got \"%s\"\n", t->path_in,
|
|
t->path_out, path_outA);
|
|
}
|
|
}
|
|
|
|
/* X: path input */
|
|
/* Fill a \ at the end of X: if there is enough space */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalizeEx(path_outW, ARRAY_SIZE(path_outW), path_inW, 0);
|
|
ok(hr == S_OK, "path %s expect result %#x, got %#x\n", "C:", S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, "C:\\"), "path \"%s\" expect output path \"%s\", got \"%s\"\n", "C:", "C:\\",
|
|
path_outA);
|
|
}
|
|
|
|
/* Don't fill a \ at the end of X: if there isn't enough space */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalizeEx(path_outW, 3, path_inW, 0);
|
|
ok(hr == S_OK, "path %s expect result %#x, got %#x\n", "C:", S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, "C:"), "path \"%s\" expect output path \"%s\", got \"%s\"\n", "C:", "C:\\", path_outA);
|
|
}
|
|
|
|
/* Don't fill a \ at the end of X: if there is character following X: */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:a", -1, path_inW, ARRAY_SIZE(path_inW));
|
|
hr = pPathCchCanonicalizeEx(path_outW, ARRAY_SIZE(path_outW), path_inW, 0);
|
|
ok(hr == S_OK, "path %s expect result %#x, got %#x\n", "C:a", S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, path_outW, -1, path_outA, ARRAY_SIZE(path_outA), NULL, NULL);
|
|
ok(!lstrcmpA(path_outA, "C:a"), "path \"%s\" expect output path \"%s\", got \"%s\"\n", "C:a", "C:a", path_outA);
|
|
}
|
|
}
|
|
|
|
struct findextension_test
|
|
{
|
|
const CHAR *path;
|
|
INT extension_offset;
|
|
};
|
|
|
|
static const struct findextension_test findextension_tests[] =
|
|
{
|
|
/* Normal */
|
|
{"1.exe", 1},
|
|
{"C:1.exe", 3},
|
|
{"C:\\1.exe", 4},
|
|
{"\\1.exe", 2},
|
|
{"\\\\1.exe", 3},
|
|
{"\\\\?\\C:1.exe", 7},
|
|
{"\\\\?\\C:\\1.exe", 8},
|
|
{"\\\\?\\UNC\\1.exe", 9},
|
|
{"\\\\?\\UNC\\192.168.1.1\\1.exe", 21},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\1.exe", 50},
|
|
|
|
/* Contains forward slash */
|
|
{"C:\\a/1.exe", 6},
|
|
{"/1.exe", 2},
|
|
{"//1.exe", 3},
|
|
{"C:\\a/b/1.exe", 8},
|
|
{"/a/1.exe", 4},
|
|
{"/a/1.exe", 4},
|
|
|
|
/* Malformed */
|
|
{"", 0},
|
|
{" ", 1},
|
|
{".", 0},
|
|
{"..", 1},
|
|
{"a", 1},
|
|
{"a.", 1},
|
|
{".a.b.", 4},
|
|
{"a. ", 3},
|
|
{"a.\\", 3},
|
|
{"\\\\?\\UNC\\192.168.1.1", 17},
|
|
{"\\\\?\\UNC\\192.168.1.1\\", 20},
|
|
{"\\\\?\\UNC\\192.168.1.1\\a", 21}
|
|
};
|
|
|
|
static void test_PathCchFindExtension(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH + 1] = {0};
|
|
const WCHAR *extension;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchFindExtension)
|
|
{
|
|
win_skip("PathCchFindExtension() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* Arguments check */
|
|
extension = (const WCHAR *)0xdeadbeef;
|
|
hr = pPathCchFindExtension(NULL, PATHCCH_MAX_CCH, &extension);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(extension == NULL, "Expect extension null, got %p\n", extension);
|
|
|
|
extension = (const WCHAR *)0xdeadbeef;
|
|
hr = pPathCchFindExtension(pathW, 0, &extension);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(extension == NULL, "Expect extension null, got %p\n", extension);
|
|
|
|
/* Crashed on Windows */
|
|
if (0)
|
|
{
|
|
hr = pPathCchFindExtension(pathW, PATHCCH_MAX_CCH, NULL);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
}
|
|
|
|
/* Path length check */
|
|
/* size == PATHCCH_MAX_CCH + 1 */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\1.exe", -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchFindExtension(pathW, PATHCCH_MAX_CCH + 1, &extension);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* Size == path length + 1*/
|
|
hr = pPathCchFindExtension(pathW, ARRAY_SIZE("C:\\1.exe"), &extension);
|
|
ok(hr == S_OK, "expect result %#x, got %#x\n", S_OK, hr);
|
|
ok(*extension == '.', "wrong extension value\n");
|
|
|
|
/* Size < path length + 1 */
|
|
extension = (const WCHAR *)0xdeadbeef;
|
|
hr = pPathCchFindExtension(pathW, ARRAY_SIZE("C:\\1.exe") - 1, &extension);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(extension == NULL, "Expect extension null, got %p\n", extension);
|
|
|
|
/* Size == PATHCCH_MAX_CCH */
|
|
hr = pPathCchFindExtension(pathW, PATHCCH_MAX_CCH, &extension);
|
|
ok(hr == S_OK, "expect result %#x, got %#x\n", S_OK, hr);
|
|
|
|
/* Path length + 1 > PATHCCH_MAX_CCH */
|
|
for (i = 0; i < ARRAY_SIZE(pathW) - 1; i++) pathW[i] = 'a';
|
|
pathW[PATHCCH_MAX_CCH] = 0;
|
|
hr = pPathCchFindExtension(pathW, PATHCCH_MAX_CCH, &extension);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* Path length + 1 == PATHCCH_MAX_CCH */
|
|
pathW[PATHCCH_MAX_CCH - 1] = 0;
|
|
hr = pPathCchFindExtension(pathW, PATHCCH_MAX_CCH, &extension);
|
|
ok(hr == S_OK, "expect result %#x, got %#x\n", S_OK, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(findextension_tests); i++)
|
|
{
|
|
const struct findextension_test *t = findextension_tests + i;
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchFindExtension(pathW, PATHCCH_MAX_CCH, &extension);
|
|
ok(hr == S_OK, "path %s expect result %#x, got %#x\n", t->path, S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
ok(extension - pathW == t->extension_offset, "path %s expect extension offset %d, got %ld\n", t->path,
|
|
t->extension_offset, (UINT_PTR)(extension - pathW));
|
|
}
|
|
}
|
|
|
|
struct isroot_test
|
|
{
|
|
const CHAR *path;
|
|
BOOL ret;
|
|
};
|
|
|
|
static const struct isroot_test isroot_tests[] =
|
|
{
|
|
{"", FALSE},
|
|
{"a", FALSE},
|
|
{"C:", FALSE},
|
|
{"C:\\", TRUE},
|
|
{"C:\\a", FALSE},
|
|
{"\\\\?\\C:\\", TRUE},
|
|
{"\\\\?\\C:", FALSE},
|
|
{"\\\\?\\C:\\a", FALSE},
|
|
{"\\", TRUE},
|
|
{"\\a\\", FALSE},
|
|
{"\\a\\b", FALSE},
|
|
{"\\\\", TRUE},
|
|
{"\\\\a", TRUE},
|
|
{"\\\\a\\", FALSE},
|
|
{"\\\\a\\b", TRUE},
|
|
{"\\\\a\\b\\", FALSE},
|
|
{"\\\\a\\b\\c", FALSE},
|
|
{"\\\\?\\UNC\\", TRUE},
|
|
{"\\\\?\\UNC\\a", TRUE},
|
|
{"\\\\?\\UNC\\a\\", FALSE},
|
|
{"\\\\?\\UNC\\a\\b", TRUE},
|
|
{"\\\\?\\UNC\\a\\b\\", FALSE},
|
|
{"\\\\?\\UNC\\a\\b\\c", FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", TRUE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", FALSE},
|
|
{"..\\a", FALSE},
|
|
|
|
/* Wrong MSDN examples */
|
|
{"\\a", FALSE},
|
|
{"X:", FALSE},
|
|
{"\\server", FALSE}
|
|
};
|
|
|
|
static void test_PathCchIsRoot(void)
|
|
{
|
|
WCHAR pathW[MAX_PATH];
|
|
BOOL ret;
|
|
INT i;
|
|
|
|
if (!pPathCchIsRoot)
|
|
{
|
|
win_skip("PathCchIsRoot() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
ret = pPathCchIsRoot(NULL);
|
|
ok(ret == FALSE, "expect return FALSE\n");
|
|
|
|
for (i = 0; i < ARRAY_SIZE(isroot_tests); i++)
|
|
{
|
|
const struct isroot_test *t = isroot_tests + i;
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
ret = pPathCchIsRoot(pathW);
|
|
ok(ret == t->ret, "path %s expect return %d, got %d\n", t->path, t->ret, ret);
|
|
}
|
|
}
|
|
|
|
struct removebackslashex_test
|
|
{
|
|
const CHAR *path_in;
|
|
const CHAR *path_out;
|
|
int end_offset;
|
|
SIZE_T free_size;
|
|
HRESULT hr;
|
|
};
|
|
|
|
static const struct removebackslashex_test removebackslashex_tests [] =
|
|
{
|
|
{"", "", 0, 1, S_FALSE},
|
|
{"C", "C", 1, 1, S_FALSE},
|
|
{"C\\", "C", 1, 2, S_OK},
|
|
{"C:", "C:", 2, 1, S_FALSE},
|
|
{"C:\\", "C:\\", 2, 2, S_FALSE},
|
|
{"C:\\\\", "C:\\", 3, 2, S_OK},
|
|
{"C:\\a\\", "C:\\a", 4, 2, S_OK},
|
|
{"C:\\a\\\\", "C:\\a\\", 5, 2, S_OK},
|
|
{"\\", "\\", 0, 2, S_FALSE},
|
|
{"\\\\", "\\\\", 1, 2, S_FALSE},
|
|
{"\\?\\", "\\?", 2, 2, S_OK},
|
|
{"\\?\\\\", "\\?\\", 3, 2, S_OK},
|
|
{"\\a\\", "\\a", 2, 2, S_OK},
|
|
{"\\a\\\\", "\\a\\", 3, 2, S_OK},
|
|
{"\\\\a\\", "\\\\a", 3, 2, S_OK},
|
|
{"\\\\a\\b\\", "\\\\a\\b", 5, 2, S_OK},
|
|
{"\\\\a\\\\", "\\\\a\\", 4, 2, S_OK},
|
|
{"\\\\?\\", "\\\\?", 3, 2, S_OK},
|
|
{"\\\\?\\\\", "\\\\?\\", 4, 2, S_OK},
|
|
{"\\\\?\\C:", "\\\\?\\C:", 6, 1, S_FALSE},
|
|
{"\\\\?\\C:\\", "\\\\?\\C:\\", 6, 2, S_FALSE},
|
|
{"\\?\\UNC\\", "\\?\\UNC", 6, 2, S_OK},
|
|
{"\\\\?\\UNC", "\\\\?\\UNC", 7, 1, S_FALSE},
|
|
{"\\\\?\\UNC\\", "\\\\?\\UNC\\", 7, 2, S_FALSE},
|
|
{"\\\\?\\UNC\\a", "\\\\?\\UNC\\a", 9, 1, S_FALSE},
|
|
{"\\\\?\\UNC\\a\\", "\\\\?\\UNC\\a", 9, 2, S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\", "\\\\?\\UNC\\a\\b", 11, 2, S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", 48, 1, S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", 48, 2, S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", 50, 1, S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", 50, 2, S_OK}
|
|
};
|
|
|
|
static void test_PathCchRemoveBackslash(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH];
|
|
CHAR pathA[PATHCCH_MAX_CCH];
|
|
HRESULT hr;
|
|
SIZE_T path_size;
|
|
INT i;
|
|
|
|
if (!pPathCchRemoveBackslash)
|
|
{
|
|
win_skip("PathCchRemoveBackslash() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* No NULL check for path on Windows */
|
|
if (0)
|
|
{
|
|
hr = pPathCchRemoveBackslash(NULL, PATHCCH_MAX_CCH);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\a\\", -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchRemoveBackslash(pathW, 0);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRemoveBackslash(pathW, PATHCCH_MAX_CCH + 1);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
|
|
hr = pPathCchRemoveBackslash(pathW, PATHCCH_MAX_CCH);
|
|
ok(hr == S_FALSE, "expect hr %#x, got %#x\n", S_FALSE, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(removebackslashex_tests); i++)
|
|
{
|
|
const struct removebackslashex_test *t = removebackslashex_tests + i;
|
|
path_size = MultiByteToWideChar(CP_ACP, 0, t->path_in, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchRemoveBackslash(pathW, path_size);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path_in, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, pathA, ARRAY_SIZE(pathA), NULL, NULL);
|
|
ok(!lstrcmpA(pathA, t->path_out), "path %s expect output path %s, got %s\n", t->path_in, t->path_out,
|
|
pathA);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_PathCchRemoveBackslashEx(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH];
|
|
CHAR pathA[PATHCCH_MAX_CCH];
|
|
WCHAR *path_end;
|
|
SIZE_T path_size, free_size;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchRemoveBackslashEx)
|
|
{
|
|
win_skip("PathCchRemoveBackslashEx() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* No NULL check for path on Windows */
|
|
if (0)
|
|
{
|
|
hr = pPathCchRemoveBackslashEx(NULL, 0, &path_end, &path_size);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
}
|
|
|
|
path_size = MultiByteToWideChar(CP_ACP, 0, "C:\\a\\", -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchRemoveBackslashEx(pathW, 0, &path_end, &path_size);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
free_size = 0xdeadbeef;
|
|
hr = pPathCchRemoveBackslashEx(pathW, path_size, NULL, &free_size);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(free_size == 0, "expect %d, got %lu\n", 0, free_size);
|
|
|
|
path_end = (WCHAR *)0xdeadbeef;
|
|
hr = pPathCchRemoveBackslashEx(pathW, path_size, &path_end, NULL);
|
|
ok(hr == E_INVALIDARG, "expect hr %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(path_end == NULL, "expect null, got %p\n", path_end);
|
|
|
|
hr = pPathCchRemoveBackslashEx(pathW, PATHCCH_MAX_CCH + 1, &path_end, &free_size);
|
|
ok(hr == S_OK, "expect hr %#x, got %#x\n", S_OK, hr);
|
|
|
|
hr = pPathCchRemoveBackslashEx(pathW, PATHCCH_MAX_CCH, &path_end, &free_size);
|
|
ok(hr == S_FALSE, "expect hr %#x, got %#x\n", S_FALSE, hr);
|
|
|
|
/* Size < original path length + 1, don't read beyond size */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\a", -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchRemoveBackslashEx(pathW, ARRAY_SIZE("C:\\a") - 1, &path_end, &free_size);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(removebackslashex_tests); i++)
|
|
{
|
|
const struct removebackslashex_test *t = removebackslashex_tests + i;
|
|
path_size = MultiByteToWideChar(CP_ACP, 0, t->path_in, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchRemoveBackslashEx(pathW, path_size, &path_end, &free_size);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path_in, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ok(path_end - pathW == t->end_offset, "path %s expect end offset %d, got %ld\n", t->path_in, t->end_offset,
|
|
(INT_PTR)(path_end - pathW));
|
|
ok(free_size == t->free_size, "path %s expect free size %lu, got %lu\n", t->path_in, t->free_size, free_size);
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, pathA, ARRAY_SIZE(pathA), NULL, NULL);
|
|
ok(!lstrcmpA(pathA, t->path_out), "path %s expect output path %s, got %s\n", t->path_in, t->path_out,
|
|
pathA);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct removeextension_test
|
|
{
|
|
const CHAR *path;
|
|
const CHAR *expected;
|
|
HRESULT hr;
|
|
};
|
|
|
|
static const struct removeextension_test removeextension_tests[] =
|
|
{
|
|
{"1.exe", "1", S_OK},
|
|
{"C:1.exe", "C:1", S_OK},
|
|
{"C:\\1.exe", "C:\\1", S_OK},
|
|
{"\\1.exe", "\\1", S_OK},
|
|
{"\\\\1.exe", "\\\\1", S_OK},
|
|
{"\\\\?\\C:1.exe", "\\\\?\\C:1", S_OK},
|
|
{"\\\\?\\C:\\1.exe", "\\\\?\\C:\\1", S_OK},
|
|
{"\\\\?\\UNC\\1.exe", "\\\\?\\UNC\\1", S_OK},
|
|
{"\\\\?\\UNC\\192.168.1.1\\1.exe", "\\\\?\\UNC\\192.168.1.1\\1", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\1.exe",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\1", S_OK},
|
|
|
|
/* Malformed */
|
|
{"", "", S_FALSE},
|
|
{" ", " ", S_FALSE},
|
|
{".", "", S_OK},
|
|
{"..", ".", S_OK},
|
|
{"a", "a", S_FALSE},
|
|
{"a.", "a", S_OK},
|
|
{".a.b.", ".a.b", S_OK},
|
|
{"a. ", "a. ", S_FALSE},
|
|
{"a.\\", "a.\\", S_FALSE},
|
|
{"\\\\?\\UNC\\192.168.1.1", "\\\\?\\UNC\\192.168.1", S_OK},
|
|
{"\\\\?\\UNC\\192.168.1.1\\", "\\\\?\\UNC\\192.168.1.1\\", S_FALSE},
|
|
{"\\\\?\\UNC\\192.168.1.1\\a", "\\\\?\\UNC\\192.168.1.1\\a", S_FALSE}
|
|
};
|
|
|
|
static void test_PathCchRemoveExtension(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH] = {0};
|
|
CHAR pathA[PATHCCH_MAX_CCH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchRemoveExtension)
|
|
{
|
|
win_skip("PathCchRemoveExtension() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* Arguments check */
|
|
hr = pPathCchRemoveExtension(NULL, PATHCCH_MAX_CCH);
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRemoveExtension(pathW, 0);
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRemoveExtension(pathW, PATHCCH_MAX_CCH + 1);
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRemoveExtension(pathW, PATHCCH_MAX_CCH);
|
|
ok(hr == S_FALSE, "expect %#x, got %#x\n", S_FALSE, hr);
|
|
|
|
/* Size < original path length + 1 */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\1.exe", -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchRemoveExtension(pathW, ARRAY_SIZE("C:\\1.exe") - 1);
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(removeextension_tests); i++)
|
|
{
|
|
const struct removeextension_test *t = removeextension_tests + i;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchRemoveExtension(pathW, ARRAY_SIZE(pathW));
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, pathA, ARRAY_SIZE(pathA), NULL, NULL);
|
|
ok(!lstrcmpA(pathA, t->expected), "path %s expect stripped path %s, got %s\n", t->path, t->expected, pathA);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct removefilespec_test
|
|
{
|
|
const CHAR *path;
|
|
const CHAR *expected;
|
|
HRESULT hr;
|
|
SIZE_T size;
|
|
};
|
|
|
|
static const struct removefilespec_test removefilespec_tests[] =
|
|
{
|
|
{"", "", S_FALSE},
|
|
{"a", "", S_OK},
|
|
{"a\\", "a", S_OK},
|
|
{"a\\b", "a", S_OK},
|
|
|
|
{"\\", "\\", S_FALSE},
|
|
{"\\a", "\\", S_OK},
|
|
{"\\a\\", "\\a", S_OK},
|
|
{"\\a\\b", "\\a", S_OK},
|
|
|
|
{"\\\\", "\\\\", S_FALSE},
|
|
{"\\\\a", "\\\\a", S_FALSE},
|
|
{"\\\\a\\", "\\\\a", S_OK},
|
|
{"\\\\a\\b", "\\\\a\\b", S_FALSE},
|
|
{"\\\\a\\b\\", "\\\\a\\b", S_OK},
|
|
{"\\\\a\\b\\c", "\\\\a\\b", S_OK},
|
|
|
|
{"C:", "C:", S_FALSE},
|
|
{"C:a", "C:", S_OK},
|
|
{"C:a\\", "C:a", S_OK},
|
|
{"C:a\\b", "C:a", S_OK},
|
|
|
|
{"C:\\", "C:\\", S_FALSE},
|
|
{"C:\\a", "C:\\", S_OK},
|
|
{"C:\\a\\", "C:\\a", S_OK},
|
|
{"C:\\a\\b", "C:\\a", S_OK},
|
|
|
|
{"\\\\?\\", "\\\\?", S_OK},
|
|
{"\\\\?\\a", "\\\\?", S_OK},
|
|
{"\\\\?\\a\\", "\\\\?\\a", S_OK},
|
|
{"\\\\?\\a\\b", "\\\\?\\a", S_OK},
|
|
|
|
{"\\\\?\\C:", "\\\\?\\C:", S_FALSE},
|
|
{"\\\\?\\C:a", "\\\\?\\C:", S_OK},
|
|
{"\\\\?\\C:a\\", "\\\\?\\C:a", S_OK},
|
|
{"\\\\?\\C:a\\b", "\\\\?\\C:a", S_OK},
|
|
|
|
{"\\\\?\\C:\\", "\\\\?\\C:\\", S_FALSE},
|
|
{"\\\\?\\C:\\a", "\\\\?\\C:\\", S_OK},
|
|
{"\\\\?\\C:\\a\\", "\\\\?\\C:\\a", S_OK},
|
|
{"\\\\?\\C:\\a\\b", "\\\\?\\C:\\a", S_OK},
|
|
|
|
{"\\\\?\\UNC\\", "\\\\?\\UNC\\", S_FALSE},
|
|
{"\\\\?\\UNC\\a", "\\\\?\\UNC\\a", S_FALSE},
|
|
{"\\\\?\\UNC\\a\\", "\\\\?\\UNC\\a", S_OK},
|
|
{"\\\\?\\UNC\\a\\b", "\\\\?\\UNC\\a\\b", S_FALSE},
|
|
{"\\\\?\\UNC\\a\\b\\", "\\\\?\\UNC\\a\\b", S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\c", "\\\\?\\UNC\\a\\b", S_OK},
|
|
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a\\b",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a", S_OK},
|
|
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a\\b",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", S_OK},
|
|
|
|
/* Size tests */
|
|
{"C:\\a", NULL, E_INVALIDARG, PATHCCH_MAX_CCH + 1},
|
|
{"C:\\a", "C:\\", S_OK, PATHCCH_MAX_CCH},
|
|
/* Size < original path length + 1, read beyond size */
|
|
{"C:\\a", "C:\\", S_OK, ARRAY_SIZE("C:\\a") - 1},
|
|
/* Size < result path length + 1 */
|
|
{"C:\\a", NULL, E_INVALIDARG, ARRAY_SIZE("C:\\") - 1}
|
|
};
|
|
|
|
static void test_PathCchRemoveFileSpec(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH] = {0};
|
|
CHAR pathA[PATHCCH_MAX_CCH];
|
|
SIZE_T size;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchRemoveFileSpec)
|
|
{
|
|
win_skip("PathCchRemoveFileSpec() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* Null arguments */
|
|
hr = pPathCchRemoveFileSpec(NULL, ARRAY_SIZE(pathW));
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRemoveFileSpec(pathW, 0);
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(removefilespec_tests); i++)
|
|
{
|
|
const struct removefilespec_test *t = removefilespec_tests + i;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
size = t->size ? t->size : ARRAY_SIZE(pathW);
|
|
hr = pPathCchRemoveFileSpec(pathW, size);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, pathA, ARRAY_SIZE(pathA), NULL, NULL);
|
|
ok(!lstrcmpA(pathA, t->expected), "path %s expect stripped path %s, got %s\n", t->path, t->expected, pathA);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct renameextension_test
|
|
{
|
|
const CHAR *path;
|
|
const CHAR *extension;
|
|
const CHAR *expected;
|
|
};
|
|
|
|
static const struct renameextension_test renameextension_tests[] =
|
|
{
|
|
{"1.exe", ".txt", "1.txt"},
|
|
{"C:1.exe", ".txt", "C:1.txt"},
|
|
{"C:\\1.exe", ".txt", "C:\\1.txt"},
|
|
{"\\1.exe", ".txt", "\\1.txt"},
|
|
{"\\\\1.exe", ".txt", "\\\\1.txt"},
|
|
{"\\\\?\\C:1.exe", ".txt", "\\\\?\\C:1.txt"},
|
|
{"\\\\?\\C:\\1.exe", ".txt", "\\\\?\\C:\\1.txt"},
|
|
{"\\\\?\\UNC\\1.exe", ".txt", "\\\\?\\UNC\\1.txt"},
|
|
{"\\\\?\\UNC\\192.168.1.1\\1.exe", ".txt", "\\\\?\\UNC\\192.168.1.1\\1.txt"},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\1.exe", ".txt",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\1.txt"},
|
|
{"C:\\1.exe", "", "C:\\1"},
|
|
{"C:\\1.exe", "txt", "C:\\1.txt"}
|
|
};
|
|
|
|
static void test_PathCchRenameExtension(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH + 1];
|
|
CHAR pathA[PATHCCH_MAX_CCH + 1];
|
|
WCHAR extensionW[MAX_PATH];
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchRenameExtension)
|
|
{
|
|
win_skip("PathCchRenameExtension() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* Invalid arguments */
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\1.txt", -1, pathW, ARRAY_SIZE(pathW));
|
|
MultiByteToWideChar(CP_ACP, 0, ".exe", -1, extensionW, ARRAY_SIZE(extensionW));
|
|
|
|
hr = pPathCchRenameExtension(NULL, PATHCCH_MAX_CCH, extensionW);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRenameExtension(pathW, 0, extensionW);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRenameExtension(pathW, PATHCCH_MAX_CCH, NULL);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
/* Path length */
|
|
hr = pPathCchRenameExtension(pathW, ARRAY_SIZE("C:\\1.exe") - 1, extensionW);
|
|
ok(E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRenameExtension(pathW, PATHCCH_MAX_CCH + 1, extensionW);
|
|
ok(hr == E_INVALIDARG, "expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchRenameExtension(pathW, PATHCCH_MAX_CCH, extensionW);
|
|
ok(hr == S_OK, "expect result %#x, got %#x\n", S_OK, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(renameextension_tests); i++)
|
|
{
|
|
const struct renameextension_test *t = renameextension_tests + i;
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
MultiByteToWideChar(CP_ACP, 0, t->extension, -1, extensionW, ARRAY_SIZE(extensionW));
|
|
hr = pPathCchRenameExtension(pathW, PATHCCH_MAX_CCH, extensionW);
|
|
ok(hr == S_OK, "path %s extension %s expect result %#x, got %#x\n", t->path, t->extension, S_OK, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, pathA, ARRAY_SIZE(pathA), NULL, NULL);
|
|
ok(!lstrcmpA(pathA, t->expected), "path %s extension %s expect output path %s, got %s\n", t->path,
|
|
t->extension, t->expected, pathA);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct skiproot_test
|
|
{
|
|
const char *path;
|
|
int root_offset;
|
|
HRESULT hr;
|
|
};
|
|
|
|
static const struct skiproot_test skiproot_tests [] =
|
|
{
|
|
/* Basic combination */
|
|
{"", 0, E_INVALIDARG},
|
|
{"C:\\", 3, S_OK},
|
|
{"\\", 1, S_OK},
|
|
{"\\\\.\\", 4, S_OK},
|
|
{"\\\\?\\UNC\\", 8, S_OK},
|
|
{"\\\\?\\C:\\", 7, S_OK},
|
|
|
|
/* Basic + \ */
|
|
{"C:\\\\", 3, S_OK},
|
|
{"\\\\", 2, S_OK},
|
|
{"\\\\.\\\\", 4, S_OK},
|
|
{"\\\\?\\UNC\\\\", 9, S_OK},
|
|
{"\\\\?\\C:\\\\", 7, S_OK},
|
|
|
|
/* Basic + a */
|
|
{"a", 0, E_INVALIDARG},
|
|
{"C:\\a", 3, S_OK},
|
|
{"\\a", 1, S_OK},
|
|
{"\\\\.\\a", 5, S_OK},
|
|
{"\\\\?\\UNC\\a", 9, S_OK},
|
|
|
|
/* Basic + \a */
|
|
{"\\a", 1, S_OK},
|
|
{"C:\\\\a", 3, S_OK},
|
|
{"\\\\a", 3, S_OK},
|
|
{"\\\\.\\\\a", 4, S_OK},
|
|
{"\\\\?\\UNC\\\\a", 10, S_OK},
|
|
{"\\\\?\\C:\\\\a", 7, S_OK},
|
|
|
|
/* Basic + a\ */
|
|
{"a\\", 0, E_INVALIDARG},
|
|
{"C:\\a\\", 3, S_OK},
|
|
{"\\a\\", 1, S_OK},
|
|
{"\\\\.\\a\\", 6, S_OK},
|
|
{"\\\\?\\UNC\\a\\", 10, S_OK},
|
|
{"\\\\?\\C:\\a\\", 7, S_OK},
|
|
|
|
/* Network share */
|
|
{"\\\\\\\\", 3, S_OK},
|
|
{"\\\\a\\", 4, S_OK},
|
|
{"\\\\a\\b", 5, S_OK},
|
|
{"\\\\a\\b\\", 6, S_OK},
|
|
{"\\\\a\\b\\\\", 6, S_OK},
|
|
{"\\\\a\\b\\\\c", 6, S_OK},
|
|
{"\\\\a\\b\\c", 6, S_OK},
|
|
{"\\\\a\\b\\c\\", 6, S_OK},
|
|
{"\\\\a\\b\\c\\d", 6, S_OK},
|
|
{"\\\\a\\\\b\\c\\", 4, S_OK},
|
|
{"\\\\aa\\bb\\cc\\", 8, S_OK},
|
|
|
|
/* UNC */
|
|
{"\\\\?\\UNC\\\\", 9, S_OK},
|
|
{"\\\\?\\UNC\\a\\b", 11, S_OK},
|
|
{"\\\\?\\UNC\\a\\b", 11, S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\", 12, S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\c", 12, S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\c\\", 12, S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\c\\d", 12, S_OK},
|
|
{"\\\\?\\C:", 6, S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", 48, S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", 49, S_OK},
|
|
{"\\\\?\\unc\\a\\b", 11, S_OK},
|
|
{"\\\\?\\volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", 49, S_OK},
|
|
{"\\\\?\\volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a", 49, S_OK},
|
|
|
|
/* Malformed */
|
|
{"C:", 2, S_OK},
|
|
{":", 0, E_INVALIDARG},
|
|
{":\\", 0, E_INVALIDARG},
|
|
{"C\\", 0, E_INVALIDARG},
|
|
{"\\?", 1, S_OK},
|
|
{"\\?\\UNC", 1, S_OK},
|
|
{"\\\\?\\", 0, E_INVALIDARG},
|
|
{"\\\\?\\UNC", 0, E_INVALIDARG},
|
|
{"\\\\?\\::\\", 0, E_INVALIDARG},
|
|
{"\\\\?\\Volume", 0, E_INVALIDARG},
|
|
{"\\.", 1, S_OK},
|
|
{"\\\\..", 4, S_OK},
|
|
{"\\\\..a", 5, S_OK}
|
|
};
|
|
|
|
static void test_PathCchSkipRoot(void)
|
|
{
|
|
WCHAR pathW[MAX_PATH];
|
|
const WCHAR *root_end;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchSkipRoot)
|
|
{
|
|
win_skip("PathCchSkipRoot() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
root_end = (const WCHAR *)0xdeadbeef;
|
|
hr = pPathCchSkipRoot(NULL, &root_end);
|
|
ok(hr == E_INVALIDARG, "Expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
ok(root_end == (const WCHAR *)0xdeadbeef, "Expect root_end 0xdeadbeef, got %p\n", root_end);
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\", -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchSkipRoot(pathW, NULL);
|
|
ok(hr == E_INVALIDARG, "Expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(skiproot_tests); i++)
|
|
{
|
|
const struct skiproot_test *t = skiproot_tests + i;
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchSkipRoot(pathW, &root_end);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
ok(root_end - pathW == t->root_offset, "path %s expect root offset %d, got %ld\n", t->path, t->root_offset,
|
|
(INT_PTR)(root_end - pathW));
|
|
}
|
|
}
|
|
|
|
struct stripprefix_test
|
|
{
|
|
const CHAR *path;
|
|
const CHAR *stripped_path;
|
|
HRESULT hr;
|
|
SIZE_T size;
|
|
};
|
|
|
|
static const struct stripprefix_test stripprefix_tests[] =
|
|
{
|
|
{"\\\\?\\UNC\\", "\\\\", S_OK},
|
|
{"\\\\?\\UNC\\a", "\\\\a", S_OK},
|
|
{"\\\\?\\C:", "C:", S_OK},
|
|
{"\\\\?\\C:\\", "C:\\", S_OK},
|
|
{"\\\\?\\C:\\a", "C:\\a", S_OK},
|
|
{"\\\\?\\unc\\", "\\\\", S_OK},
|
|
{"\\\\?\\c:\\", "c:\\", S_OK},
|
|
|
|
{"\\", "\\", S_FALSE},
|
|
{"\\\\", "\\\\", S_FALSE},
|
|
{"\\\\a", "\\\\a", S_FALSE},
|
|
{"\\\\a\\", "\\\\a\\", S_FALSE},
|
|
{"\\\\?\\a", "\\\\?\\a", S_FALSE},
|
|
{"\\\\?\\UNC", "\\\\?\\UNC", S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", S_FALSE},
|
|
|
|
/* Size Tests */
|
|
{"C:\\", NULL, E_INVALIDARG, PATHCCH_MAX_CCH + 1},
|
|
{"C:\\", "C:\\", S_FALSE, PATHCCH_MAX_CCH},
|
|
/* Size < original path actual length + 1, read beyond size */
|
|
{"\\\\?\\C:\\", "C:\\", S_OK, ARRAY_SIZE("\\\\?\\C:\\") - 1},
|
|
/* Size < stripped path length + 1 */
|
|
{"\\\\?\\C:\\", NULL, E_INVALIDARG, ARRAY_SIZE("C:\\") - 1},
|
|
{"\\\\?\\UNC\\", NULL, E_INVALIDARG, ARRAY_SIZE("\\\\") - 1}
|
|
};
|
|
|
|
static void test_PathCchStripPrefix(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH + 1] = {0};
|
|
CHAR stripped_pathA[PATHCCH_MAX_CCH];
|
|
SIZE_T size;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchStripPrefix)
|
|
{
|
|
win_skip("PathCchStripPrefix(() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* Null arguments */
|
|
hr = pPathCchStripPrefix(NULL, PATHCCH_MAX_CCH);
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
hr = pPathCchStripPrefix(pathW, 0);
|
|
ok(hr == E_INVALIDARG, "expect %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(stripprefix_tests); i++)
|
|
{
|
|
const struct stripprefix_test *t = stripprefix_tests + i;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
size = t->size ? t->size : PATHCCH_MAX_CCH;
|
|
hr = pPathCchStripPrefix(pathW, size);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, stripped_pathA, ARRAY_SIZE(stripped_pathA), NULL, NULL);
|
|
ok(!lstrcmpA(stripped_pathA, t->stripped_path), "path %s expect stripped path %s, got %s\n", t->path,
|
|
t->stripped_path, stripped_pathA);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct striptoroot_test
|
|
{
|
|
const CHAR *path;
|
|
const CHAR *root;
|
|
HRESULT hr;
|
|
SIZE_T size;
|
|
};
|
|
|
|
static const struct striptoroot_test striptoroot_tests[] =
|
|
{
|
|
/* Invalid */
|
|
{"", "", E_INVALIDARG},
|
|
{"C", NULL, E_INVALIDARG},
|
|
{"\\\\?\\UNC", NULL, E_INVALIDARG},
|
|
|
|
/* Size */
|
|
{"C:\\", NULL, E_INVALIDARG, PATHCCH_MAX_CCH + 1},
|
|
{"C:\\", "C:\\", S_FALSE, PATHCCH_MAX_CCH},
|
|
/* Size < original path length + 1, read beyond size */
|
|
{"C:\\a", "C:\\", S_OK, ARRAY_SIZE("C:\\a") - 1},
|
|
/* Size < stripped path length + 1 */
|
|
{"C:\\a", "C:\\", E_INVALIDARG, ARRAY_SIZE("C:\\") - 1},
|
|
{"\\\\a\\b\\c", NULL, E_INVALIDARG, ARRAY_SIZE("\\\\a\\b") - 1},
|
|
|
|
/* X: */
|
|
{"C:", "C:", S_FALSE},
|
|
{"C:a", "C:", S_OK},
|
|
{"C:a\\b", "C:", S_OK},
|
|
{"C:a\\b\\c", "C:", S_OK},
|
|
|
|
/* X:\ */
|
|
{"C:\\", "C:\\", S_FALSE},
|
|
{"C:\\a", "C:\\", S_OK},
|
|
{"C:\\a\\b", "C:\\", S_OK},
|
|
{"C:\\a\\b\\c", "C:\\", S_OK},
|
|
|
|
/* \ */
|
|
{"\\", "\\", S_FALSE},
|
|
{"\\a", "\\", S_OK},
|
|
{"\\a\\b", "\\", S_OK},
|
|
{"\\a\\b\\c", "\\", S_OK},
|
|
|
|
/* \\ */
|
|
{"\\\\", "\\\\", S_FALSE},
|
|
{"\\\\a", "\\\\a", S_FALSE},
|
|
{"\\\\a\\b", "\\\\a\\b", S_FALSE},
|
|
{"\\\\a\\b\\c", "\\\\a\\b", S_OK},
|
|
|
|
/* UNC */
|
|
{"\\\\?\\UNC\\", "\\\\?\\UNC\\", S_FALSE},
|
|
{"\\\\?\\UNC\\a", "\\\\?\\UNC\\a", S_FALSE},
|
|
{"\\\\?\\UNC\\a\\b", "\\\\?\\UNC\\a\\b", S_FALSE},
|
|
{"\\\\?\\UNC\\a\\b\\", "\\\\?\\UNC\\a\\b", S_OK},
|
|
{"\\\\?\\UNC\\a\\b\\c", "\\\\?\\UNC\\a\\b", S_OK},
|
|
|
|
/* Prefixed X: */
|
|
{"\\\\?\\C:", "\\\\?\\C:", S_FALSE},
|
|
{"\\\\?\\C:a", "\\\\?\\C:", S_OK},
|
|
{"\\\\?\\C:a\\b", "\\\\?\\C:", S_OK},
|
|
{"\\\\?\\C:a\\b\\c", "\\\\?\\C:", S_OK},
|
|
|
|
/* Prefixed X:\ */
|
|
{"\\\\?\\C:\\", "\\\\?\\C:\\", S_FALSE},
|
|
{"\\\\?\\C:\\a", "\\\\?\\C:\\", S_OK},
|
|
{"\\\\?\\C:\\a\\b", "\\\\?\\C:\\", S_OK},
|
|
{"\\\\?\\C:\\a\\b\\c", "\\\\?\\C:\\", S_OK},
|
|
|
|
/* UNC Volume */
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a\\b",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}a\\b\\c",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}", S_OK},
|
|
|
|
/* UNC Volume with backslash */
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", S_FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a\\b",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", S_OK},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\a\\b\\c",
|
|
"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", S_OK},
|
|
};
|
|
|
|
static void test_PathCchStripToRoot(void)
|
|
{
|
|
WCHAR pathW[PATHCCH_MAX_CCH];
|
|
CHAR rootA[PATHCCH_MAX_CCH];
|
|
SIZE_T size;
|
|
HRESULT hr;
|
|
INT i;
|
|
|
|
if (!pPathCchStripToRoot)
|
|
{
|
|
win_skip("PathCchStripToRoot() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* Null arguments */
|
|
hr = pPathCchStripToRoot(NULL, ARRAY_SIZE(pathW));
|
|
ok(hr == E_INVALIDARG, "Expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\a", -1, pathW, ARRAY_SIZE(pathW));
|
|
hr = pPathCchStripToRoot(pathW, 0);
|
|
ok(hr == E_INVALIDARG, "Expect result %#x, got %#x\n", E_INVALIDARG, hr);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(striptoroot_tests); i++)
|
|
{
|
|
const struct striptoroot_test *t = striptoroot_tests + i;
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
size = t->size ? t->size : ARRAY_SIZE(pathW);
|
|
hr = pPathCchStripToRoot(pathW, size);
|
|
ok(hr == t->hr, "path %s expect result %#x, got %#x\n", t->path, t->hr, hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pathW, -1, rootA, ARRAY_SIZE(rootA), NULL, NULL);
|
|
ok(!lstrcmpA(rootA, t->root), "path %s expect stripped path %s, got %s\n", t->path, t->root, rootA);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct isuncex_test
|
|
{
|
|
const CHAR *path;
|
|
INT server_offset;
|
|
BOOL ret;
|
|
};
|
|
|
|
static const struct isuncex_test isuncex_tests[] =
|
|
{
|
|
{"\\\\", 2, TRUE},
|
|
{"\\\\a\\", 2, TRUE},
|
|
{"\\\\.\\", 2, TRUE},
|
|
{"\\\\?\\UNC\\", 8, TRUE},
|
|
{"\\\\?\\UNC\\a", 8, TRUE},
|
|
{"\\\\?\\unc\\", 8, TRUE},
|
|
{"\\\\?\\unc\\a", 8, TRUE},
|
|
|
|
{"", 0, FALSE},
|
|
{"\\", 0, FALSE},
|
|
{"C:\\", 0, FALSE},
|
|
{"\\??\\", 0, FALSE},
|
|
{"\\\\?\\", 0, FALSE},
|
|
{"\\\\?\\UNC", 0, FALSE},
|
|
{"\\\\?\\C:", 0, FALSE},
|
|
{"\\\\?\\C:\\", 0, FALSE},
|
|
{"\\\\?\\C:\\a", 0, FALSE},
|
|
{"\\\\?\\Volume{e51a1864-6f2d-4019-b73d-f4e60e600c26}\\", 0, FALSE}
|
|
};
|
|
|
|
static void test_PathIsUNCEx(void)
|
|
{
|
|
WCHAR pathW[MAX_PATH];
|
|
const WCHAR *server;
|
|
BOOL ret;
|
|
INT i;
|
|
|
|
if (!pPathIsUNCEx)
|
|
{
|
|
win_skip("PathIsUNCEx(() is not available.\n");
|
|
return;
|
|
}
|
|
|
|
/* No NULL check for path pointers on Windows */
|
|
if (0)
|
|
{
|
|
ret = pPathIsUNCEx(NULL, &server);
|
|
ok(ret == FALSE, "expect FALSE\n");
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "C:\\", -1, pathW, ARRAY_SIZE(pathW));
|
|
ret = pPathIsUNCEx(pathW, NULL);
|
|
ok(ret == FALSE, "expect FALSE\n");
|
|
|
|
for (i = 0; i < ARRAY_SIZE(isuncex_tests); i++)
|
|
{
|
|
const struct isuncex_test *t = isuncex_tests + i;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, t->path, -1, pathW, ARRAY_SIZE(pathW));
|
|
server = (const WCHAR *)0xdeadbeef;
|
|
ret = pPathIsUNCEx(pathW, &server);
|
|
ok(ret == t->ret, "path \"%s\" expect return %d, got %d\n", t->path, t->ret, ret);
|
|
if (ret)
|
|
ok(server == pathW + t->server_offset, "path \"%s\" expect server offset %d, got %ld\n", t->path,
|
|
t->server_offset, (INT_PTR)(server - pathW));
|
|
else
|
|
ok(!server, "expect server is null, got %p\n", server);
|
|
}
|
|
}
|
|
|
|
START_TEST(path)
|
|
{
|
|
HMODULE hmod = LoadLibraryA("kernelbase.dll");
|
|
|
|
pPathAllocCanonicalize = (void *)GetProcAddress(hmod, "PathAllocCanonicalize");
|
|
pPathAllocCombine = (void *)GetProcAddress(hmod, "PathAllocCombine");
|
|
pPathCchAddBackslash = (void *)GetProcAddress(hmod, "PathCchAddBackslash");
|
|
pPathCchAddBackslashEx = (void *)GetProcAddress(hmod, "PathCchAddBackslashEx");
|
|
pPathCchAddExtension = (void *)GetProcAddress(hmod, "PathCchAddExtension");
|
|
pPathCchAppend = (void *)GetProcAddress(hmod, "PathCchAppend");
|
|
pPathCchAppendEx = (void *)GetProcAddress(hmod, "PathCchAppendEx");
|
|
pPathCchCanonicalize = (void *)GetProcAddress(hmod, "PathCchCanonicalize");
|
|
pPathCchCanonicalizeEx = (void *)GetProcAddress(hmod, "PathCchCanonicalizeEx");
|
|
pPathCchCombine = (void *)GetProcAddress(hmod, "PathCchCombine");
|
|
pPathCchCombineEx = (void *)GetProcAddress(hmod, "PathCchCombineEx");
|
|
pPathCchFindExtension = (void *)GetProcAddress(hmod, "PathCchFindExtension");
|
|
pPathCchIsRoot = (void *)GetProcAddress(hmod, "PathCchIsRoot");
|
|
pPathCchRemoveBackslash = (void *)GetProcAddress(hmod, "PathCchRemoveBackslash");
|
|
pPathCchRemoveBackslashEx = (void *)GetProcAddress(hmod, "PathCchRemoveBackslashEx");
|
|
pPathCchRemoveExtension = (void *)GetProcAddress(hmod, "PathCchRemoveExtension");
|
|
pPathCchRemoveFileSpec = (void *)GetProcAddress(hmod, "PathCchRemoveFileSpec");
|
|
pPathCchRenameExtension = (void *)GetProcAddress(hmod, "PathCchRenameExtension");
|
|
pPathCchSkipRoot = (void *)GetProcAddress(hmod, "PathCchSkipRoot");
|
|
pPathCchStripPrefix = (void *)GetProcAddress(hmod, "PathCchStripPrefix");
|
|
pPathCchStripToRoot = (void *)GetProcAddress(hmod, "PathCchStripToRoot");
|
|
pPathIsUNCEx = (void *)GetProcAddress(hmod, "PathIsUNCEx");
|
|
|
|
test_PathAllocCanonicalize();
|
|
test_PathAllocCombine();
|
|
test_PathCchAddBackslash();
|
|
test_PathCchAddBackslashEx();
|
|
test_PathCchAddExtension();
|
|
test_PathCchAppend();
|
|
test_PathCchAppendEx();
|
|
test_PathCchCanonicalize();
|
|
test_PathCchCanonicalizeEx();
|
|
test_PathCchCombine();
|
|
test_PathCchCombineEx();
|
|
test_PathCchFindExtension();
|
|
test_PathCchIsRoot();
|
|
test_PathCchRemoveBackslash();
|
|
test_PathCchRemoveBackslashEx();
|
|
test_PathCchRemoveExtension();
|
|
test_PathCchRemoveFileSpec();
|
|
test_PathCchRenameExtension();
|
|
test_PathCchSkipRoot();
|
|
test_PathCchStripPrefix();
|
|
test_PathCchStripToRoot();
|
|
test_PathIsUNCEx();
|
|
}
|