Sweden-Number/dlls/kernelbase/tests/path.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);
    }

    path_inW[0] = 0;
    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();
}