[COMCTL32_WINETEST]
authorAmine Khaldi <amine.khaldi@reactos.org>
Tue, 22 Apr 2014 14:05:48 +0000 (14:05 +0000)
committerAmine Khaldi <amine.khaldi@reactos.org>
Tue, 22 Apr 2014 14:05:48 +0000 (14:05 +0000)
* Sync with Wine 1.7.17.
CORE-8080

svn path=/trunk/; revision=62880

28 files changed:
rostests/winetests/comctl32/CMakeLists.txt
rostests/winetests/comctl32/button.c [new file with mode: 0644]
rostests/winetests/comctl32/comboex.c
rostests/winetests/comctl32/datetime.c
rostests/winetests/comctl32/dpa.c
rostests/winetests/comctl32/header.c
rostests/winetests/comctl32/imagelist.c
rostests/winetests/comctl32/ipaddress.c
rostests/winetests/comctl32/listview.c
rostests/winetests/comctl32/misc.c
rostests/winetests/comctl32/monthcal.c
rostests/winetests/comctl32/mru.c
rostests/winetests/comctl32/msg.h
rostests/winetests/comctl32/pager.c
rostests/winetests/comctl32/progress.c
rostests/winetests/comctl32/propsheet.c
rostests/winetests/comctl32/rebar.c
rostests/winetests/comctl32/status.c
rostests/winetests/comctl32/subclass.c
rostests/winetests/comctl32/syslink.c
rostests/winetests/comctl32/tab.c
rostests/winetests/comctl32/testlist.c
rostests/winetests/comctl32/toolbar.c
rostests/winetests/comctl32/tooltips.c
rostests/winetests/comctl32/trackbar.c
rostests/winetests/comctl32/treeview.c
rostests/winetests/comctl32/updown.c
rostests/winetests/comctl32/v6util.h

index dbfd6a3..9b0e6e8 100644 (file)
@@ -4,6 +4,7 @@ remove_definitions(-D_WIN32_WINNT=0x502 -D_WIN32_IE=0x600)
 add_definitions(-DUSE_WINE_TODOS)
 
 list(APPEND SOURCE
+    button.c
     comboex.c
     datetime.c
     dpa.c
diff --git a/rostests/winetests/comctl32/button.c b/rostests/winetests/comctl32/button.c
new file mode 100644 (file)
index 0000000..82cd3c0
--- /dev/null
@@ -0,0 +1,819 @@
+/* Unit test suite for Button control.
+ *
+ * Copyright 1999 Ove Kaaven
+ * Copyright 2003 Dimitrie O. Paun
+ * Copyright 2004, 2005 Dmitry Timoshkov
+ * Copyright 2014 Nikolay Sivov for CodeWeavers
+ *
+ * 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 <windows.h>
+#include <stdarg.h>
+#include <windef.h>
+#include <winbase.h>
+#include <wingdi.h>
+#include <winuser.h>
+#include <commctrl.h>
+
+#include "wine/test.h"
+#include "v6util.h"
+#include "msg.h"
+
+#define IS_WNDPROC_HANDLE(x) (((ULONG_PTR)(x) >> 16) == (~0u >> 16))
+
+static BOOL (WINAPI *pSetWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR, DWORD_PTR);
+static BOOL (WINAPI *pRemoveWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR);
+static LRESULT (WINAPI *pDefSubclassProc)(HWND, UINT, WPARAM, LPARAM);
+
+/****************** button message test *************************/
+#define ID_BUTTON 0x000e
+
+#define COMBINED_SEQ_INDEX 0
+#define NUM_MSG_SEQUENCES  1
+
+static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
+
+struct wndclass_redirect_data
+{
+    ULONG size;
+    DWORD res;
+    ULONG name_len;
+    ULONG name_offset;
+    ULONG module_len;
+    ULONG module_offset;
+};
+
+/* returned pointer is valid as long as activation context is alive */
+static WCHAR* get_versioned_classname(const WCHAR *name)
+{
+    BOOL (WINAPI *pFindActCtxSectionStringW)(DWORD,const GUID *,ULONG,LPCWSTR,PACTCTX_SECTION_KEYED_DATA);
+    struct wndclass_redirect_data *wnddata;
+    ACTCTX_SECTION_KEYED_DATA data;
+    BOOL ret;
+
+    pFindActCtxSectionStringW = (void*)GetProcAddress(GetModuleHandleA("kernel32"), "FindActCtxSectionStringW");
+
+    memset(&data, 0, sizeof(data));
+    data.cbSize = sizeof(data);
+
+    ret = pFindActCtxSectionStringW(0, NULL,
+                                    ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION,
+                                    name, &data);
+    ok(ret, "got %d, error %u\n", ret, GetLastError());
+    wnddata = (struct wndclass_redirect_data*)data.lpData;
+    return (WCHAR*)((BYTE*)wnddata + wnddata->name_offset);
+}
+
+static void init_functions(void)
+{
+    HMODULE hmod = GetModuleHandleA("comctl32.dll");
+    ok(hmod != NULL, "got %p\n", hmod);
+
+#define MAKEFUNC_ORD(f, ord) (p##f = (void*)GetProcAddress(hmod, (LPSTR)(ord)))
+    MAKEFUNC_ORD(SetWindowSubclass, 410);
+    MAKEFUNC_ORD(RemoveWindowSubclass, 412);
+    MAKEFUNC_ORD(DefSubclassProc, 413);
+#undef MAKEFUNC_ORD
+}
+
+/* try to make sure pending X events have been processed before continuing */
+static void flush_events(void)
+{
+    MSG msg;
+    int diff = 200;
+    int min_timeout = 100;
+    DWORD time = GetTickCount() + diff;
+
+    while (diff > 0)
+    {
+        if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
+        while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
+        diff = time - GetTickCount();
+    }
+}
+
+static BOOL ignore_message( UINT message )
+{
+    /* these are always ignored */
+    return (message >= 0xc000 ||
+            message == WM_GETICON ||
+            message == WM_GETOBJECT ||
+            message == WM_TIMECHANGE ||
+            message == WM_DISPLAYCHANGE ||
+            message == WM_DEVICECHANGE ||
+            message == WM_DWMNCRENDERINGCHANGED ||
+            message == WM_GETTEXTLENGTH ||
+            message == WM_GETTEXT);
+}
+
+static LRESULT CALLBACK button_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, UINT_PTR id, DWORD_PTR ref_data)
+{
+    static LONG defwndproc_counter = 0;
+    LRESULT ret;
+    struct message msg;
+
+    if (ignore_message( message )) return pDefSubclassProc(hwnd, message, wParam, lParam);
+
+    switch (message)
+    {
+    case WM_SYNCPAINT:
+        break;
+    case BM_SETSTATE:
+        if (GetCapture())
+            ok(GetCapture() == hwnd, "GetCapture() = %p\n", GetCapture());
+        /* fall through */
+    default:
+        msg.message = message;
+        msg.flags = sent|wparam|lparam;
+        if (defwndproc_counter) msg.flags |= defwinproc;
+        msg.wParam = wParam;
+        msg.lParam = lParam;
+        add_message(sequences, COMBINED_SEQ_INDEX, &msg);
+    }
+
+    if (message == WM_NCDESTROY)
+        pRemoveWindowSubclass(hwnd, button_subclass_proc, 0);
+
+    defwndproc_counter++;
+    ret = pDefSubclassProc(hwnd, message, wParam, lParam);
+    defwndproc_counter--;
+
+    return ret;
+}
+
+static LRESULT WINAPI test_parent_wndproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    static LONG defwndproc_counter = 0;
+    static LONG beginpaint_counter = 0;
+    LRESULT ret;
+    struct message msg;
+
+    if (ignore_message( message )) return 0;
+
+    if (message == WM_PARENTNOTIFY || message == WM_CANCELMODE ||
+        message == WM_SETFOCUS || message == WM_KILLFOCUS ||
+        message == WM_ENABLE || message == WM_ENTERIDLE ||
+        message == WM_DRAWITEM || message == WM_COMMAND ||
+        message == WM_IME_SETCONTEXT)
+    {
+        switch (message)
+        {
+            /* ignore */
+            case WM_NCHITTEST:
+                return HTCLIENT;
+            case WM_SETCURSOR:
+            case WM_MOUSEMOVE:
+            case WM_NCMOUSEMOVE:
+                return 0;
+        }
+
+        msg.message = message;
+        msg.flags = sent|parent|wparam|lparam;
+        if (defwndproc_counter) msg.flags |= defwinproc;
+        if (beginpaint_counter) msg.flags |= beginpaint;
+        msg.wParam = wParam;
+        msg.lParam = lParam;
+        add_message(sequences, COMBINED_SEQ_INDEX, &msg);
+    }
+
+    if (message == WM_PAINT)
+    {
+        PAINTSTRUCT ps;
+        beginpaint_counter++;
+        BeginPaint( hwnd, &ps );
+        beginpaint_counter--;
+        EndPaint( hwnd, &ps );
+        return 0;
+    }
+
+    defwndproc_counter++;
+    ret = DefWindowProcA(hwnd, message, wParam, lParam);
+    defwndproc_counter--;
+
+    return ret;
+}
+
+static const struct message setfocus_seq[] =
+{
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
+    { WM_SETFOCUS, sent|wparam },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
+    { WM_APP, sent|wparam|lparam },
+    { WM_PAINT, sent },
+    { 0 }
+};
+
+static const struct message killfocus_seq[] =
+{
+    { WM_KILLFOCUS, sent|wparam, 0 },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { 0 }
+};
+
+static const struct message setfocus_static_seq[] =
+{
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
+    { WM_SETFOCUS, sent|wparam, 0 },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
+    { WM_COMMAND, sent|wparam|parent|optional, MAKEWPARAM(ID_BUTTON, BN_CLICKED) }, /* radio button */
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { 0 }
+};
+
+static const struct message setfocus_groupbox_seq[] =
+{
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
+    { WM_SETFOCUS, sent|wparam, 0 },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
+    { WM_COMMAND, sent|wparam|parent|optional, MAKEWPARAM(ID_BUTTON, BN_CLICKED) }, /* radio button */
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { 0 }
+};
+
+static const struct message killfocus_static_seq[] =
+{
+    { WM_KILLFOCUS, sent|wparam, 0 },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { 0 }
+};
+
+static const struct message setfocus_ownerdraw_seq[] =
+{
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
+    { WM_SETFOCUS, sent|wparam, 0 },
+    { WM_DRAWITEM, sent|wparam|parent, ID_BUTTON },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
+    { 0 }
+};
+
+static const struct message killfocus_ownerdraw_seq[] =
+{
+    { WM_KILLFOCUS, sent|wparam, 0 },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
+    { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_DRAWITEM, sent|wparam|parent, ID_BUTTON },
+    { 0 }
+};
+
+static const struct message lbuttondown_seq[] =
+{
+    { WM_LBUTTONDOWN, sent|wparam|lparam, 0, 0 },
+    { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
+    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
+    { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
+    { BM_SETSTATE, sent|wparam|defwinproc, TRUE },
+    { 0 }
+};
+
+static const struct message lbuttonup_seq[] =
+{
+    { WM_LBUTTONUP, sent|wparam|lparam, 0, 0 },
+    { BM_SETSTATE, sent|wparam|defwinproc, FALSE },
+    { WM_CAPTURECHANGED, sent|wparam|defwinproc, 0 },
+    { WM_COMMAND, sent|wparam|defwinproc, 0 },
+    { 0 }
+};
+
+static const struct message setfont_seq[] =
+{
+    { WM_SETFONT, sent },
+    { 0 }
+};
+
+static const struct message setstyle_seq[] =
+{
+    { BM_SETSTYLE, sent },
+    { WM_STYLECHANGING, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_STYLECHANGED, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message setstyle_static_seq[] =
+{
+    { BM_SETSTYLE, sent },
+    { WM_STYLECHANGING, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_STYLECHANGED, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message setstyle_user_seq[] =
+{
+    { BM_SETSTYLE, sent },
+    { WM_STYLECHANGING, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_STYLECHANGED, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|defwinproc|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message setstyle_ownerdraw_seq[] =
+{
+    { BM_SETSTYLE, sent },
+    { WM_STYLECHANGING, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_STYLECHANGED, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { WM_DRAWITEM, sent|wparam|parent, ID_BUTTON },
+    { 0 }
+};
+
+static const struct message setstate_seq[] =
+{
+    { BM_SETSTATE, sent },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message setstate_static_seq[] =
+{
+    { BM_SETSTATE, sent },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message setstate_user_seq[] =
+{
+    { BM_SETSTATE, sent },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_HILITE) },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message setstate_ownerdraw_seq[] =
+{
+    { BM_SETSTATE, sent },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { WM_DRAWITEM, sent|wparam|parent, ID_BUTTON },
+    { 0 }
+};
+
+static const struct message clearstate_seq[] =
+{
+    { BM_SETSTATE, sent },
+    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_UNHILITE) },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message clearstate_ownerdraw_seq[] =
+{
+    { BM_SETSTATE, sent },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { WM_DRAWITEM, sent|wparam|parent, ID_BUTTON },
+    { 0 }
+};
+
+static const struct message setcheck_ignored_seq[] =
+{
+    { BM_SETCHECK, sent },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { 0 }
+};
+
+static const struct message setcheck_uncheck_seq[] =
+{
+    { BM_SETCHECK, sent },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { 0 }
+};
+
+static const struct message setcheck_static_seq[] =
+{
+    { BM_SETCHECK, sent },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static const struct message setcheck_radio_seq[] =
+{
+    { BM_SETCHECK, sent },
+    { WM_STYLECHANGING, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_STYLECHANGED, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { 0 }
+};
+
+static const struct message setcheck_radio_redraw_seq[] =
+{
+    { BM_SETCHECK, sent },
+    { WM_STYLECHANGING, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_STYLECHANGED, sent|wparam|defwinproc, GWL_STYLE },
+    { WM_APP, sent|wparam|lparam, 0, 0 },
+    { WM_PAINT, sent },
+    { WM_NCPAINT, sent|optional }, /* FIXME: Wine sends it */
+    { WM_ERASEBKGND, sent|defwinproc|optional },
+    { 0 }
+};
+
+static HWND create_button(DWORD style, HWND parent)
+{
+    HMENU menuid = 0;
+    HWND hwnd;
+
+    if (parent)
+    {
+        style |= WS_CHILD|BS_NOTIFY;
+        menuid = (HMENU)ID_BUTTON;
+    }
+    hwnd = CreateWindowExA(0, "Button", "test", style, 0, 0, 50, 14, parent, menuid, 0, NULL);
+    ok(hwnd != NULL, "failed to create a button, 0x%08x, %p\n", style, parent);
+    pSetWindowSubclass(hwnd, button_subclass_proc, 0, 0);
+    return hwnd;
+}
+
+static void test_button_messages(void)
+{
+    static const struct
+    {
+        DWORD style;
+        DWORD dlg_code;
+        const struct message *setfocus;
+        const struct message *killfocus;
+        const struct message *setstyle;
+        const struct message *setstate;
+        const struct message *clearstate;
+        const struct message *setcheck;
+    } button[] = {
+        { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
+          setfocus_seq, killfocus_seq, setstyle_seq,
+          setstate_seq, setstate_seq, setcheck_ignored_seq },
+        { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON,
+          setfocus_seq, killfocus_seq, setstyle_seq,
+          setstate_seq, setstate_seq, setcheck_ignored_seq },
+        { BS_CHECKBOX, DLGC_BUTTON,
+          setfocus_static_seq, killfocus_static_seq, setstyle_static_seq,
+          setstate_static_seq, setstate_static_seq, setcheck_static_seq },
+        { BS_AUTOCHECKBOX, DLGC_BUTTON,
+          setfocus_static_seq, killfocus_static_seq, setstyle_static_seq,
+          setstate_static_seq, setstate_static_seq, setcheck_static_seq },
+        { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
+          setfocus_static_seq, killfocus_static_seq, setstyle_static_seq,
+          setstate_static_seq, setstate_static_seq, setcheck_radio_redraw_seq },
+        { BS_3STATE, DLGC_BUTTON,
+          setfocus_static_seq, killfocus_static_seq, setstyle_static_seq,
+          setstate_static_seq, setstate_static_seq, setcheck_static_seq },
+        { BS_AUTO3STATE, DLGC_BUTTON,
+          setfocus_static_seq, killfocus_static_seq, setstyle_static_seq,
+          setstate_static_seq, setstate_static_seq, setcheck_static_seq },
+        { BS_GROUPBOX, DLGC_STATIC,
+          setfocus_groupbox_seq, killfocus_static_seq, setstyle_static_seq,
+          setstate_static_seq, setstate_static_seq, setcheck_ignored_seq },
+        { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON,
+          setfocus_seq, killfocus_seq, setstyle_user_seq,
+          setstate_user_seq, clearstate_seq, setcheck_ignored_seq },
+        { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON,
+          setfocus_static_seq, killfocus_static_seq, setstyle_static_seq,
+          setstate_static_seq, setstate_static_seq, setcheck_radio_redraw_seq },
+        { BS_OWNERDRAW, DLGC_BUTTON,
+          setfocus_ownerdraw_seq, killfocus_ownerdraw_seq, setstyle_ownerdraw_seq,
+          setstate_ownerdraw_seq, clearstate_ownerdraw_seq, setcheck_ignored_seq },
+    };
+    const struct message *seq;
+    unsigned int i;
+    HWND hwnd, parent;
+    DWORD dlg_code;
+    HFONT zfont;
+    BOOL todo;
+
+    /* selection with VK_SPACE should capture button window */
+    hwnd = create_button(BS_CHECKBOX | WS_VISIBLE | WS_POPUP, NULL);
+    ok(hwnd != 0, "Failed to create button window\n");
+    ReleaseCapture();
+    SetFocus(hwnd);
+    SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
+    ok(GetCapture() == hwnd, "Should be captured on VK_SPACE WM_KEYDOWN\n");
+    SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
+    DestroyWindow(hwnd);
+
+    parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
+                             100, 100, 200, 200, 0, 0, 0, NULL);
+    ok(parent != 0, "Failed to create parent window\n");
+
+    for (i = 0; i < sizeof(button)/sizeof(button[0]); i++)
+    {
+        MSG msg;
+        DWORD style, state;
+
+        trace("%d: button test sequence\n", i);
+        hwnd = create_button(button[i].style, parent);
+
+        style = GetWindowLongA(hwnd, GWL_STYLE);
+        style &= ~(WS_CHILD | BS_NOTIFY);
+        /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
+        if (button[i].style == BS_USERBUTTON)
+            ok(style == BS_PUSHBUTTON, "expected style BS_PUSHBUTTON got %x\n", style);
+        else
+            ok(style == button[i].style, "expected style %x got %x\n", button[i].style, style);
+
+        dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0);
+        ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code);
+
+        ShowWindow(hwnd, SW_SHOW);
+        UpdateWindow(hwnd);
+        SetFocus(0);
+        flush_events();
+        SetFocus(0);
+        flush_sequences(sequences, NUM_MSG_SEQUENCES);
+
+        todo = button[i].style != BS_OWNERDRAW;
+        ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
+        SetFocus(hwnd);
+        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
+        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
+        ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setfocus, "SetFocus(hwnd) on a button", todo);
+
+        todo = button[i].style == BS_OWNERDRAW;
+        SetFocus(0);
+        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
+        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
+        ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].killfocus, "SetFocus(0) on a button", todo);
+        ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus());
+
+        SendMessageA(hwnd, BM_SETSTYLE, button[i].style | BS_BOTTOM, TRUE);
+        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
+        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
+        ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setstyle, "BM_SETSTYLE on a button", TRUE);
+
+        style = GetWindowLongA(hwnd, GWL_STYLE);
+        style &= ~(WS_VISIBLE | WS_CHILD | BS_NOTIFY);
+        /* XP doesn't turn a BS_USERBUTTON into BS_PUSHBUTTON here! */
+        ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
+
+        state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
+        ok(state == 0, "expected state 0, got %04x\n", state);
+
+        flush_sequences(sequences, NUM_MSG_SEQUENCES);
+
+        SendMessageA(hwnd, BM_SETSTATE, TRUE, 0);
+        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
+        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
+        ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setstate, "BM_SETSTATE/TRUE on a button", TRUE);
+
+        state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
+        ok(state == BST_PUSHED, "expected state 0x0004, got %04x\n", state);
+
+        style = GetWindowLongA(hwnd, GWL_STYLE);
+        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
+        ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
+
+        flush_sequences(sequences, NUM_MSG_SEQUENCES);
+
+        SendMessageA(hwnd, BM_SETSTATE, FALSE, 0);
+        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
+        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
+        ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].clearstate, "BM_SETSTATE/FALSE on a button", TRUE);
+
+        state = SendMessageA(hwnd, BM_GETSTATE, 0, 0);
+        ok(state == 0, "expected state 0, got %04x\n", state);
+
+        style = GetWindowLongA(hwnd, GWL_STYLE);
+        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
+        ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
+
+        state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
+        ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state);
+
+        flush_sequences(sequences, NUM_MSG_SEQUENCES);
+
+        if (button[i].style == BS_RADIOBUTTON ||
+            button[i].style == BS_AUTORADIOBUTTON)
+        {
+            seq = setcheck_radio_seq;
+            todo = TRUE;
+        }
+        else
+        {
+            seq = setcheck_ignored_seq;
+            todo = FALSE;
+        }
+        SendMessageA(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
+        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
+        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
+        ok_sequence(sequences, COMBINED_SEQ_INDEX, seq, "BM_SETCHECK on a button", todo);
+
+        state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
+        ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state);
+
+        style = GetWindowLongA(hwnd, GWL_STYLE);
+        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
+        ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
+
+        flush_sequences(sequences, NUM_MSG_SEQUENCES);
+
+        SendMessageA(hwnd, BM_SETCHECK, BST_CHECKED, 0);
+        SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */
+        while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
+
+        if (button[i].style == BS_PUSHBUTTON ||
+            button[i].style == BS_DEFPUSHBUTTON ||
+            button[i].style == BS_GROUPBOX ||
+            button[i].style == BS_USERBUTTON ||
+            button[i].style == BS_OWNERDRAW)
+        {
+            ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setcheck, "BM_SETCHECK on a button", FALSE);
+            state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
+            ok(state == BST_UNCHECKED, "expected check BST_UNCHECKED, got %04x\n", state);
+        }
+        else
+        {
+            ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setcheck, "BM_SETCHECK on a button", TRUE);
+            state = SendMessageA(hwnd, BM_GETCHECK, 0, 0);
+            ok(state == BST_CHECKED, "expected check BST_CHECKED, got %04x\n", state);
+        }
+
+        style = GetWindowLongA(hwnd, GWL_STYLE);
+        style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE);
+        if (button[i].style == BS_RADIOBUTTON ||
+            button[i].style == BS_AUTORADIOBUTTON)
+            ok(style == (button[i].style | WS_TABSTOP), "expected style %04x | WS_TABSTOP got %04x\n", button[i].style, style);
+        else
+            ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style);
+
+        DestroyWindow(hwnd);
+    }
+
+    DestroyWindow(parent);
+
+    hwnd = create_button(BS_PUSHBUTTON, NULL);
+
+    SetForegroundWindow(hwnd);
+    flush_events();
+
+    SetActiveWindow(hwnd);
+    SetFocus(0);
+    flush_sequences(sequences, NUM_MSG_SEQUENCES);
+
+    SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0);
+    ok_sequence(sequences, COMBINED_SEQ_INDEX, lbuttondown_seq, "WM_LBUTTONDOWN on a button", FALSE);
+
+    SendMessageA(hwnd, WM_LBUTTONUP, 0, 0);
+    ok_sequence(sequences, COMBINED_SEQ_INDEX, lbuttonup_seq, "WM_LBUTTONUP on a button", TRUE);
+
+    flush_sequences(sequences, NUM_MSG_SEQUENCES);
+    zfont = GetStockObject(SYSTEM_FONT);
+    SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE);
+    UpdateWindow(hwnd);
+    ok_sequence(sequences, COMBINED_SEQ_INDEX, setfont_seq, "WM_SETFONT on a button", FALSE);
+
+    DestroyWindow(hwnd);
+}
+
+static void test_button_class(void)
+{
+    static const WCHAR testW[] = {'t','e','s','t',0};
+    WNDCLASSEXW exW, ex2W;
+    WNDCLASSEXA exA;
+    char buffA[100];
+    WCHAR *nameW;
+    HWND hwnd;
+    BOOL ret;
+    int len;
+
+    ret = GetClassInfoExA(NULL, WC_BUTTONA, &exA);
+    ok(ret, "got %d\n", ret);
+todo_wine
+    ok(IS_WNDPROC_HANDLE(exA.lpfnWndProc), "got %p\n", exA.lpfnWndProc);
+
+    ret = GetClassInfoExW(NULL, WC_BUTTONW, &exW);
+    ok(ret, "got %d\n", ret);
+    ok(!IS_WNDPROC_HANDLE(exW.lpfnWndProc), "got %p\n", exW.lpfnWndProc);
+
+    /* check that versioned class is also accessible */
+    nameW = get_versioned_classname(WC_BUTTONW);
+    ok(lstrcmpW(nameW, WC_BUTTONW), "got %s\n", wine_dbgstr_w(nameW));
+
+    ret = GetClassInfoExW(NULL, nameW, &ex2W);
+todo_wine {
+    ok(ret, "got %d\n", ret);
+    ok(ex2W.lpfnWndProc == exW.lpfnWndProc, "got %p, %p\n", exW.lpfnWndProc, ex2W.lpfnWndProc);
+}
+
+    /* Check reported class name */
+    hwnd = create_button(BS_CHECKBOX, NULL);
+    len = GetClassNameA(hwnd, buffA, sizeof(buffA));
+    ok(len == strlen(buffA), "got %d\n", len);
+    ok(!strcmp(buffA, "Button"), "got %s\n", buffA);
+
+    len = RealGetWindowClassA(hwnd, buffA, sizeof(buffA));
+    ok(len == strlen(buffA), "got %d\n", len);
+    ok(!strcmp(buffA, "Button"), "got %s\n", buffA);
+    DestroyWindow(hwnd);
+
+    /* explicitely create with versioned class name */
+    hwnd = CreateWindowExW(0, nameW, testW, BS_CHECKBOX, 0, 0, 50, 14, NULL, 0, 0, NULL);
+todo_wine
+    ok(hwnd != NULL, "failed to create a window %s\n", wine_dbgstr_w(nameW));
+if (hwnd)
+{
+    len = GetClassNameA(hwnd, buffA, sizeof(buffA));
+    ok(len == strlen(buffA), "got %d\n", len);
+    ok(!strcmp(buffA, "Button"), "got %s\n", buffA);
+
+    len = RealGetWindowClassA(hwnd, buffA, sizeof(buffA));
+    ok(len == strlen(buffA), "got %d\n", len);
+    ok(!strcmp(buffA, "Button"), "got %s\n", buffA);
+
+    DestroyWindow(hwnd);
+}
+}
+
+static void register_parent_class(void)
+{
+    WNDCLASSA cls;
+
+    cls.style = 0;
+    cls.lpfnWndProc = test_parent_wndproc;
+    cls.cbClsExtra = 0;
+    cls.cbWndExtra = 0;
+    cls.hInstance = GetModuleHandleA(0);
+    cls.hIcon = 0;
+    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
+    cls.hbrBackground = GetStockObject(WHITE_BRUSH);
+    cls.lpszMenuName = NULL;
+    cls.lpszClassName = "TestParentClass";
+    RegisterClassA(&cls);
+}
+
+START_TEST(button)
+{
+    ULONG_PTR ctx_cookie;
+    HANDLE hCtx;
+
+    if (!load_v6_module(&ctx_cookie, &hCtx))
+        return;
+
+    register_parent_class();
+
+    init_functions();
+    init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
+
+    test_button_class();
+    test_button_messages();
+
+    unload_v6_module(ctx_cookie, hCtx);
+}
index 0f78bbe..3e30558 100644 (file)
@@ -53,37 +53,37 @@ static HWND createComboEx(DWORD style) {
             hComboExParentWnd, NULL, hMainHinst, NULL);
 }
 
-static LONG addItem(HWND cbex, int idx, LPTSTR text) {
-    COMBOBOXEXITEM cbexItem;
+static LONG addItem(HWND cbex, int idx, const char *text) {
+    COMBOBOXEXITEMA cbexItem;
     memset(&cbexItem, 0x00, sizeof(cbexItem));
     cbexItem.mask = CBEIF_TEXT;
     cbexItem.iItem = idx;
-    cbexItem.pszText    = text;
+    cbexItem.pszText    = (char*)text;
     cbexItem.cchTextMax = 0;
-    return SendMessage(cbex, CBEM_INSERTITEM, 0, (LPARAM)&cbexItem);
+    return SendMessageA(cbex, CBEM_INSERTITEMA, 0, (LPARAM)&cbexItem);
 }
 
-static LONG setItem(HWND cbex, int idx, LPTSTR text) {
-    COMBOBOXEXITEM cbexItem;
+static LONG setItem(HWND cbex, int idx, const char *text) {
+    COMBOBOXEXITEMA cbexItem;
     memset(&cbexItem, 0x00, sizeof(cbexItem));
     cbexItem.mask = CBEIF_TEXT;
     cbexItem.iItem = idx;
-    cbexItem.pszText    = text;
+    cbexItem.pszText    = (char*)text;
     cbexItem.cchTextMax = 0;
-    return SendMessage(cbex, CBEM_SETITEM, 0, (LPARAM)&cbexItem);
+    return SendMessageA(cbex, CBEM_SETITEMA, 0, (LPARAM)&cbexItem);
 }
 
 static LONG delItem(HWND cbex, int idx) {
-    return SendMessage(cbex, CBEM_DELETEITEM, idx, 0);
+    return SendMessageA(cbex, CBEM_DELETEITEM, idx, 0);
 }
 
-static LONG getItem(HWND cbex, int idx, COMBOBOXEXITEM *cbItem) {
-    memset(cbItem, 0x00, sizeof(COMBOBOXEXITEM));
+static LONG getItem(HWND cbex, int idx, COMBOBOXEXITEMA *cbItem) {
+    memset(cbItem, 0x00, sizeof(COMBOBOXEXITEMA));
     cbItem->mask = CBEIF_TEXT;
     cbItem->pszText      = textBuffer;
     cbItem->iItem        = idx;
     cbItem->cchTextMax   = 100;
-    return SendMessage(cbex, CBEM_GETITEM, 0, (LPARAM)cbItem);
+    return SendMessageA(cbex, CBEM_GETITEMA, 0, (LPARAM)cbItem);
 }
 
 static LRESULT WINAPI editbox_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
@@ -122,7 +122,7 @@ static HWND subclass_editbox(HWND hwndComboEx)
     WNDPROC oldproc;
     HWND hwnd;
 
-    hwnd = (HWND)SendMessage(hwndComboEx, CBEM_GETEDITCONTROL, 0, 0);
+    hwnd = (HWND)SendMessageA(hwndComboEx, CBEM_GETEDITCONTROL, 0, 0);
     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
                                          (LONG_PTR)editbox_subclass_proc);
     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
@@ -133,15 +133,13 @@ static HWND subclass_editbox(HWND hwndComboEx)
 static void test_comboboxex(void) {
     HWND myHwnd = 0;
     LONG res = -1;
-    COMBOBOXEXITEM cbexItem;
-    static TCHAR first_item[]        = {'F','i','r','s','t',' ','I','t','e','m',0},
-                 second_item[]       = {'S','e','c','o','n','d',' ','I','t','e','m',0},
-                 third_item[]        = {'T','h','i','r','d',' ','I','t','e','m',0},
-                 middle_item[]       = {'B','e','t','w','e','e','n',' ','F','i','r','s','t',' ','a','n','d',' ',
-                                        'S','e','c','o','n','d',' ','I','t','e','m','s',0},
-                 replacement_item[]  = {'B','e','t','w','e','e','n',' ','F','i','r','s','t',' ','a','n','d',' ',
-                                        'S','e','c','o','n','d',' ','I','t','e','m','s',0},
-                 out_of_range_item[] = {'O','u','t',' ','o','f',' ','R','a','n','g','e',' ','I','t','e','m',0};
+    COMBOBOXEXITEMA cbexItem;
+    static const char *first_item  = "First Item",
+                *second_item = "Second Item",
+                *third_item  = "Third Item",
+                *middle_item = "Between First and Second Items",
+                *replacement_item = "Between First and Second Items",
+                *out_of_range_item = "Out of Range Item";
 
     /* Allocate space for result */
     textBuffer = HeapAlloc(GetProcessHeap(), 0, MAX_CHARS);
@@ -271,8 +269,8 @@ static void test_WM_LBUTTONDOWN(void)
            "Failed to add item %d\n", i);
     }
 
-    hCombo = (HWND)SendMessage(hComboEx, CBEM_GETCOMBOCONTROL, 0, 0);
-    hEdit = (HWND)SendMessage(hComboEx, CBEM_GETEDITCONTROL, 0, 0);
+    hCombo = (HWND)SendMessageA(hComboEx, CBEM_GETCOMBOCONTROL, 0, 0);
+    hEdit = (HWND)SendMessageA(hComboEx, CBEM_GETEDITCONTROL, 0, 0);
 
     cbInfo.cbSize = sizeof(COMBOBOXINFO);
     result = pGetComboBoxInfo(hCombo, &cbInfo);
@@ -286,19 +284,19 @@ static void test_WM_LBUTTONDOWN(void)
     /* Click on the button to drop down the list */
     x = cbInfo.rcButton.left + (cbInfo.rcButton.right-cbInfo.rcButton.left)/2;
     y = cbInfo.rcButton.top + (cbInfo.rcButton.bottom-cbInfo.rcButton.top)/2;
-    result = SendMessage(hCombo, WM_LBUTTONDOWN, 0, MAKELPARAM(x, y));
+    result = SendMessageA(hCombo, WM_LBUTTONDOWN, 0, MAKELPARAM(x, y));
     ok(result, "WM_LBUTTONDOWN was not processed. LastError=%d\n",
        GetLastError());
     ok(GetFocus() == hCombo ||
        broken(GetFocus() != hCombo), /* win98 */
        "Focus not on ComboBoxEx's ComboBox Control, instead on %p\n",
        GetFocus());
-    ok(SendMessage(hComboEx, CB_GETDROPPEDSTATE, 0, 0),
+    ok(SendMessageA(hComboEx, CB_GETDROPPEDSTATE, 0, 0),
        "The dropdown list should have appeared after clicking the button.\n");
-    idx = SendMessage(hCombo, CB_GETTOPINDEX, 0, 0);
+    idx = SendMessageA(hCombo, CB_GETTOPINDEX, 0, 0);
     ok(idx == 0, "For TopIndex expected %d, got %d\n", 0, idx);
 
-    result = SendMessage(hCombo, WM_LBUTTONUP, 0, MAKELPARAM(x, y));
+    result = SendMessageA(hCombo, WM_LBUTTONUP, 0, MAKELPARAM(x, y));
     ok(result, "WM_LBUTTONUP was not processed. LastError=%d\n",
        GetLastError());
     ok(GetFocus() == hCombo ||
@@ -307,11 +305,11 @@ static void test_WM_LBUTTONDOWN(void)
        GetFocus());
 
     /* Click on the 5th item in the list */
-    item_height = SendMessage(hCombo, CB_GETITEMHEIGHT, 0, 0);
+    item_height = SendMessageA(hCombo, CB_GETITEMHEIGHT, 0, 0);
     ok(GetClientRect(hList, &rect), "Failed to get list's client rect.\n");
     x = rect.left + (rect.right-rect.left)/2;
     y = item_height/2 + item_height*4;
-    result = SendMessage(hList, WM_MOUSEMOVE, 0, MAKELPARAM(x, y));
+    result = SendMessageA(hList, WM_MOUSEMOVE, 0, MAKELPARAM(x, y));
     ok(!result, "WM_MOUSEMOVE was not processed. LastError=%d\n",
        GetLastError());
     ok(GetFocus() == hCombo ||
@@ -319,17 +317,17 @@ static void test_WM_LBUTTONDOWN(void)
        "Focus not on ComboBoxEx's ComboBox Control, instead on %p\n",
        GetFocus());
 
-    result = SendMessage(hList, WM_LBUTTONDOWN, 0, MAKELPARAM(x, y));
+    result = SendMessageA(hList, WM_LBUTTONDOWN, 0, MAKELPARAM(x, y));
     ok(!result, "WM_LBUTTONDOWN was not processed. LastError=%d\n",
        GetLastError());
     ok(GetFocus() == hCombo ||
        broken(GetFocus() != hCombo), /* win98 */
        "Focus not on ComboBoxEx's ComboBox Control, instead on %p\n",
        GetFocus());
-    ok(SendMessage(hComboEx, CB_GETDROPPEDSTATE, 0, 0),
+    ok(SendMessageA(hComboEx, CB_GETDROPPEDSTATE, 0, 0),
        "The dropdown list should still be visible.\n");
 
-    result = SendMessage(hList, WM_LBUTTONUP, 0, MAKELPARAM(x, y));
+    result = SendMessageA(hList, WM_LBUTTONUP, 0, MAKELPARAM(x, y));
     ok(!result, "WM_LBUTTONUP was not processed. LastError=%d\n",
        GetLastError());
     todo_wine ok(GetFocus() == hEdit ||
@@ -337,11 +335,11 @@ static void test_WM_LBUTTONDOWN(void)
        "Focus not on ComboBoxEx's Edit Control, instead on %p\n",
        GetFocus());
 
-    result = SendMessage(hCombo, CB_GETDROPPEDSTATE, 0, 0);
+    result = SendMessageA(hCombo, CB_GETDROPPEDSTATE, 0, 0);
     ok(!result ||
        broken(result != 0), /* win98 */
        "The dropdown list should have been rolled up.\n");
-    idx = SendMessage(hComboEx, CB_GETCURSEL, 0, 0);
+    idx = SendMessageA(hComboEx, CB_GETCURSEL, 0, 0);
     ok(idx == 4 ||
        broken(idx == -1), /* win98 */
        "Current Selection: expected %d, got %d\n", 4, idx);
@@ -372,18 +370,18 @@ static void test_CB_GETLBTEXT(void)
     item.iItem = 0;
     item.pszText = buff;
     item.cchTextMax = 1;
-    ret = SendMessage(hCombo, CBEM_GETITEMA, 0, (LPARAM)&item);
+    ret = SendMessageA(hCombo, CBEM_GETITEMA, 0, (LPARAM)&item);
     ok(ret != 0, "CBEM_GETITEM failed\n");
     ok(buff[0] == 0, "\n");
 
-    ret = SendMessage(hCombo, CB_GETLBTEXTLEN, 0, 0);
+    ret = SendMessageA(hCombo, CB_GETLBTEXTLEN, 0, 0);
     ok(ret == 0, "Expected zero length\n");
 
-    ret = SendMessage(hCombo, CB_GETLBTEXTLEN, 0, 0);
+    ret = SendMessageA(hCombo, CB_GETLBTEXTLEN, 0, 0);
     ok(ret == 0, "Expected zero length\n");
 
     buff[0] = 'a';
-    ret = SendMessage(hCombo, CB_GETLBTEXT, 0, (LPARAM)buff);
+    ret = SendMessageA(hCombo, CB_GETLBTEXT, 0, (LPARAM)buff);
     ok(ret == 0, "Expected zero length\n");
     ok(buff[0] == 0, "Expected null terminator as a string, got %s\n", buff);
 
@@ -477,7 +475,7 @@ static LRESULT CALLBACK ComboExTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, L
     return 0L;
 }
 
-static int init(void)
+static BOOL init(void)
 {
     HMODULE hComctl32;
     BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
@@ -489,7 +487,7 @@ static int init(void)
     if (!pInitCommonControlsEx)
     {
         win_skip("InitCommonControlsEx() is missing. Skipping the tests\n");
-        return 0;
+        return FALSE;
     }
     iccex.dwSize = sizeof(iccex);
     iccex.dwICC  = ICC_USEREX_CLASSES;
@@ -502,7 +500,7 @@ static int init(void)
     wc.cbWndExtra = 0;
     wc.hInstance = GetModuleHandleA(NULL);
     wc.hIcon = NULL;
-    wc.hCursor = LoadCursorA(NULL, IDC_ARROW);
+    wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
     wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
     wc.lpszMenuName = NULL;
     wc.lpszClassName = ComboExTestClass;
@@ -511,10 +509,11 @@ static int init(void)
 
     hComboExParentWnd = CreateWindowExA(0, ComboExTestClass, "ComboEx test", WS_OVERLAPPEDWINDOW|WS_VISIBLE,
       CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, GetModuleHandleA(NULL), 0);
-    assert(hComboExParentWnd != NULL);
+    ok(hComboExParentWnd != NULL, "failed to create parent window\n");
 
     hMainHinst = GetModuleHandleA(NULL);
-    return 1;
+
+    return hComboExParentWnd != NULL;
 }
 
 static void cleanup(void)
@@ -537,9 +536,9 @@ static void test_comboboxex_subclass(void)
 
     hComboEx = createComboEx(WS_BORDER | WS_VISIBLE | WS_CHILD | CBS_DROPDOWN);
 
-    hCombo = (HWND)SendMessage(hComboEx, CBEM_GETCOMBOCONTROL, 0, 0);
+    hCombo = (HWND)SendMessageA(hComboEx, CBEM_GETCOMBOCONTROL, 0, 0);
     ok(hCombo != NULL, "Failed to get internal combo\n");
-    hEdit = (HWND)SendMessage(hComboEx, CBEM_GETEDITCONTROL, 0, 0);
+    hEdit = (HWND)SendMessageA(hComboEx, CBEM_GETEDITCONTROL, 0, 0);
     ok(hEdit != NULL, "Failed to get internal edit\n");
 
     if (pSetWindowSubclass)
@@ -575,7 +574,7 @@ static void test_get_set_item(void)
     item.mask = CBEIF_TEXT;
     item.pszText = textA;
     item.iItem = -1;
-    ret = SendMessage(hComboEx, CBEM_SETITEMA, 0, (LPARAM)&item);
+    ret = SendMessageA(hComboEx, CBEM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, ret);
 
     ok_sequence(sequences, EDITBOX_SEQ_INDEX, test_setitem_edit_seq, "set item data for edit", FALSE);
@@ -584,16 +583,16 @@ static void test_get_set_item(void)
     item.mask = CBEIF_LPARAM;
     item.iItem = -1;
     item.lParam = 0xdeadbeef;
-    ret = SendMessage(hComboEx, CBEM_GETITEMA, 0, (LPARAM)&item);
+    ret = SendMessageA(hComboEx, CBEM_GETITEMA, 0, (LPARAM)&item);
     expect(TRUE, ret);
     ok(item.lParam == 0, "Expected zero, got %lx\n", item.lParam);
 
     item.lParam = 0x1abe11ed;
-    ret = SendMessage(hComboEx, CBEM_SETITEMA, 0, (LPARAM)&item);
+    ret = SendMessageA(hComboEx, CBEM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, ret);
 
     item.lParam = 0;
-    ret = SendMessage(hComboEx, CBEM_GETITEMA, 0, (LPARAM)&item);
+    ret = SendMessageA(hComboEx, CBEM_GETITEMA, 0, (LPARAM)&item);
     expect(TRUE, ret);
     ok(item.lParam == 0x1abe11ed, "Expected 0x1abe11ed, got %lx\n", item.lParam);
 
index 1a21f84..415e72f 100644 (file)
@@ -165,8 +165,8 @@ static HWND create_datetime_control(DWORD style)
     WNDPROC oldproc;
     HWND hWndDateTime = NULL;
 
-    hWndDateTime = CreateWindowEx(0,
-        DATETIMEPICK_CLASS,
+    hWndDateTime = CreateWindowExA(0,
+        DATETIMEPICK_CLASSA,
         NULL,
         style,
         0,50,300,120,
@@ -195,24 +195,23 @@ static void test_dtm_set_format(void)
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hWnd, DTM_SETFORMAT, 0, 0);
+    r = SendMessageA(hWnd, DTM_SETFORMATA, 0, 0);
     expect(1, r);
 
-    r = SendMessage(hWnd, DTM_SETFORMAT, 0,
+    r = SendMessageA(hWnd, DTM_SETFORMATA, 0,
                    (LPARAM)"'Today is: 'hh':'m':'s dddd MMM dd', 'yyyy");
     expect(1, r);
 
     ok_sequence(sequences, DATETIME_SEQ_INDEX, test_dtm_set_format_seq, "test_dtm_set_format", FALSE);
 
-    r = SendMessage(hWnd, DTM_SETFORMAT, 0,
-                   (LPARAM)"'hh' hh");
+    r = SendMessageA(hWnd, DTM_SETFORMATA, 0, (LPARAM)"'hh' hh");
     expect(1, r);
     ZeroMemory(&systime, sizeof(systime));
     systime.wYear = 2000;
     systime.wMonth = systime.wDay = 1;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, 0, (LPARAM)&systime);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, 0, (LPARAM)&systime);
     expect(1, r);
-    GetWindowText(hWnd, txt, 256);
+    GetWindowTextA(hWnd, txt, 256);
     ok(strcmp(txt, "hh 12") == 0, "String mismatch (\"%s\" vs \"hh 12\")\n", txt);
 
     DestroyWindow(hWnd);
@@ -223,17 +222,17 @@ static void test_mccolor_types(HWND hWndDateTime, int mccolor_type, const char*
     COLORREF theColor, prevColor, crColor;
 
     theColor=RGB(0,0,0);
-    crColor = SendMessage(hWndDateTime, DTM_SETMCCOLOR, mccolor_type, theColor);
+    crColor = SendMessageA(hWndDateTime, DTM_SETMCCOLOR, mccolor_type, theColor);
     ok(crColor != ~0u, "%s: Set RGB(0,0,0): Expected COLORREF of previous value, got %d\n", mccolor_name, crColor);
     prevColor=theColor;
     theColor=RGB(255,255,255);
-    crColor = SendMessage(hWndDateTime, DTM_SETMCCOLOR, mccolor_type, theColor);
+    crColor = SendMessageA(hWndDateTime, DTM_SETMCCOLOR, mccolor_type, theColor);
     ok(crColor==prevColor, "%s: Set RGB(255,255,255): Expected COLORREF of previous value, got %d\n", mccolor_name, crColor);
     prevColor=theColor;
     theColor=RGB(100,180,220);
-    crColor = SendMessage(hWndDateTime, DTM_SETMCCOLOR, mccolor_type, theColor);
+    crColor = SendMessageA(hWndDateTime, DTM_SETMCCOLOR, mccolor_type, theColor);
     ok(crColor==prevColor, "%s: Set RGB(100,180,220): Expected COLORREF of previous value, got %d\n", mccolor_name, crColor);
-    crColor = SendMessage(hWndDateTime, DTM_GETMCCOLOR, mccolor_type, 0);
+    crColor = SendMessageA(hWndDateTime, DTM_GETMCCOLOR, mccolor_type, 0);
     ok(crColor==theColor, "%s: GETMCCOLOR: Expected %d, got %d\n", mccolor_name, theColor, crColor);
 }
 
@@ -267,8 +266,8 @@ static void test_dtm_set_and_get_mcfont(void)
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
     hFontOrig = GetStockObject(DEFAULT_GUI_FONT);
-    SendMessage(hWnd, DTM_SETMCFONT, (WPARAM)hFontOrig, TRUE);
-    hFontNew = (HFONT)SendMessage(hWnd, DTM_GETMCFONT, 0, 0);
+    SendMessageA(hWnd, DTM_SETMCFONT, (WPARAM)hFontOrig, TRUE);
+    hFontNew = (HFONT)SendMessageA(hWnd, DTM_GETMCFONT, 0, 0);
     ok(hFontOrig == hFontNew, "Expected hFontOrig==hFontNew, hFontOrig=%p, hFontNew=%p\n", hFontOrig, hFontNew);
 
     ok_sequence(sequences, DATETIME_SEQ_INDEX, test_dtm_set_and_get_mcfont_seq, "test_dtm_set_and_get_mcfont", FALSE);
@@ -285,7 +284,7 @@ static void test_dtm_get_monthcal(void)
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
     todo_wine {
-        r = SendMessage(hWnd, DTM_GETMONTHCAL, 0, 0);
+        r = SendMessageA(hWnd, DTM_GETMONTHCAL, 0, 0);
         ok(r == 0, "Expected NULL(no child month calendar control), got %ld\n", r);
     }
 
@@ -349,13 +348,13 @@ static void test_dtm_set_and_get_range(void)
     /* initialize st[1] to all invalid numbers */
     fill_systime_struct(&st[1], 0, 0, 7, 0, 24, 60, 60, 1000);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == GDTR_MIN, "Expected %x, not %x(GDTR_MAX) or %x(GDTR_MIN | GDTR_MAX), got %lx\n", GDTR_MIN, GDTR_MAX, GDTR_MIN | GDTR_MAX, r);
     expect_systime(&st[0], &getSt[0]);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MAX, (LPARAM)st);
     expect_unsuccess(0, r);
 
     /* set st[0] to all invalid numbers */
@@ -363,25 +362,25 @@ static void test_dtm_set_and_get_range(void)
     /* set st[1] to highest possible value */
     fill_systime_struct(&st[1], 30827, 12, 6, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     todo_wine {
         ok(r == GDTR_MAX, "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MIN | GDTR_MAX), got %lx\n", GDTR_MAX, GDTR_MIN, GDTR_MIN | GDTR_MAX, r);
     }
     expect_systime(&st[1], &getSt[1]);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN, (LPARAM)st);
     expect_unsuccess(0, r);
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect_unsuccess(0, r);
 
     /* set st[0] to highest possible value */
     fill_systime_struct(&st[0], 30827, 12, 6, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     expect_systime(&st[0], &getSt[0]);
     expect_systime(&st[1], &getSt[1]);
@@ -391,9 +390,9 @@ static void test_dtm_set_and_get_range(void)
     /* set st[1] to highest possible value */
     fill_systime_struct(&st[1], 30827, 12, 6, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     expect_systime(&st[0], &getSt[0]);
     expect_systime(&st[1], &getSt[1]);
@@ -403,9 +402,9 @@ static void test_dtm_set_and_get_range(void)
     /* set st[1] to value lower than maximum */
     fill_systime_struct(&st[1], 2007, 3, 2, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     expect_systime(&st[0], &getSt[0]);
     expect_systime(&st[1], &getSt[1]);
@@ -431,9 +430,9 @@ static void test_dtm_set_range_swap_min_max(void)
 
     fill_systime_struct(&st[0], 2007, 2, 4, 15, 2, 2, 2, 2);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&origSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&origSt);
     ok(r == GDT_VALID, "Expected %d, not %d(GDT_NONE) or %d(GDT_ERROR), got %ld\n", GDT_VALID, GDT_NONE, GDT_ERROR, r);
     expect_systime(&st[0], &origSt);
 
@@ -443,9 +442,9 @@ static void test_dtm_set_range_swap_min_max(void)
 
     /* since min>max, min and max values should be swapped by DTM_SETRANGE
     automatically */
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     todo_wine {
         ok(compare_systime(&st[0], &getSt[0]) == 1 ||
@@ -459,9 +458,9 @@ static void test_dtm_set_range_swap_min_max(void)
 
     fill_systime_struct(&st[0], 1980, 1, 3, 23, 14, 34, 37, 465);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
     ok(r == GDT_VALID, "Expected %d, not %d(GDT_NONE) or %d(GDT_ERROR), got %ld\n", GDT_VALID, GDT_NONE, GDT_ERROR, r);
     /* the time part seems to not change after swapping the min and max values
     and doing DTM_SETSYSTEMTIME */
@@ -477,12 +476,12 @@ static void test_dtm_set_range_swap_min_max(void)
     /* set st[1] to value lower than maximum */
     fill_systime_struct(&st[1], 2007, 3, 2, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
     /* for some reason after we swapped the min and max values before,
     whenever we do a DTM_SETRANGE, the DTM_GETRANGE will return the values
     swapped*/
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     todo_wine {
         ok(compare_systime(&st[0], &getSt[1]) == 1 ||
@@ -500,9 +499,9 @@ static void test_dtm_set_range_swap_min_max(void)
 
     /* set min>max again, so that the return values of DTM_GETRANGE are no
     longer swapped the next time we do a DTM SETRANGE and DTM_GETRANGE*/
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     expect_systime(&st[0], &getSt[1]);
     expect_systime(&st[1], &getSt[0]);
@@ -512,9 +511,9 @@ static void test_dtm_set_range_swap_min_max(void)
     /* set st[1] to highest possible value */
     fill_systime_struct(&st[1], 30827, 12, 6, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     expect_systime(&st[0], &getSt[0]);
     expect_systime(&st[1], &getSt[1]);
@@ -534,7 +533,7 @@ static void test_dtm_set_and_get_system_time(void)
 
     ok(hWndDateTime_test_gdt_none!=NULL, "Expected non NULL, got %p\n", hWndDateTime_test_gdt_none);
     if(hWndDateTime_test_gdt_none) {
-        r = SendMessage(hWndDateTime_test_gdt_none, DTM_SETSYSTEMTIME, GDT_NONE, (LPARAM)&st);
+        r = SendMessageA(hWndDateTime_test_gdt_none, DTM_SETSYSTEMTIME, GDT_NONE, (LPARAM)&st);
         expect(0, r);
     }
     else {
@@ -549,128 +548,128 @@ static void test_dtm_set_and_get_system_time(void)
     hWnd = create_datetime_control(DTS_SHOWNONE);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_NONE, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_NONE, (LPARAM)&st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     ok(r == GDT_NONE, "Expected %d, not %d(GDT_VALID) or %d(GDT_ERROR), got %ld\n", GDT_NONE, GDT_VALID, GDT_ERROR, r);
 
     /* set st to lowest possible value */
     fill_systime_struct(&st, 1601, 1, 0, 1, 0, 0, 0, 0);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(1, r);
 
     /* set st to highest possible value */
     fill_systime_struct(&st, 30827, 12, 6, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(1, r);
 
     /* set st to value between min and max */
     fill_systime_struct(&st, 1980, 1, 3, 23, 14, 34, 37, 465);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     ok(r == GDT_VALID, "Expected %d, not %d(GDT_NONE) or %d(GDT_ERROR), got %ld\n", GDT_VALID, GDT_NONE, GDT_ERROR, r);
     expect_systime(&st, &getSt);
 
     /* set st to invalid value */
     fill_systime_struct(&st, 0, 0, 7, 0, 24, 60, 60, 1000);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect_unsuccess(0, r);
 
     ok_sequence(sequences, DATETIME_SEQ_INDEX, test_dtm_set_and_get_system_time_seq, "test_dtm_set_and_get_system_time", FALSE);
 
     /* set to some valid value */
     GetSystemTime(&ref);
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&ref);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&ref);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
 
     /* year invalid */
     st = ref;
     st.wYear = 0;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     todo_wine expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* month invalid */
     st = ref;
     st.wMonth = 13;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(0, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* day invalid */
     st = ref;
     st.wDay = 32;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(0, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* day invalid for current month */
     st = ref;
     st.wDay = 30;
     st.wMonth = 2;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(0, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* day of week isn't validated */
     st = ref;
     st.wDayOfWeek = 10;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* hour invalid */
     st = ref;
     st.wHour = 25;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(0, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* minute invalid */
     st = ref;
     st.wMinute = 60;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(0, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* sec invalid */
     st = ref;
     st.wSecond = 60;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(0, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
     /* msec invalid */
     st = ref;
     st.wMilliseconds = 1000;
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(0, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     expect_systime(&ref, &getSt);
 
     /* day of week should be calculated automatically,
        actual day of week for this date is 4 */
     fill_systime_struct(&st, 2009, 10, 1, 1, 0, 0, 10, 200);
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt);
     expect(GDT_VALID, r);
     /* 01.10.2009 is Thursday */
     expect(4, (LRESULT)getSt.wDayOfWeek);
@@ -692,35 +691,35 @@ static void test_dtm_set_and_get_systemtime_with_limits(void)
     fill_systime_struct(&st[0], 1980, 1, 3, 23, 14, 34, 37, 465);
     fill_systime_struct(&st[1], 2007, 3, 2, 31, 23, 59, 59, 999);
 
-    r = SendMessage(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
+    r = SendMessageA(hWnd, DTM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
+    r = SendMessageA(hWnd, DTM_GETRANGE, 0, (LPARAM)getSt);
     ok(r == (GDTR_MIN | GDTR_MAX), "Expected %x, not %x(GDTR_MIN) or %x(GDTR_MAX), got %lx\n", (GDTR_MIN | GDTR_MAX), GDTR_MIN, GDTR_MAX, r);
     expect_systime(&st[0], &getSt[0]);
     expect_systime(&st[1], &getSt[1]);
 
     /* Initially set a valid time */
     fill_systime_struct(&refSt, 1999, 9, 4, 9, 19, 9, 9, 999);
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&refSt);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&refSt);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
     ok(r == GDT_VALID, "Expected %d, not %d(GDT_NONE) or %d(GDT_ERROR), got %ld\n", GDT_VALID, GDT_NONE, GDT_ERROR, r);
     expect_systime(&refSt, &getSt[0]);
 
     /* Now set an out-of-bounds time */
     fill_systime_struct(&st[0], 2010, 1, 0, 1, 0, 0, 0, 0);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
     ok(r == GDT_VALID, "Expected %d, not %d(GDT_NONE) or %d(GDT_ERROR), got %ld\n", GDT_VALID, GDT_NONE, GDT_ERROR, r);
     expect_systime(&refSt, &getSt[0]);
 
     fill_systime_struct(&st[0], 1977, 1, 0, 1, 0, 0, 0, 0);
 
-    r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
+    r = SendMessageA(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st[0]);
     expect(1, r);
-    r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
+    r = SendMessageA(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt[0]);
     ok(r == GDT_VALID, "Expected %d, not %d(GDT_NONE) or %d(GDT_ERROR), got %ld\n", GDT_VALID, GDT_NONE, GDT_ERROR, r);
     expect_systime(&refSt, &getSt[0]);
 
@@ -738,14 +737,14 @@ static void test_wm_set_get_text(void)
 
     hWnd = create_datetime_control(0);
 
-    ret = SendMessage(hWnd, WM_SETTEXT, 0, (LPARAM)a_str);
+    ret = SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)a_str);
     ok(CB_ERR == ret ||
        broken(0 == ret) || /* comctl32 <= 4.72 */
        broken(1 == ret), /* comctl32 <= 4.70 */
        "Expected CB_ERR, got %ld\n", ret);
 
     buff[0] = 0;
-    ret = SendMessage(hWnd, WM_GETTEXT, sizeof(buff), (LPARAM)buff);
+    ret = SendMessageA(hWnd, WM_GETTEXT, sizeof(buff), (LPARAM)buff);
     ok(strcmp(buff, a_str) != 0, "Expected text to change, got %s\n", buff);
     ok(ret != 0, "Expected non-zero return value\n");
 
@@ -757,7 +756,7 @@ static void test_wm_set_get_text(void)
         skip("DateTimePicker Control only supports Gregorian calendar (type: %s)\n", caltype);
     else {
         SetLastError(0xdeadbeef);
-        ret = GetDateFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, time, sizeof(time));
+        ret = GetDateFormatA(LOCALE_USER_DEFAULT, 0, NULL, NULL, time, sizeof(time));
         if (ret == 0)
             skip("GetDateFormat failed, returned %ld, error %d\n", ret, GetLastError());
         else
@@ -774,16 +773,16 @@ static void test_dts_shownone(void)
 
     /* it isn't allowed to change DTS_SHOWNONE after creation */
     hwnd = create_datetime_control(0);
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    SetWindowLong(hwnd, GWL_STYLE, style | DTS_SHOWNONE);
-    style = GetWindowLong(hwnd, GWL_STYLE);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
+    SetWindowLongA(hwnd, GWL_STYLE, style | DTS_SHOWNONE);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
     ok(!(style & DTS_SHOWNONE), "Expected DTS_SHOWNONE not to be set\n");
     DestroyWindow(hwnd);
 
     hwnd = create_datetime_control(DTS_SHOWNONE);
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    SetWindowLong(hwnd, GWL_STYLE, style & ~DTS_SHOWNONE);
-    style = GetWindowLong(hwnd, GWL_STYLE);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
+    SetWindowLongA(hwnd, GWL_STYLE, style & ~DTS_SHOWNONE);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
     ok(style & DTS_SHOWNONE, "Expected DTS_SHOWNONE to be set\n");
     DestroyWindow(hwnd);
 }
index 7c7f99b..6a8230a 100644 (file)
@@ -45,24 +45,24 @@ typedef struct _STREAMDATA
     DWORD dwItems;
 } STREAMDATA, *PSTREAMDATA;
 
-static HDPA    (WINAPI *pDPA_Clone)(const HDPA,const HDPA);
+static HDPA    (WINAPI *pDPA_Clone)(const HDPA,HDPA);
 static HDPA    (WINAPI *pDPA_Create)(INT);
 static HDPA    (WINAPI *pDPA_CreateEx)(INT,HANDLE);
-static PVOID   (WINAPI *pDPA_DeleteAllPtrs)(const HDPA);
-static PVOID   (WINAPI *pDPA_DeletePtr)(const HDPA,INT);
-static BOOL    (WINAPI *pDPA_Destroy)(const HDPA);
+static PVOID   (WINAPI *pDPA_DeleteAllPtrs)(HDPA);
+static PVOID   (WINAPI *pDPA_DeletePtr)(HDPA,INT);
+static BOOL    (WINAPI *pDPA_Destroy)(HDPA);
 static VOID    (WINAPI *pDPA_DestroyCallback)(HDPA,PFNDPAENUMCALLBACK,PVOID);
 static VOID    (WINAPI *pDPA_EnumCallback)(HDPA,PFNDPAENUMCALLBACK,PVOID); 
-static INT     (WINAPI *pDPA_GetPtr)(const HDPA,INT);
-static INT     (WINAPI *pDPA_GetPtrIndex)(const HDPA,PVOID);
+static INT     (WINAPI *pDPA_GetPtr)(HDPA,INT);
+static INT     (WINAPI *pDPA_GetPtrIndex)(HDPA,PVOID);
 static BOOL    (WINAPI *pDPA_Grow)(HDPA,INT);
-static INT     (WINAPI *pDPA_InsertPtr)(const HDPA,INT,PVOID);
+static INT     (WINAPI *pDPA_InsertPtr)(HDPA,INT,PVOID);
 static HRESULT (WINAPI *pDPA_LoadStream)(HDPA*,PFNDPASTREAM,IStream*,LPVOID);
-static BOOL    (WINAPI *pDPA_Merge)(const HDPA,const HDPA,DWORD,PFNDPACOMPARE,PFNDPAMERGE,LPARAM);
+static BOOL    (WINAPI *pDPA_Merge)(HDPA,HDPA,DWORD,PFNDPACOMPARE,PFNDPAMERGE,LPARAM);
 static HRESULT (WINAPI *pDPA_SaveStream)(HDPA,PFNDPASTREAM,IStream*,LPVOID);
 static INT     (WINAPI *pDPA_Search)(HDPA,PVOID,INT,PFNDPACOMPARE,LPARAM,UINT);
-static BOOL    (WINAPI *pDPA_SetPtr)(const HDPA,INT,PVOID);
-static BOOL    (WINAPI *pDPA_Sort)(const HDPA,PFNDPACOMPARE,LPARAM);
+static BOOL    (WINAPI *pDPA_SetPtr)(HDPA,INT,PVOID);
+static BOOL    (WINAPI *pDPA_Sort)(HDPA,PFNDPACOMPARE,LPARAM);
 
 #define COMCTL32_GET_PROC(func, ord) \
   ((p ## func = (PVOID)GetProcAddress(hcomctl32,(LPCSTR)ord)) ? 1 \
index 1502970..90d4ea1 100644 (file)
@@ -27,6 +27,7 @@
 #include <windef.h>
 #include <winbase.h>
 #include <wingdi.h>
+#include <winuser.h>
 #include <winnls.h>
 #include <objbase.h>
 #include <commctrl.h>
@@ -106,16 +107,16 @@ static const struct message add_header_to_parent_seq[] = {
 };
 
 static const struct message insertItem_seq[] = {
-    { HDM_INSERTITEM, sent|wparam, 0 },
-    { HDM_INSERTITEM, sent|wparam, 1 },
-    { HDM_INSERTITEM, sent|wparam, 2 },
-    { HDM_INSERTITEM, sent|wparam, 3 },
+    { HDM_INSERTITEMA, sent|wparam, 0 },
+    { HDM_INSERTITEMA, sent|wparam, 1 },
+    { HDM_INSERTITEMA, sent|wparam, 2 },
+    { HDM_INSERTITEMA, sent|wparam, 3 },
     { 0 }
 };
 
 static const struct message getItem_seq[] = {
-    { HDM_GETITEM, sent|wparam, 3 },
-    { HDM_GETITEM, sent|wparam, 0 },
+    { HDM_GETITEMA, sent|wparam, 3 },
+    { HDM_GETITEMA, sent|wparam, 0 },
     { 0 }
 };
 
@@ -137,8 +138,8 @@ static const struct message orderArray_seq[] = {
 };
 
 static const struct message setItem_seq[] = {
-    { HDM_SETITEM, sent|wparam, 0 },
-    { HDM_SETITEM, sent|wparam, 1 },
+    { HDM_SETITEMA, sent|wparam, 0 },
+    { HDM_SETITEMA, sent|wparam, 1 },
     { 0 }
 };
 
@@ -225,17 +226,21 @@ static const struct message bitmapmarginMessages_seq[] = {
 
 static void expect_notify(INT iCode, BOOL fUnicode, HDITEMA *lpItem)
 {
-    assert(nExpectedNotify < 10);
-    expectedNotify[nExpectedNotify].iCode = iCode;
-    expectedNotify[nExpectedNotify].fUnicode = fUnicode;
-    expectedNotify[nExpectedNotify].hdItem = *lpItem;
-    nExpectedNotify++;
+    ok(nExpectedNotify < 10, "notification count %d\n", nExpectedNotify);
+    if (nExpectedNotify < 10)
+    {
+        expectedNotify[nExpectedNotify].iCode = iCode;
+        expectedNotify[nExpectedNotify].fUnicode = fUnicode;
+        expectedNotify[nExpectedNotify].hdItem = *lpItem;
+        nExpectedNotify++;
+    }
 }
 
 static void dont_expect_notify(INT iCode)
 {
-    assert(nUnexpectedNotify < 10);
-    unexpectedNotify[nUnexpectedNotify++] = iCode;
+    ok(nExpectedNotify < 10, "notification count %d\n", nExpectedNotify);
+    if (nExpectedNotify < 10)
+        unexpectedNotify[nUnexpectedNotify++] = iCode;
 }
 
 static BOOL notifies_received(void)
@@ -253,7 +258,7 @@ static LONG addItem(HWND hdex, int idx, LPSTR text)
     hdItem.cxy        = 100;
     hdItem.pszText    = text;
     hdItem.cchTextMax = 0;
-    return SendMessage(hdex, HDM_INSERTITEMA, idx, (LPARAM)&hdItem);
+    return SendMessageA(hdex, HDM_INSERTITEMA, idx, (LPARAM)&hdItem);
 }
 
 static LONG setItem(HWND hdex, int idx, LPSTR text, BOOL fCheckNotifies)
@@ -268,7 +273,7 @@ static LONG setItem(HWND hdex, int idx, LPSTR text, BOOL fCheckNotifies)
         expect_notify(HDN_ITEMCHANGINGA, FALSE, &hdexItem);
         expect_notify(HDN_ITEMCHANGEDA, FALSE, &hdexItem);
     }
-    ret = SendMessage(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
+    ret = SendMessageA(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
     if (fCheckNotifies)
         ok(notifies_received(), "setItem(): not all expected notifies were received\n");
     return ret;
@@ -288,19 +293,19 @@ static LONG setItemUnicodeNotify(HWND hdex, int idx, LPSTR text, LPWSTR wText)
     
     expect_notify(HDN_ITEMCHANGINGW, TRUE, (HDITEMA*)&hdexNotify);
     expect_notify(HDN_ITEMCHANGEDW, TRUE, (HDITEMA*)&hdexNotify);
-    ret = SendMessage(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
+    ret = SendMessageA(hdex, HDM_SETITEMA, idx, (LPARAM)&hdexItem);
     ok(notifies_received(), "setItemUnicodeNotify(): not all expected notifies were received\n");
     return ret;
 }
 
 static LONG delItem(HWND hdex, int idx)
 {
-    return SendMessage(hdex, HDM_DELETEITEM, idx, 0);
+    return SendMessageA(hdex, HDM_DELETEITEM, idx, 0);
 }
 
 static LONG getItemCount(HWND hdex)
 {
-    return SendMessage(hdex, HDM_GETITEMCOUNT, 0, 0);
+    return SendMessageA(hdex, HDM_GETITEMCOUNT, 0, 0);
 }
 
 static LONG getItem(HWND hdex, int idx, LPSTR textBuffer)
@@ -309,16 +314,16 @@ static LONG getItem(HWND hdex, int idx, LPSTR textBuffer)
     hdItem.mask         = HDI_TEXT;
     hdItem.pszText      = textBuffer;
     hdItem.cchTextMax   = MAX_CHARS;
-    return SendMessage(hdex, HDM_GETITEMA, idx, (LPARAM)&hdItem);
+    return SendMessageA(hdex, HDM_GETITEMA, idx, (LPARAM)&hdItem);
 }
 
 static void addReadDelItem(HWND hdex, HDITEMA *phdiCreate, int maskRead, HDITEMA *phdiRead)
 {
-    ok(SendMessage(hdex, HDM_INSERTITEMA, 0, (LPARAM)phdiCreate)!=-1, "Adding item failed\n");
+    ok(SendMessageA(hdex, HDM_INSERTITEMA, 0, (LPARAM)phdiCreate)!=-1, "Adding item failed\n");
     ZeroMemory(phdiRead, sizeof(HDITEMA));
     phdiRead->mask = maskRead;
-    ok(SendMessage(hdex, HDM_GETITEMA, 0, (LPARAM)phdiRead)!=0, "Getting item data failed\n");
-    ok(SendMessage(hdex, HDM_DELETEITEM, 0, 0)!=0, "Deleting item failed\n");
+    ok(SendMessageA(hdex, HDM_GETITEMA, 0, (LPARAM)phdiRead)!=0, "Getting item data failed\n");
+    ok(SendMessageA(hdex, HDM_DELETEITEM, 0, 0)!=0, "Deleting item failed\n");
 }
 
 static HWND create_header_control (void)
@@ -328,11 +333,11 @@ static HWND create_header_control (void)
     RECT rectwin;
     WINDOWPOS winpos;
 
-    handle = CreateWindowEx(0, WC_HEADER, NULL,
-                           WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
-                           0, 0, 0, 0,
-                           hHeaderParentWnd, NULL, NULL, NULL);
-    assert(handle);
+    handle = CreateWindowExA(0, WC_HEADERA, NULL,
+                            WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
+                            0, 0, 0, 0,
+                            hHeaderParentWnd, NULL, NULL, NULL);
+    ok(handle != NULL, "failed to create header window\n");
 
     if (winetest_interactive)
        ShowWindow (hHeaderParentWnd, SW_SHOW);
@@ -340,7 +345,7 @@ static HWND create_header_control (void)
     GetClientRect(hHeaderParentWnd,&rectwin);
     hlayout.prc = &rectwin;
     hlayout.pwpos = &winpos;
-    SendMessageA(handle,HDM_LAYOUT,0,(LPARAM) &hlayout);
+    SendMessageA(handle, HDM_LAYOUT, 0, (LPARAM)&hlayout);
     SetWindowPos(handle, winpos.hwndInsertAfter, winpos.x, winpos.y, 
                  winpos.cx, winpos.cy, 0);
 
@@ -448,6 +453,7 @@ static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LP
         if (defwndproc_counter) msg.flags |= defwinproc;
         msg.wParam = wParam;
         msg.lParam = lParam;
+        msg.id = 0;
         add_message(sequences, PARENT_SEQ_INDEX, &msg);
    }
 
@@ -468,7 +474,7 @@ static BOOL register_parent_wnd_class(void)
     cls.cbWndExtra = 0;
     cls.hInstance = GetModuleHandleA(NULL);
     cls.hIcon = 0;
-    cls.hCursor = LoadCursorA(0, IDC_ARROW);
+    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
     cls.lpszMenuName = NULL;
     cls.lpszClassName = "Header test parent class";
@@ -499,26 +505,25 @@ static HWND create_custom_header_control(HWND hParent, BOOL preloadHeaderItems)
     static char firstHeaderItem[] = "Name";
     static char secondHeaderItem[] = "Size";
     static char *items[] = {secondHeaderItem, firstHeaderItem};
-    HDITEM hdItem;
+    HDITEMA hdItem;
     hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
     hdItem.fmt = HDF_LEFT;
     hdItem.cxy = 80;
     hdItem.cchTextMax = 260;
 
-
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    childHandle = CreateWindowEx(0, WC_HEADER, NULL,
+    childHandle = CreateWindowExA(0, WC_HEADERA, NULL,
                            WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
                            0, 0, 0, 0,
                            hParent, NULL, NULL, NULL);
-    assert(childHandle);
+    ok(childHandle != NULL, "failed to create child window\n");
     if (preloadHeaderItems)
     {
          for ( loopcnt = 0 ; loopcnt < 2 ; loopcnt++ )
          {
              hdItem.pszText = items[loopcnt];
-             retVal = SendMessage(childHandle, HDM_INSERTITEM, loopcnt, (LPARAM) &hdItem);
+             retVal = SendMessageA(childHandle, HDM_INSERTITEMA, loopcnt, (LPARAM) &hdItem);
              ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), retVal);
           }
     }
@@ -661,24 +666,24 @@ static void check_mask(void)
     hdi.iOrder = 0;
     hdi.lParam = 17;
     hdi.cchTextMax = 260;
-    ret = SendMessage(hWndHeader, HDM_INSERTITEM, 0, (LPARAM)&hdi);
+    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
     ok(ret == -1, "Creating an item with a zero mask should have failed\n");
-    if (ret != -1) SendMessage(hWndHeader, HDM_DELETEITEM, 0, 0);
+    if (ret != -1) SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
 
     /* with a non-zero mask creation will succeed */
     ZeroMemory(&hdi, sizeof(hdi));
     hdi.mask = HDI_LPARAM;
-    ret = SendMessage(hWndHeader, HDM_INSERTITEM, 0, (LPARAM)&hdi);
+    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
     ok(ret != -1, "Adding item with non-zero mask failed\n");
     if (ret != -1)
-        SendMessage(hWndHeader, HDM_DELETEITEM, 0, 0);
+        SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
 
     /* in SETITEM if the mask contains a unknown bit, it is ignored */
     ZeroMemory(&hdi, sizeof(hdi));
     hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
     hdi.lParam = 133;
     hdi.iImage = 17;
-    ret = SendMessage(hWndHeader, HDM_INSERTITEM, 0, (LPARAM)&hdi);
+    ret = SendMessageA(hWndHeader, HDM_INSERTITEMA, 0, (LPARAM)&hdi);
     ok(ret != -1, "Adding item failed\n");
 
     if (ret != -1)
@@ -686,18 +691,18 @@ static void check_mask(void)
         /* check result */
         ZeroMemory(&hdi, sizeof(hdi));
         hdi.mask = HDI_LPARAM | HDI_IMAGE;
-        SendMessage(hWndHeader, HDM_GETITEM, 0, (LPARAM)&hdi);
+        SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
         ok(hdi.lParam == 133, "comctl32 4.0 field not set\n");
         ok(hdi.iImage == 17, "comctl32 >4.0 field not set\n");
 
         /* but in GETITEM if an unknown bit is set, comctl32 uses only version 4.0 fields */
         ZeroMemory(&hdi, sizeof(hdi));
         hdi.mask = 0x08000000 | HDI_LPARAM | HDI_IMAGE;
-        SendMessage(hWndHeader, HDM_GETITEM, 0, (LPARAM)&hdi);
+        SendMessageA(hWndHeader, HDM_GETITEMA, 0, (LPARAM)&hdi);
         ok(hdi.lParam == 133, "comctl32 4.0 field not read\n");
         ok(hdi.iImage == 0, "comctl32 >4.0 field shouldn't be read\n");
 
-        SendMessage(hWndHeader, HDM_DELETEITEM, 0, 0);
+        SendMessageA(hWndHeader, HDM_DELETEITEM, 0, 0);
     }
 }
 
@@ -813,7 +818,7 @@ static void test_hdm_getitemrect(HWND hParent)
     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
                                     "adder header control to parent", FALSE);
 
-    retVal = SendMessage(hChild, HDM_GETITEMRECT, 1, (LPARAM) &rect);
+    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 1, (LPARAM) &rect);
     ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
     /* check bounding rectangle information of 2nd header item */
     expect(80, rect.left);
@@ -821,7 +826,7 @@ static void test_hdm_getitemrect(HWND hParent)
     expect(160, rect.right);
     expect(g_customheight, rect.bottom);
 
-    retVal = SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
+    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
 
     ok(retVal == TRUE, "Getting item rect should TRUE, got %d\n", retVal);
     /* check bounding rectangle information of 1st header item */
@@ -831,7 +836,7 @@ static void test_hdm_getitemrect(HWND hParent)
     expect(80, rect.right);
     expect(g_customheight, rect.bottom);
 
-    retVal = SendMessage(hChild, HDM_GETITEMRECT, 10, (LPARAM) &rect);
+    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 10, (LPARAM) &rect);
     ok(retVal == 0, "Getting rect of nonexistent item should return 0, got %d\n", retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, getItemRect_seq, "getItemRect sequence testing", FALSE);
@@ -854,7 +859,7 @@ static void test_hdm_layout(HWND hParent)
                                     "adder header control to parent", FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    retVal = SendMessage(hChild, HDM_LAYOUT, 0, (LPARAM) &hdLayout);
+    retVal = SendMessageA(hChild, HDM_LAYOUT, 0, (LPARAM) &hdLayout);
     expect(TRUE, retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, layout_seq, "layout sequence testing", FALSE);
@@ -873,7 +878,7 @@ static void test_hdm_ordertoindex(HWND hParent)
                                     "adder header control to parent", FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    retVal = SendMessage(hChild, HDM_ORDERTOINDEX, 1, 0);
+    retVal = SendMessageA(hChild, HDM_ORDERTOINDEX, 1, 0);
     expect(1, retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, orderToIndex_seq, "orderToIndex sequence testing", FALSE);
@@ -901,7 +906,7 @@ static void test_hdm_hittest(HWND hParent)
                                     "adder header control to parent", FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    retVal = SendMessage(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
+    retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
     expect(0, retVal);
     expect(0, hdHitTestInfo.iItem);
     expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
@@ -909,7 +914,7 @@ static void test_hdm_hittest(HWND hParent)
     pt.x = secondItemRightBoundary - 1;
     pt.y = bottomBoundary - 1;
     hdHitTestInfo.pt = pt;
-    retVal = SendMessage(hChild, HDM_HITTEST, 1, (LPARAM) &hdHitTestInfo);
+    retVal = SendMessageA(hChild, HDM_HITTEST, 1, (LPARAM) &hdHitTestInfo);
     expect(1, retVal);
     expect(1, hdHitTestInfo.iItem);
     expect(HHT_ONDIVIDER, hdHitTestInfo.flags);
@@ -917,7 +922,7 @@ static void test_hdm_hittest(HWND hParent)
     pt.x = secondItemRightBoundary;
     pt.y = bottomBoundary + 1;
     hdHitTestInfo.pt = pt;
-    retVal = SendMessage(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
+    retVal = SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM) &hdHitTestInfo);
     expect(-1, retVal);
     expect(-1, hdHitTestInfo.iItem);
     expect(HHT_BELOW, hdHitTestInfo.flags);
@@ -941,12 +946,12 @@ static void test_hdm_sethotdivider(HWND hParent)
                                     "adder header control to parent", FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, TRUE, MAKELPARAM(5, 5));
+    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, TRUE, MAKELPARAM(5, 5));
     expect(0, retVal);
 
-    retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, FALSE, 100);
+    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 100);
     expect(100, retVal);
-    retVal = SendMessage(hChild, HDM_SETHOTDIVIDER, FALSE, 1);
+    retVal = SendMessageA(hChild, HDM_SETHOTDIVIDER, FALSE, 1);
     expect(1, retVal);
     if (winetest_interactive)
        ok_sequence(sequences, HEADER_SEQ_INDEX, setHotDivider_seq_interactive,
@@ -972,13 +977,13 @@ static void test_hdm_imageMessages(HWND hParent)
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    hIml = (HIMAGELIST) SendMessage(hChild, HDM_SETIMAGELIST, 0, (LPARAM) hImageList);
+    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_SETIMAGELIST, 0, (LPARAM) hImageList);
     ok(hIml == NULL, "Expected NULL, got %p\n", hIml);
 
-    hIml = (HIMAGELIST) SendMessage(hChild, HDM_GETIMAGELIST, 0, 0);
+    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_GETIMAGELIST, 0, 0);
     ok(hIml != NULL, "Expected non-NULL handle, got %p\n", hIml);
 
-    hIml = (HIMAGELIST) SendMessage(hChild, HDM_CREATEDRAGIMAGE, 0, 0);
+    hIml = (HIMAGELIST) SendMessageA(hChild, HDM_CREATEDRAGIMAGE, 0, 0);
     ok(hIml != NULL, "Expected non-NULL handle, got %p\n", hIml);
     ImageList_Destroy(hIml);
 
@@ -997,12 +1002,11 @@ static void test_hdm_filterMessages(HWND hParent)
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     hChild = create_custom_header_control(hParent, TRUE);
-    assert(hChild);
     ok_sequence(sequences, PARENT_SEQ_INDEX, add_header_to_parent_seq,
                                     "adder header control to parent", FALSE);
 
-    timeout = SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
-    SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, timeout);
+    timeout = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
+    SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, timeout);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
@@ -1012,18 +1016,18 @@ static void test_hdm_filterMessages(HWND hParent)
      * return previous filter timeout value
      */
 
-    retVal = SendMessage(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
+    retVal = SendMessageA(hChild, HDM_SETFILTERCHANGETIMEOUT, 1, 100);
     expect(timeout, retVal);
 
     todo_wine
     {
-        retVal = SendMessage(hChild, HDM_CLEARFILTER, 0, 1);
+        retVal = SendMessageA(hChild, HDM_CLEARFILTER, 0, 1);
         if (retVal == 0)
             win_skip("HDM_CLEARFILTER needs 5.80\n");
         else
             expect(1, retVal);
 
-        retVal = SendMessage(hChild, HDM_EDITFILTER, 1, 0);
+        retVal = SendMessageA(hChild, HDM_EDITFILTER, 1, 0);
         if (retVal == 0)
             win_skip("HDM_EDITFILTER needs 5.80\n");
         else
@@ -1050,9 +1054,9 @@ static void test_hdm_unicodeformatMessages(HWND hParent)
                                     "adder header control to parent", FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    retVal = SendMessage(hChild, HDM_SETUNICODEFORMAT, TRUE, 0);
+    retVal = SendMessageA(hChild, HDM_SETUNICODEFORMAT, TRUE, 0);
     expect(0, retVal);
-    retVal = SendMessage(hChild, HDM_GETUNICODEFORMAT, 0, 0);
+    retVal = SendMessageA(hChild, HDM_GETUNICODEFORMAT, 0, 0);
     expect(1, retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, unicodeformatMessages_seq,
@@ -1071,7 +1075,7 @@ static void test_hdm_bitmapmarginMessages(HWND hParent)
                                     "adder header control to parent", FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    retVal = SendMessage(hChild, HDM_GETBITMAPMARGIN, 0, 0);
+    retVal = SendMessageA(hChild, HDM_GETBITMAPMARGIN, 0, 0);
     if (retVal == 0)
         win_skip("HDM_GETBITMAPMARGIN needs 5.80\n");
     else
@@ -1097,7 +1101,7 @@ static void test_hdm_index_messages(HWND hParent)
     static char fourthHeaderItem[] = "Date Modified";
     static char *items[] = {firstHeaderItem, secondHeaderItem, thirdHeaderItem, fourthHeaderItem};
     RECT rect;
-    HDITEM hdItem;
+    HDITEMA hdItem;
     hdItem.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
     hdItem.fmt = HDF_LEFT;
     hdItem.cxy = 80;
@@ -1115,26 +1119,26 @@ static void test_hdm_index_messages(HWND hParent)
     for ( loopcnt = 0 ; loopcnt < 4 ; loopcnt++ )
     {
       hdItem.pszText = items[loopcnt];
-      retVal = SendMessage(hChild, HDM_INSERTITEM, loopcnt, (LPARAM) &hdItem);
+      retVal = SendMessageA(hChild, HDM_INSERTITEMA, loopcnt, (LPARAM) &hdItem);
       ok(retVal == loopcnt, "Adding item %d failed with return value %d\n", ( loopcnt + 1 ), retVal);
     }
     ok_sequence(sequences, HEADER_SEQ_INDEX, insertItem_seq, "insertItem sequence testing", FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    retVal = SendMessage(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
+    retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
     ok(retVal == TRUE, "Deleting item 3 should return TRUE, got %d\n", retVal);
-    retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, 0);
+    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
     ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
 
-    retVal = SendMessage(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
+    retVal = SendMessageA(hChild, HDM_DELETEITEM, 3, (LPARAM) &hdItem);
     ok(retVal == FALSE, "Deleting already-deleted item should return FALSE, got %d\n", retVal);
-    retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, 0);
+    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
     ok(retVal == 3, "Getting item count should return 3, got %d\n", retVal);
 
-    retVal = SendMessage(hChild, HDM_DELETEITEM, 2, (LPARAM) &hdItem);
+    retVal = SendMessageA(hChild, HDM_DELETEITEM, 2, (LPARAM) &hdItem);
     ok(retVal == TRUE, "Deleting item 2 should return TRUE, got %d\n", retVal);
-    retVal = SendMessage(hChild, HDM_GETITEMCOUNT, 0, 0);
+    retVal = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
     ok(retVal == 2, "Getting item count should return 2, got %d\n", retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, deleteItem_getItemCount_seq,
@@ -1142,10 +1146,10 @@ static void test_hdm_index_messages(HWND hParent)
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    retVal = SendMessage(hChild, HDM_GETITEM, 3, (LPARAM) &hdItem);
+    retVal = SendMessageA(hChild, HDM_GETITEMA, 3, (LPARAM) &hdItem);
     ok(retVal == FALSE, "Getting already-deleted item should return FALSE, got %d\n", retVal);
 
-    retVal = SendMessage(hChild, HDM_GETITEM, 0, (LPARAM) &hdItem);
+    retVal = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM) &hdItem);
     ok(retVal == TRUE, "Getting the 1st header item should return TRUE, got %d\n", retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, getItem_seq, "getItem sequence testing", FALSE);
@@ -1155,23 +1159,23 @@ static void test_hdm_index_messages(HWND hParent)
     expect(0, strcmpResult);
     expect(80, hdItem.cxy);
 
-    iSize = SendMessage(hChild, HDM_GETITEMCOUNT, 0, 0);
+    iSize = SendMessageA(hChild, HDM_GETITEMCOUNT, 0, 0);
 
     /* item should be updated just after accepting new array */
     ShowWindow(hChild, SW_HIDE);
-    retVal = SendMessage(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
+    retVal = SendMessageA(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
     expect(TRUE, retVal);
     rect.left = 0;
-    retVal = SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
+    retVal = SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM) &rect);
     expect(TRUE, retVal);
     ok(rect.left != 0, "Expected updated rectangle\n");
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    retVal = SendMessage(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
+    retVal = SendMessageA(hChild, HDM_SETORDERARRAY, iSize, (LPARAM) lpiarray);
     ok(retVal == TRUE, "Setting header items order should return TRUE, got %d\n", retVal);
 
-    retVal = SendMessage(hChild, HDM_GETORDERARRAY, iSize, (LPARAM) lpiarrayReceived);
+    retVal = SendMessageA(hChild, HDM_GETORDERARRAY, iSize, (LPARAM) lpiarrayReceived);
     ok(retVal == TRUE, "Getting header items order should return TRUE, got %d\n", retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, orderArray_seq, "set_get_orderArray sequence testing", FALSE);
@@ -1186,10 +1190,10 @@ static void test_hdm_index_messages(HWND hParent)
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    retVal = SendMessage(hChild, HDM_SETITEM, 0, (LPARAM) &hdItem);
+    retVal = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM) &hdItem);
     ok(retVal == TRUE, "Aligning 1st header item to center should return TRUE, got %d\n", retVal);
     hdItem.fmt = HDF_RIGHT | HDF_STRING;
-    retVal = SendMessage(hChild, HDM_SETITEM, 1, (LPARAM) &hdItem);
+    retVal = SendMessageA(hChild, HDM_SETITEMA, 1, (LPARAM) &hdItem);
     ok(retVal == TRUE, "Aligning 2nd header item to right should return TRUE, got %d\n", retVal);
 
     ok_sequence(sequences, HEADER_SEQ_INDEX, setItem_seq, "setItem sequence testing", FALSE);
@@ -1199,7 +1203,7 @@ static void test_hdm_index_messages(HWND hParent)
 static void test_hdf_fixedwidth(HWND hParent)
 {
     HWND hChild;
-    HDITEM hdItem;
+    HDITEMA hdItem;
     DWORD ret;
     RECT rect;
     HDHITTESTINFO ht;
@@ -1210,20 +1214,20 @@ static void test_hdf_fixedwidth(HWND hParent)
     hdItem.fmt = HDF_FIXEDWIDTH;
     hdItem.cxy = 80;
 
-    ret = SendMessage(hChild, HDM_INSERTITEM, 0, (LPARAM)&hdItem);
+    ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
     expect(0, ret);
 
     /* try to change width */
     rect.right = rect.bottom = 0;
-    SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
+    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
     ok(rect.right  != 0, "Expected not zero width\n");
     ok(rect.bottom != 0, "Expected not zero height\n");
 
-    SendMessage(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
-    SendMessage(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
-    SendMessage(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
+    SendMessageA(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
+    SendMessageA(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
+    SendMessageA(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
 
-    SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
+    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
 
     if (hdItem.cxy != rect.right)
     {
@@ -1236,29 +1240,29 @@ static void test_hdf_fixedwidth(HWND hParent)
     hdItem.mask = HDI_WIDTH;
     hdItem.cxy = 90;
 
-    ret = SendMessage(hChild, HDM_SETITEM, 0, (LPARAM)&hdItem);
+    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
     expect(TRUE, ret);
 
     rect.right = 0;
-    SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
+    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(90, rect.right);
 
     /* hittesting doesn't report ondivider flag for HDF_FIXEDWIDTH */
     ht.pt.x = rect.right - 1;
     ht.pt.y = rect.bottom / 2;
-    SendMessage(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
+    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
     expect(HHT_ONHEADER, ht.flags);
 
     /* try to adjust with message */
     hdItem.mask = HDI_FORMAT;
     hdItem.fmt  = 0;
 
-    ret = SendMessage(hChild, HDM_SETITEM, 0, (LPARAM)&hdItem);
+    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
     expect(TRUE, ret);
 
     ht.pt.x = 90;
     ht.pt.y = rect.bottom / 2;
-    SendMessage(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
+    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
     expect(HHT_ONDIVIDER, ht.flags);
 
     DestroyWindow(hChild);
@@ -1267,7 +1271,7 @@ static void test_hdf_fixedwidth(HWND hParent)
 static void test_hds_nosizing(HWND hParent)
 {
     HWND hChild;
-    HDITEM hdItem;
+    HDITEMA hdItem;
     DWORD ret;
     RECT rect;
     HDHITTESTINFO ht;
@@ -1278,24 +1282,24 @@ static void test_hds_nosizing(HWND hParent)
     hdItem.mask = HDI_WIDTH;
     hdItem.cxy = 80;
 
-    ret = SendMessage(hChild, HDM_INSERTITEM, 0, (LPARAM)&hdItem);
+    ret = SendMessageA(hChild, HDM_INSERTITEMA, 0, (LPARAM)&hdItem);
     expect(0, ret);
 
     /* HDS_NOSIZING only blocks hittesting */
-    ret = GetWindowLong(hChild, GWL_STYLE);
-    SetWindowLong(hChild, GWL_STYLE, ret | HDS_NOSIZING);
+    ret = GetWindowLongA(hChild, GWL_STYLE);
+    SetWindowLongA(hChild, GWL_STYLE, ret | HDS_NOSIZING);
 
     /* try to change width with mouse gestures */
     rect.right = rect.bottom = 0;
-    SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
+    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
     ok(rect.right  != 0, "Expected not zero width\n");
     ok(rect.bottom != 0, "Expected not zero height\n");
 
-    SendMessage(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
-    SendMessage(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
-    SendMessage(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
+    SendMessageA(hChild, WM_LBUTTONDOWN, 0, MAKELPARAM(rect.right, rect.bottom / 2));
+    SendMessageA(hChild, WM_MOUSEMOVE, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
+    SendMessageA(hChild, WM_LBUTTONUP, 0, MAKELPARAM(rect.right + 20, rect.bottom / 2));
 
-    SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
+    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
 
     if (hdItem.cxy != rect.right)
     {
@@ -1306,7 +1310,7 @@ static void test_hds_nosizing(HWND hParent)
 
     /* this style doesn't set HDF_FIXEDWIDTH for items */
     hdItem.mask = HDI_FORMAT;
-    ret = SendMessage(hChild, HDM_GETITEM, 0, (LPARAM)&hdItem);
+    ret = SendMessageA(hChild, HDM_GETITEMA, 0, (LPARAM)&hdItem);
     expect(TRUE, ret);
     ok(!(hdItem.fmt & HDF_FIXEDWIDTH), "Unexpected HDF_FIXEDWIDTH\n");
 
@@ -1314,26 +1318,26 @@ static void test_hds_nosizing(HWND hParent)
     hdItem.mask = HDI_WIDTH;
     hdItem.cxy = 90;
 
-    ret = SendMessage(hChild, HDM_SETITEM, 0, (LPARAM)&hdItem);
+    ret = SendMessageA(hChild, HDM_SETITEMA, 0, (LPARAM)&hdItem);
     expect(TRUE, ret);
 
     rect.right = 0;
-    SendMessage(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
+    SendMessageA(hChild, HDM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(90, rect.right);
 
     /* hittesting doesn't report ondivider flags for HDS_NOSIZING */
     ht.pt.x = rect.right - 1;
     ht.pt.y = rect.bottom / 2;
-    SendMessage(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
+    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
     expect(HHT_ONHEADER, ht.flags);
 
     /* try to adjust with message */
-    ret = GetWindowLong(hChild, GWL_STYLE);
-    SetWindowLong(hChild, GWL_STYLE, ret & ~HDS_NOSIZING);
+    ret = GetWindowLongA(hChild, GWL_STYLE);
+    SetWindowLongA(hChild, GWL_STYLE, ret & ~HDS_NOSIZING);
 
     ht.pt.x = 90;
     ht.pt.y = rect.bottom / 2;
-    SendMessage(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
+    SendMessageA(hChild, HDM_HITTEST, 0, (LPARAM)&ht);
     expect(HHT_ONDIVIDER, ht.flags);
 
     DestroyWindow(hChild);
@@ -1364,7 +1368,7 @@ static LRESULT customdraw_1(int n, NMCUSTOMDRAW *nm)
         return 0;
     }
 
-    ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
+    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
     return -1;
 }
 
@@ -1391,7 +1395,7 @@ static LRESULT customdraw_2(int n, NMCUSTOMDRAW *nm)
         return 0;
     }
 
-    ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
+    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
     return 0;
 }
 
@@ -1421,7 +1425,7 @@ static LRESULT customdraw_3(int n, NMCUSTOMDRAW *nm)
         return 0;
     }
 
-    ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
+    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
     return 0;
 }
 
@@ -1449,7 +1453,7 @@ static LRESULT customdraw_4(int n, NMCUSTOMDRAW *nm)
         return 0;
     }
 
-    ok(FALSE, "To many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
+    ok(FALSE, "Too many custom draw messages (n=%d, nm->dwDrawStage=%d)\n", n, nm->dwDrawStage);
     return 0;
 }
 
@@ -1466,7 +1470,7 @@ static void run_customdraw_scenario(CUSTOMDRAWPROC proc)
 static void test_customdraw(void)
 {
     int i;
-    HDITEM item;
+    HDITEMA item;
     RECT rect;
     CHAR name[] = "Test";
     hWndHeader = create_header_control();
@@ -1482,7 +1486,7 @@ static void test_customdraw(void)
         item.cxy = 50*(i+1);
         item.pszText = name;
         item.lParam = i*5;
-        SendMessage(hWndHeader, HDM_INSERTITEM, i, (LPARAM)&item);
+        SendMessageA(hWndHeader, HDM_INSERTITEMA, i, (LPARAM)&item);
     }
 
     run_customdraw_scenario(customdraw_1);
@@ -1492,13 +1496,13 @@ static void test_customdraw(void)
     ZeroMemory(&item, sizeof(item));
     item.mask = HDI_FORMAT;
     item.fmt = HDF_OWNERDRAW;
-    SendMessage(hWndHeader, HDM_SETITEM, 1, (LPARAM)&item);
+    SendMessageA(hWndHeader, HDM_SETITEMA, 1, (LPARAM)&item);
     g_DrawItem.CtlID = 0;
     g_DrawItem.CtlType = ODT_HEADER;
     g_DrawItem.hwndItem = hWndHeader;
     g_DrawItem.itemID = 1;
     g_DrawItem.itemState = 0;
-    SendMessage(hWndHeader, HDM_GETITEMRECT, 1, (LPARAM)&g_DrawItem.rcItem);
+    SendMessageA(hWndHeader, HDM_GETITEMRECT, 1, (LPARAM)&g_DrawItem.rcItem);
     run_customdraw_scenario(customdraw_4);
     ok(g_DrawItemReceived, "WM_DRAWITEM not received\n");
     DestroyWindow(hWndHeader);
@@ -1517,7 +1521,7 @@ static void check_order(const int expected_id[], const int expected_order[],
     for (i = 0; i < count; i++)
     {
         hdi.mask = HDI_LPARAM|HDI_ORDER;
-        SendMessage(hWndHeader, HDM_GETITEMA, i, (LPARAM)&hdi);
+        SendMessageA(hWndHeader, HDM_GETITEMA, i, (LPARAM)&hdi);
         ok(hdi.lParam == expected_id[i],
             "Invalid item ids after '%s'- item %d has lParam %d\n", type, i, (int)hdi.lParam);
         ok(hdi.iOrder == expected_order[i],
@@ -1556,7 +1560,7 @@ static void test_header_order (void)
     for (i = 0; i < 5; i++)
     {
         hdi.lParam = i;
-        SendMessage(hWndHeader, HDM_INSERTITEMA, rand1[i], (LPARAM)&hdi);
+        SendMessageA(hWndHeader, HDM_INSERTITEMA, rand1[i], (LPARAM)&hdi);
         rand();
     }
     check_order(ids1, ord1, 5, "insert without iOrder");
@@ -1566,7 +1570,7 @@ static void test_header_order (void)
     {
         hdi.lParam = i + 5;
         hdi.iOrder = rand2[i];
-        SendMessage(hWndHeader, HDM_INSERTITEMA, rand3[i], (LPARAM)&hdi);
+        SendMessageA(hWndHeader, HDM_INSERTITEMA, rand3[i], (LPARAM)&hdi);
         rand(); rand();
     }
     check_order(ids2, ord2, 10, "insert with order");
@@ -1575,13 +1579,13 @@ static void test_header_order (void)
     for (i=0; i<10; i++)
     {
         hdi.iOrder = rand5[i];
-        SendMessage(hWndHeader, HDM_SETITEMA, rand4[i], (LPARAM)&hdi);
+        SendMessageA(hWndHeader, HDM_SETITEMA, rand4[i], (LPARAM)&hdi);
         rand(); rand();
     }
     check_order(ids2, ord3, 10, "setitems changing order");
 
     for (i=0; i<5; i++)
-        SendMessage(hWndHeader, HDM_DELETEITEM, rand6[i], 0);
+        SendMessageA(hWndHeader, HDM_DELETEITEM, rand6[i], 0);
     check_order(ids4, ord4, 5, "deleteitem");
 
     DestroyWindow(hWndHeader);
@@ -1594,7 +1598,7 @@ static LRESULT CALLBACK HeaderTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, LP
 
     case WM_NOTIFY:
     {
-        NMHEADERA *hdr = (NMHEADER *)lParam;
+        NMHEADERA *hdr = (NMHEADERA*)lParam;
         EXPECTEDNOTIFY *expected;
         int i;
 
@@ -1644,7 +1648,7 @@ static LRESULT CALLBACK HeaderTestWndProc(HWND hWnd, UINT msg, WPARAM wParam, LP
     return 0L;
 }
 
-static int init(void)
+static BOOL init(void)
 {
     HMODULE hComctl32;
     BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
@@ -1659,7 +1663,7 @@ static int init(void)
     if (!pInitCommonControlsEx)
     {
         skip("InitCommonControlsEx() is missing. Skipping the tests\n");
-        return 0;
+        return FALSE;
     }
 
     iccex.dwSize = sizeof(iccex);
@@ -1671,7 +1675,7 @@ static int init(void)
     wc.cbWndExtra = 0;
     wc.hInstance = GetModuleHandleA(NULL);
     wc.hIcon = NULL;
-    wc.hCursor = LoadCursorA(NULL, IDC_ARROW);
+    wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
     wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
     wc.lpszMenuName = NULL;
     wc.lpszClassName = "HeaderTestClass";
@@ -1693,36 +1697,37 @@ static int init(void)
       CW_USEDEFAULT, CW_USEDEFAULT, 672+2*GetSystemMetrics(SM_CXSIZEFRAME),
       226+GetSystemMetrics(SM_CYCAPTION)+2*GetSystemMetrics(SM_CYSIZEFRAME),
       NULL, NULL, GetModuleHandleA(NULL), 0);
-    assert(hHeaderParentWnd != NULL);
+    ok(hHeaderParentWnd != NULL, "failed to create parent wnd\n");
+
     ShowWindow(hHeaderParentWnd, SW_SHOW);
-    return 1;
+    return hHeaderParentWnd != NULL;
 }
 
 /* maximum 8 items allowed */
 static void check_orderarray(HWND hwnd, DWORD start, DWORD set, DWORD expected,
-                             int todo, int line)
+                             BOOL todo, int line)
 {
     int count, i;
     INT order[8];
     DWORD ret, array = 0;
 
-    count = SendMessage(hwnd, HDM_GETITEMCOUNT, 0, 0);
+    count = SendMessageA(hwnd, HDM_GETITEMCOUNT, 0, 0);
 
     /* initial order */
     for(i = 1; i<=count; i++)
         order[i-1] = start>>(4*(count-i)) & 0xf;
 
-    ret = SendMessage(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
+    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
     ok_(__FILE__, line)(ret, "Expected HDM_SETORDERARAY to succeed, got %d\n", ret);
 
     /* new order */
     for(i = 1; i<=count; i++)
         order[i-1] = set>>(4*(count-i)) & 0xf;
-    ret = SendMessage(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
+    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, count, (LPARAM)order);
     ok_(__FILE__, line)(ret, "Expected HDM_SETORDERARAY to succeed, got %d\n", ret);
 
     /* check actual order */
-    ret = SendMessage(hwnd, HDM_GETORDERARRAY, count, (LPARAM)order);
+    ret = SendMessageA(hwnd, HDM_GETORDERARRAY, count, (LPARAM)order);
     ok_(__FILE__, line)(ret, "Expected HDM_GETORDERARAY to succeed, got %d\n", ret);
     for(i = 1; i<=count; i++)
         array |= order[i-1]<<(4*(count-i));
@@ -1748,7 +1753,7 @@ static void test_hdm_orderarray(void)
     addItem(hwnd, 1, NULL);
     addItem(hwnd, 2, NULL);
 
-    ret = SendMessage(hwnd, HDM_GETORDERARRAY, 3, (LPARAM)order);
+    ret = SendMessageA(hwnd, HDM_GETORDERARRAY, 3, (LPARAM)order);
     if (!ret)
     {
         win_skip("HDM_GETORDERARRAY not implemented.\n");
@@ -1763,14 +1768,14 @@ static void test_hdm_orderarray(void)
 if (0)
 {
     /* null pointer, crashes native */
-    ret = SendMessage(hwnd, HDM_SETORDERARRAY, 3, 0);
+    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 3, 0);
     expect(FALSE, ret);
 }
     /* count out of limits */
-    ret = SendMessage(hwnd, HDM_SETORDERARRAY, 5, (LPARAM)order);
+    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 5, (LPARAM)order);
     expect(FALSE, ret);
     /* count out of limits */
-    ret = SendMessage(hwnd, HDM_SETORDERARRAY, 2, (LPARAM)order);
+    ret = SendMessageA(hwnd, HDM_SETORDERARRAY, 2, (LPARAM)order);
     expect(FALSE, ret);
 
     /* try with out of range item index */
@@ -1823,7 +1828,6 @@ START_TEST(header)
     HWND parent_hwnd;
     ULONG_PTR ctx_cookie;
     HANDLE hCtx;
-    HWND hwnd;
 
     if (!init())
         return;
@@ -1856,22 +1860,6 @@ START_TEST(header)
         return;
     }
 
-    /* this is a XP SP3 failure workaround */
-    hwnd = CreateWindowExA(0, WC_HEADER, NULL,
-                           WS_CHILD|WS_BORDER|WS_VISIBLE|HDS_BUTTONS|HDS_HORZ,
-                           0, 0, 100, 100,
-                           parent_hwnd, NULL, GetModuleHandleA(NULL), NULL);
-
-    if (!IsWindow(hwnd))
-    {
-        win_skip("FIXME: failed to create Header window.\n");
-        unload_v6_module(ctx_cookie, hCtx);
-        DestroyWindow(parent_hwnd);
-        return;
-    }
-    else
-        DestroyWindow(hwnd);
-
     /* comctl32 version 6 tests start here */
     test_hdf_fixedwidth(parent_hwnd);
     test_hds_nosizing(parent_hwnd);
index 53b4fac..d6ee25f 100644 (file)
@@ -34,7 +34,7 @@
 #include <windef.h>
 #include <winbase.h>
 #include <wingdi.h>
-//#include "winuser.h"
+#include <winuser.h>
 #include <objbase.h>
 #include <commctrl.h> /* must be included after objbase.h to get ImageList_Write */
 #include <initguid.h>
@@ -138,7 +138,7 @@ static HWND create_a_window(void)
     char className[] = "bmwnd";
     char winName[]   = "Test Bitmap";
     HWND hWnd;
-    static int registered = 0;
+    static BOOL registered = FALSE;
 
     if (!registered)
     {
@@ -149,14 +149,14 @@ static HWND create_a_window(void)
         cls.cbClsExtra    = 0;
         cls.cbWndExtra    = 0;
         cls.hInstance     = 0;
-        cls.hIcon         = LoadIconA (0, IDI_APPLICATION);
-        cls.hCursor       = LoadCursorA (0, IDC_ARROW);
+        cls.hIcon         = LoadIconA(0, (LPCSTR)IDI_APPLICATION);
+        cls.hCursor       = LoadCursorA(0, (LPCSTR)IDC_ARROW);
         cls.hbrBackground = GetStockObject (WHITE_BRUSH);
         cls.lpszMenuName  = 0;
         cls.lpszClassName = className;
 
         RegisterClassA (&cls);
-        registered = 1;
+        registered = TRUE;
     }
 
     /* Setup window */
@@ -813,7 +813,8 @@ static ULONG check_bitmap_data(const char *bm_data, ULONG bm_data_size,
 
     image_size = DIB_GetWidthBytes(bmih->biWidth, bmih->biBitCount) * bmih->biHeight;
     ok(bmih->biSizeImage == image_size, "wrong biSizeImage %u\n", bmih->biSizeImage);
-#if 0
+
+if (0)
 {
     char fname[256];
     FILE *f;
@@ -822,7 +823,7 @@ static ULONG check_bitmap_data(const char *bm_data, ULONG bm_data_size,
     fwrite(bm_data, 1, bm_data_size, f);
     fclose(f);
 }
-#endif
+
     return hdr_size + image_size;
 }
 
@@ -871,7 +872,7 @@ static HBITMAP create_bitmap(INT cx, INT cy, COLORREF color, const char *comment
     FillRect(hdc, &rc, hbrush);
     DeleteObject(hbrush);
 
-    DrawText(hdc, comment, -1, &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
+    DrawTextA(hdc, comment, -1, &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
 
     SelectObject(hdc, hbmp_old);
     DeleteDC(hdc);
@@ -1221,7 +1222,7 @@ static void test_shell_imagelist(void)
     int cx, cy;
 
     /* Try to load function from shell32 */
-    hShell32 = LoadLibrary("shell32.dll");
+    hShell32 = LoadLibraryA("shell32.dll");
     pSHGetImageList = (void*)GetProcAddress(hShell32, (LPCSTR) 727);
 
     if (!pSHGetImageList)
@@ -2068,7 +2069,7 @@ START_TEST(imagelist)
     ULONG_PTR ctx_cookie;
     HANDLE hCtx;
 
-    HMODULE hComCtl32 = GetModuleHandle("comctl32.dll");
+    HMODULE hComCtl32 = GetModuleHandleA("comctl32.dll");
     pImageList_Create = NULL;   /* These are not needed for non-v6.0 tests*/
     pImageList_Add = NULL;
     pImageList_DrawIndirect = (void*)GetProcAddress(hComCtl32, "ImageList_DrawIndirect");
index 4acdd83..22bd1d0 100644 (file)
@@ -29,9 +29,9 @@ static HWND create_ipaddress_control (void)
 {
     HWND handle;
 
-    handle = CreateWindowEx(0, WC_IPADDRESS, NULL,
-                           WS_BORDER|WS_VISIBLE, 0, 0, 0, 0,
-                           NULL, NULL, NULL, NULL);
+    handle = CreateWindowExA(0, WC_IPADDRESSA, NULL,
+                            WS_BORDER|WS_VISIBLE, 0, 0, 0, 0,
+                            NULL, NULL, NULL, NULL);
     return handle;
 }
 
@@ -49,19 +49,19 @@ static void test_get_set_text(void)
     }
 
     /* check text just after creation */
-    r = GetWindowText(hwnd, ip, sizeof(ip)/sizeof(CHAR));
+    r = GetWindowTextA(hwnd, ip, sizeof(ip)/sizeof(CHAR));
     expect(7, r);
     ok(strcmp(ip, "0.0.0.0") == 0, "Expected null IP address, got %s\n", ip);
 
-    SendMessage(hwnd, IPM_SETADDRESS, 0, MAKEIPADDRESS(127, 0, 0, 1));
-    r = GetWindowText(hwnd, ip, sizeof(ip)/sizeof(CHAR));
+    SendMessageA(hwnd, IPM_SETADDRESS, 0, MAKEIPADDRESS(127, 0, 0, 1));
+    r = GetWindowTextA(hwnd, ip, sizeof(ip)/sizeof(CHAR));
     expect(9, r);
     ok(strcmp(ip, "127.0.0.1") == 0, "Expected 127.0.0.1, got %s\n", ip);
 
     DestroyWindow(hwnd);
 }
 
-static int init(void)
+static BOOL init(void)
 {
     HMODULE hComctl32;
     BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
@@ -72,7 +72,7 @@ static int init(void)
     if (!pInitCommonControlsEx)
     {
         win_skip("InitCommonControlsEx() is missing.\n");
-        return 0;
+        return FALSE;
     }
 
     iccex.dwSize = sizeof(iccex);
@@ -80,7 +80,7 @@ static int init(void)
     iccex.dwICC  = ICC_INTERNET_CLASSES;
     pInitCommonControlsEx(&iccex);
 
-    return 1;
+    return TRUE;
 }
 
 START_TEST(ipaddress)
index 014997e..9acc505 100644 (file)
@@ -67,7 +67,7 @@ static LVITEMA g_itema;
 /* alter notification code A->W */
 static BOOL g_disp_A_to_W;
 /* dispinfo data sent with LVN_LVN_ENDLABELEDIT */
-static NMLVDISPINFO g_editbox_disp_info;
+static NMLVDISPINFOA g_editbox_disp_info;
 /* when this is set focus will be tested on LVN_DELETEITEM */
 static BOOL g_focus_test_LVN_DELETEITEM;
 
@@ -134,9 +134,9 @@ static const struct message listview_color_seq[] = {
 
 static const struct message listview_item_count_seq[] = {
     { LVM_GETITEMCOUNT,   sent },
-    { LVM_INSERTITEM    sent },
-    { LVM_INSERTITEM    sent },
-    { LVM_INSERTITEM    sent },
+    { LVM_INSERTITEMA,    sent },
+    { LVM_INSERTITEMA,    sent },
+    { LVM_INSERTITEMA,    sent },
     { LVM_GETITEMCOUNT,   sent },
     { LVM_DELETEITEM,     sent|wparam, 2 },
     { WM_NCPAINT,         sent|optional },
@@ -144,18 +144,18 @@ static const struct message listview_item_count_seq[] = {
     { LVM_GETITEMCOUNT,   sent },
     { LVM_DELETEALLITEMS, sent },
     { LVM_GETITEMCOUNT,   sent },
-    { LVM_INSERTITEM    sent },
-    { LVM_INSERTITEM    sent },
+    { LVM_INSERTITEMA,    sent },
+    { LVM_INSERTITEMA,    sent },
     { LVM_GETITEMCOUNT,   sent },
-    { LVM_INSERTITEM    sent },
+    { LVM_INSERTITEMA,    sent },
     { LVM_GETITEMCOUNT,   sent },
     { 0 }
 };
 
 static const struct message listview_itempos_seq[] = {
-    { LVM_INSERTITEM     sent },
-    { LVM_INSERTITEM     sent },
-    { LVM_INSERTITEM     sent },
+    { LVM_INSERTITEMA,     sent },
+    { LVM_INSERTITEMA,     sent },
+    { LVM_INSERTITEMA,     sent },
     { LVM_SETITEMPOSITION, sent|wparam|lparam, 1, MAKELPARAM(10,5) },
     { WM_NCPAINT,          sent|optional },
     { WM_ERASEBKGND,       sent|optional },
@@ -333,6 +333,23 @@ static const struct message listview_destroy[] = {
     { 0 }
 };
 
+static const struct message listview_ownerdata_destroy[] = {
+    { 0x0090, sent|optional }, /* Vista */
+    { WM_PARENTNOTIFY, sent },
+    { WM_SHOWWINDOW, sent },
+    { WM_WINDOWPOSCHANGING, sent },
+    { WM_WINDOWPOSCHANGED, sent|optional },
+    { WM_DESTROY, sent },
+    { WM_NCDESTROY, sent },
+    { 0 }
+};
+
+static const struct message listview_ownerdata_deleteall[] = {
+    { LVM_DELETEALLITEMS, sent },
+    { WM_NOTIFY, sent|id, 0, 0, LVN_DELETEALLITEMS },
+    { 0 }
+};
+
 static const struct message listview_header_changed_seq[] = {
     { LVM_SETCOLUMNA, sent },
     { WM_NOTIFY, sent|id|defwinproc, 0, 0, LISTVIEW_ID },
@@ -409,7 +426,7 @@ static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LP
       {
           switch (((NMHDR*)lParam)->code)
           {
-          case LVN_BEGINLABELEDIT:
+          case LVN_BEGINLABELEDITA:
           {
               HWND edit = NULL;
 
@@ -426,12 +443,12 @@ static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LP
 
               return blockEdit;
           }
-          case LVN_ENDLABELEDIT:
+          case LVN_ENDLABELEDITA:
               {
               HWND edit;
 
               /* always accept new item text */
-              NMLVDISPINFO *di = (NMLVDISPINFO*)lParam;
+              NMLVDISPINFOA *di = (NMLVDISPINFOA*)lParam;
               g_editbox_disp_info = *di;
               trace("LVN_ENDLABELEDIT: text=%s\n", di->item.pszText ? di->item.pszText : "(null)");
 
@@ -527,7 +544,7 @@ static BOOL register_parent_wnd_class(BOOL Unicode)
         clsW.cbWndExtra = 0;
         clsW.hInstance = GetModuleHandleW(NULL);
         clsW.hIcon = 0;
-        clsW.hCursor = LoadCursorA(0, IDC_ARROW);
+        clsW.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
         clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
         clsW.lpszMenuName = NULL;
         clsW.lpszClassName = testparentclassW;
@@ -540,7 +557,7 @@ static BOOL register_parent_wnd_class(BOOL Unicode)
         clsA.cbWndExtra = 0;
         clsA.hInstance = GetModuleHandleA(NULL);
         clsA.hIcon = 0;
-        clsA.hCursor = LoadCursorA(0, IDC_ARROW);
+        clsA.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
         clsA.hbrBackground = GetStockObject(WHITE_BRUSH);
         clsA.lpszMenuName = NULL;
         clsA.lpszClassName = "Listview test parent class";
@@ -614,7 +631,7 @@ static HWND create_listview_control(DWORD style)
     RECT rect;
 
     GetClientRect(hwndparent, &rect);
-    hwnd = CreateWindowExA(0, WC_LISTVIEW, "foo",
+    hwnd = CreateWindowExA(0, WC_LISTVIEWA, "foo",
                            WS_CHILD | WS_BORDER | WS_VISIBLE | style,
                            0, 0, rect.right, rect.bottom,
                            hwndparent, NULL, GetModuleHandleA(NULL), NULL);
@@ -679,7 +696,7 @@ static HWND subclass_header(HWND hwndListview)
     WNDPROC oldproc;
     HWND hwnd;
 
-    hwnd = ListView_GetHeader(hwndListview);
+    hwnd = (HWND)SendMessageA(hwndListview, LVM_GETHEADER, 0, 0);
     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
                                          (LONG_PTR)header_subclass_proc);
     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
@@ -722,7 +739,7 @@ static HWND subclass_editbox(HWND hwndListview)
     WNDPROC oldproc;
     HWND hwnd;
 
-    hwnd = (HWND)SendMessage(hwndListview, LVM_GETEDITCONTROL, 0, 0);
+    hwnd = (HWND)SendMessageA(hwndListview, LVM_GETEDITCONTROL, 0, 0);
     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
                                          (LONG_PTR)editbox_subclass_proc);
     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
@@ -741,7 +758,7 @@ static void test_lvm_hittest_(HWND hwnd, INT x, INT y, INT item, UINT flags, UIN
     lpht.pt.y = y;
     lpht.iSubItem = 10;
 
-    ret = SendMessage(hwnd, LVM_HITTEST, 0, (LPARAM)&lpht);
+    ret = SendMessageA(hwnd, LVM_HITTEST, 0, (LPARAM)&lpht);
 
     if (todo_item)
     {
@@ -783,7 +800,7 @@ static void test_lvm_subitemhittest_(HWND hwnd, INT x, INT y, INT item, INT subi
     lpht.pt.x = x;
     lpht.pt.y = y;
 
-    ret = SendMessage(hwnd, LVM_SUBITEMHITTEST, 0, (LPARAM)&lpht);
+    ret = SendMessageA(hwnd, LVM_SUBITEMHITTEST, 0, (LPARAM)&lpht);
 
     if (todo_item)
     {
@@ -822,7 +839,7 @@ static void test_images(void)
 {
     HWND hwnd;
     INT r;
-    LVITEM item;
+    LVITEMA item;
     HIMAGELIST himl;
     HBITMAP hbmp;
     RECT r1, r2;
@@ -837,24 +854,24 @@ static void test_images(void)
     r = ImageList_Add(himl, hbmp, 0);
     ok(r == 0, "should be zero\n");
 
-    hwnd = CreateWindowEx(0, "SysListView32", "foo", LVS_OWNERDRAWFIXED, 
+    hwnd = CreateWindowExA(0, "SysListView32", "foo", LVS_OWNERDRAWFIXED,
                 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
     ok(hwnd != NULL, "failed to create listview window\n");
 
-    r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
+    r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
                     LVS_EX_UNDERLINEHOT | LVS_EX_FLATSB | LVS_EX_ONECLICKACTIVATE);
 
     ok(r == 0, "should return zero\n");
 
-    r = SendMessage(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
+    r = SendMessageA(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
     ok(r == 0, "should return zero\n");
 
-    r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELONG(100,50));
+    r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELONG(100,50));
     ok(r != 0, "got 0\n");
 
     /* returns dimensions */
 
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     ok(r == 0, "should be zero items\n");
 
     item.mask = LVIF_IMAGE | LVIF_TEXT;
@@ -862,30 +879,30 @@ static void test_images(void)
     item.iSubItem = 1;
     item.iImage = 0;
     item.pszText = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     ok(r == -1, "should fail\n");
 
     item.iSubItem = 0;
     item.pszText = hello;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     ok(r == 0, "should not fail\n");
 
     memset(&r1, 0, sizeof r1);
     r1.left = LVIR_ICON;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r1);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r1);
     expect(1, r);
 
-    r = SendMessage(hwnd, LVM_DELETEALLITEMS, 0, 0);
+    r = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
     ok(r == TRUE, "should not fail\n");
 
     item.iSubItem = 0;
     item.pszText = hello;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     ok(r == 0, "should not fail\n");
 
     memset(&r2, 0, sizeof r2);
     r2.left = LVIR_ICON;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r2);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM) &r2);
     expect(1, r);
 
     ok(!memcmp(&r1, &r2, sizeof r1), "rectangle should be the same\n");
@@ -902,7 +919,7 @@ static void test_checkboxes(void)
                 text2[] = "Text2",
                 text3[] = "Text3";
 
-    hwnd = CreateWindowEx(0, "SysListView32", "foo", LVS_REPORT, 
+    hwnd = CreateWindowExA(0, "SysListView32", "foo", LVS_REPORT,
                 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
     ok(hwnd != NULL, "failed to create listview window\n");
 
@@ -913,13 +930,13 @@ static void test_checkboxes(void)
     item.iItem = 0;
     item.iSubItem = 0;
     item.pszText = text;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
 
     item.iItem = 0;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0xfccc, "state %x\n", item.state);
 
@@ -930,24 +947,24 @@ static void test_checkboxes(void)
     item.iItem = 1;
     item.iSubItem = 0;
     item.pszText = text;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     item.iItem = 1;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0, "state %x\n", item.state);
 
-    r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
+    r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
     expect(0, r);
 
     /* Having turned on checkboxes, check that all existing items are set to 0x1000 (unchecked) */
     item.iItem = 0;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     if (item.state != 0x1ccc)
     {
@@ -961,13 +978,13 @@ static void test_checkboxes(void)
     item.mask = LVIF_TEXT;
     item.state = 0;
     item.pszText = text2;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(2, r);
 
     item.iItem = 2;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x1000, "state %x\n", item.state);
 
@@ -977,13 +994,13 @@ static void test_checkboxes(void)
     item.stateMask = 0xffff;
     item.state = 0x2aaa;
     item.pszText = text3;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(3, r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x1aaa, "state %x\n", item.state);
 
@@ -992,13 +1009,13 @@ static void test_checkboxes(void)
     item.mask = LVIF_STATE;
     item.stateMask = 0xf000;
     item.state = 0x2000;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x2aaa, "state %x\n", item.state);
 
@@ -1009,40 +1026,40 @@ static void test_checkboxes(void)
     item.mask = LVIF_STATE;
     item.stateMask = 0xf000;
     item.state = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x2000, "state %x\n", item.state);
 
     /* Set the style again and check that doesn't change an item's state */
-    r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
+    r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
     ok(r == LVS_EX_CHECKBOXES, "ret %x\n", r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x2aaa, "state %x\n", item.state);
 
     /* Unsetting the checkbox extended style doesn't change an item's state */
-    r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, 0);
+    r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, 0);
     ok(r == LVS_EX_CHECKBOXES, "ret %x\n", r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x2aaa, "state %x\n", item.state);
 
     /* Now setting the style again will change an item's state */
-    r = SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
+    r = SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES);
     expect(0, r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x1aaa, "state %x\n", item.state);
 
@@ -1053,37 +1070,37 @@ static void test_checkboxes(void)
     item.iSubItem = 0;
     item.state = LVIS_FOCUSED;
     item.stateMask = LVIS_FOCUSED;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x1aab, "state %x\n", item.state);
 
-    r = SendMessage(hwnd, WM_KEYDOWN, VK_SPACE, 0);
+    r = SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
     expect(0, r);
-    r = SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0);
+    r = SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
     expect(0, r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x2aab, "state %x\n", item.state);
 
-    r = SendMessage(hwnd, WM_KEYDOWN, VK_SPACE, 0);
+    r = SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0);
     expect(0, r);
-    r = SendMessage(hwnd, WM_KEYUP, VK_SPACE, 0);
+    r = SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0);
     expect(0, r);
 
     item.iItem = 3;
     item.mask = LVIF_STATE;
     item.stateMask = 0xffff;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == 0x1aab, "state %x\n", item.state);
 
@@ -1092,14 +1109,14 @@ static void test_checkboxes(void)
 
 static void insert_column(HWND hwnd, int idx)
 {
-    LVCOLUMN column;
+    LVCOLUMNA column;
     INT rc;
 
     memset(&column, 0xcc, sizeof(column));
     column.mask = LVCF_SUBITEM;
     column.iSubItem = idx;
 
-    rc = ListView_InsertColumn(hwnd, idx, &column);
+    rc = SendMessageA(hwnd, LVM_INSERTCOLUMNA, idx, (LPARAM)&column);
     expect(idx, rc);
 }
 
@@ -1116,7 +1133,7 @@ static void insert_item(HWND hwnd, int idx)
     item.iSubItem = 0;
     item.pszText = text;
 
-    rc = ListView_InsertItem(hwnd, &item);
+    rc = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(idx, rc);
 }
 
@@ -1129,7 +1146,7 @@ static void test_items(void)
     LVITEMA item;
     DWORD r;
 
-    hwnd = CreateWindowEx(0, "SysListView32", "foo", LVS_REPORT,
+    hwnd = CreateWindowExA(0, "SysListView32", "foo", LVS_REPORT,
                 10, 10, 100, 200, hwndparent, NULL, NULL, NULL);
     ok(hwnd != NULL, "failed to create listview window\n");
 
@@ -1149,7 +1166,7 @@ static void test_items(void)
     item.stateMask = 0;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
     /* get */
     memset (&item, 0xcc, sizeof (item));
@@ -1158,10 +1175,10 @@ static void test_items(void)
     item.state = 0;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state & LVIS_SELECTED, "Expected LVIS_SELECTED\n");
-    SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
+    SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
 
     /* LVIS_SELECTED with zero stateMask */
     /* set */
@@ -1171,7 +1188,7 @@ static void test_items(void)
     item.stateMask = 0;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
     /* get */
     memset (&item, 0xcc, sizeof (item));
@@ -1180,10 +1197,10 @@ static void test_items(void)
     item.state = 0;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state & LVIS_FOCUSED, "Expected LVIS_FOCUSED\n");
-    SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
+    SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
 
     /* LVIS_CUT with LVIS_FOCUSED stateMask */
     /* set */
@@ -1193,7 +1210,7 @@ static void test_items(void)
     item.stateMask = LVIS_FOCUSED;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
     /* get */
     memset (&item, 0xcc, sizeof (item));
@@ -1202,10 +1219,10 @@ static void test_items(void)
     item.state = 0;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state & LVIS_CUT, "Expected LVIS_CUT\n");
-    SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
+    SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
 
     /* Insert an item with just a param */
     memset (&item, 0xcc, sizeof (item));
@@ -1213,7 +1230,7 @@ static void test_items(void)
     item.iItem = 0;
     item.iSubItem = 0;
     item.lParam = lparamTest;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
 
     /* Test getting of the param */
@@ -1221,7 +1238,7 @@ static void test_items(void)
     item.mask = LVIF_PARAM;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
 
@@ -1231,7 +1248,7 @@ static void test_items(void)
     item.iItem = 0;
     item.iSubItem = 1;
     item.pszText = text;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     item.mask = LVIF_TEXT;
@@ -1239,7 +1256,7 @@ static void test_items(void)
     item.iSubItem = 1;
     item.pszText = buffA;
     item.cchTextMax = sizeof(buffA);
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(!memcmp(item.pszText, text, sizeof(text)), "got text %s, expected %s\n", item.pszText, text);
 
@@ -1249,7 +1266,7 @@ static void test_items(void)
     item.iItem = 0;
     item.iSubItem = 1;
     item.pszText = NULL;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     item.mask = LVIF_TEXT;
@@ -1258,7 +1275,7 @@ static void test_items(void)
     item.pszText = buffA;
     buffA[0] = 'a';
     item.cchTextMax = sizeof(buffA);
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.pszText[0] == 0, "got %p\n", item.pszText);
 
@@ -1267,7 +1284,7 @@ static void test_items(void)
     item.iItem = 0;
     item.iSubItem = 1;
     item.pszText = text;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     ok(r == 1 || broken(r == 0) /* NT4 */, "ret %d\n", r);
 
     if (r == 1)
@@ -1278,7 +1295,7 @@ static void test_items(void)
         item.pszText = buffA;
         buffA[0] = 'a';
         item.cchTextMax = sizeof(buffA);
-        r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+        r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
         expect(1, r);
         ok(!memcmp(item.pszText, text, sizeof(text)), "got %s, expected %s\n", item.pszText, text);
     }
@@ -1288,7 +1305,7 @@ static void test_items(void)
     item.mask = LVIF_PARAM;
     item.iItem = 0;
     item.iSubItem = 1;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
 
@@ -1298,7 +1315,7 @@ static void test_items(void)
     item.iItem = 0;
     item.iSubItem = 1;
     item.lParam = lparamTest+1;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     expect(0, r);
 
     /* Query param from subitem again: should still return main item param */
@@ -1306,7 +1323,7 @@ static void test_items(void)
     item.mask = LVIF_PARAM;
     item.iItem = 0;
     item.iSubItem = 1;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.lParam == lparamTest, "got lParam %lx, expected %lx\n", item.lParam, lparamTest);
 
@@ -1317,11 +1334,11 @@ static void test_items(void)
     item.iSubItem = 0;
     item.state = LVIS_SELECTED;
     item.stateMask = LVIS_SELECTED | LVIS_DROPHILITED;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     item.iSubItem = 1;
     item.state = LVIS_DROPHILITED;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     memset (&item, 0xcc, sizeof (item));
@@ -1329,11 +1346,11 @@ static void test_items(void)
     item.iItem = 0;
     item.iSubItem = 0;
     item.stateMask = -1;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     ok(item.state == LVIS_SELECTED, "got state %x, expected %x\n", item.state, LVIS_SELECTED);
     item.iSubItem = 1;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     todo_wine ok(item.state == LVIS_DROPHILITED, "got state %x, expected %x\n", item.state, LVIS_DROPHILITED);
 
@@ -1342,30 +1359,30 @@ static void test_items(void)
     item.mask = LVIF_NORECOMPUTE;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
     memset (&item, 0, sizeof(item));
     item.mask = LVIF_DI_SETITEM;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     /* set text to callback value already having it */
-    r = SendMessage(hwnd, LVM_DELETEALLITEMS, 0, 0);
+    r = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
     expect(TRUE, r);
     memset (&item, 0, sizeof (item));
     item.mask  = LVIF_TEXT;
-    item.pszText = LPSTR_TEXTCALLBACK;
+    item.pszText = LPSTR_TEXTCALLBACKA;
     item.iItem = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
     memset (&item, 0, sizeof (item));
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    item.pszText = LPSTR_TEXTCALLBACK;
-    r = SendMessage(hwnd, LVM_SETITEMTEXT, 0 , (LPARAM) &item);
+    item.pszText = LPSTR_TEXTCALLBACKA;
+    r = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0 , (LPARAM) &item);
     expect(TRUE, r);
 
     ok_sequence(sequences, PARENT_SEQ_INDEX, textcallback_set_again_parent_seq,
@@ -1453,11 +1470,11 @@ static LRESULT CALLBACK create_test_wndproc(HWND hwnd, UINT uMsg, WPARAM wParam,
 
     if (uMsg == WM_CREATE)
     {
-        LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
+        CREATESTRUCTA *lpcs = (CREATESTRUCTA*)lParam;
         lpcs->style |= LVS_REPORT;
     }
-    ret = CallWindowProc(listviewWndProc, hwnd, uMsg, wParam, lParam);
-    if (uMsg == WM_CREATE) SendMessage(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)test_create_imagelist);
+    ret = CallWindowProcA(listviewWndProc, hwnd, uMsg, wParam, lParam);
+    if (uMsg == WM_CREATE) SendMessageA(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)test_create_imagelist);
     return ret;
 }
 
@@ -1469,20 +1486,20 @@ static void test_create(void)
     LONG r;
     LVCOLUMNA col;
     RECT rect;
-    WNDCLASSEX cls;
+    WNDCLASSEXA cls;
     DWORD style;
 
-    cls.cbSize = sizeof(WNDCLASSEX);
-    ok(GetClassInfoEx(GetModuleHandle(NULL), "SysListView32", &cls), "GetClassInfoEx failed\n");
+    cls.cbSize = sizeof(WNDCLASSEXA);
+    ok(GetClassInfoExA(GetModuleHandleA(NULL), "SysListView32", &cls), "GetClassInfoEx failed\n");
     listviewWndProc = cls.lpfnWndProc;
     cls.lpfnWndProc = create_test_wndproc;
     cls.lpszClassName = "MyListView32";
-    ok(RegisterClassEx(&cls), "RegisterClassEx failed\n");
+    ok(RegisterClassExA(&cls), "RegisterClassEx failed\n");
 
     test_create_imagelist = ImageList_Create(16, 16, 0, 5, 10);
-    hList = CreateWindow("MyListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL, GetModuleHandle(NULL), 0);
-    ok((HIMAGELIST)SendMessage(hList, LVM_GETIMAGELIST, 0, 0) == test_create_imagelist, "Image list not obtained\n");
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("MyListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL, GetModuleHandleA(NULL), 0);
+    ok((HIMAGELIST)SendMessageA(hList, LVM_GETIMAGELIST, 0, 0) == test_create_imagelist, "Image list not obtained\n");
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
 
     if (!IsWindow(hHeader))
     {
@@ -1497,118 +1514,118 @@ static void test_create(void)
     DestroyWindow(hList);
 
     /* header isn't created on LVS_ICON and LVS_LIST styles */
-    hList = CreateWindow("SysListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL,
+                           GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
     /* insert column */
     memset(&col, 0, sizeof(LVCOLUMNA));
     col.mask = LVCF_WIDTH;
     col.cx = 100;
-    r = SendMessage(hList, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
+    r = SendMessageA(hList, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, r);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
-    style = GetWindowLong(hHeader, GWL_STYLE);
+    style = GetWindowLongA(hHeader, GWL_STYLE);
     ok(!(style & HDS_HIDDEN), "Not expected HDS_HIDDEN\n");
     DestroyWindow(hList);
 
-    hList = CreateWindow("SysListView32", "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
+                           GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
     /* insert column */
     memset(&col, 0, sizeof(LVCOLUMNA));
     col.mask = LVCF_WIDTH;
     col.cx = 100;
-    r = SendMessage(hList, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
+    r = SendMessageA(hList, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, r);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
     DestroyWindow(hList);
 
     /* try to switch LVS_ICON -> LVS_REPORT and back LVS_ICON -> LVS_REPORT */
-    hList = CreateWindow("SysListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    ret = SetWindowLongPtr(hList, GWL_STYLE, GetWindowLongPtr(hList, GWL_STYLE) | LVS_REPORT);
+    hList = CreateWindowA("SysListView32", "Test", WS_VISIBLE, 0, 0, 100, 100, NULL, NULL,
+                           GetModuleHandleA(NULL), 0);
+    ret = SetWindowLongPtrA(hList, GWL_STYLE, GetWindowLongPtrA(hList, GWL_STYLE) | LVS_REPORT);
     ok(ret & WS_VISIBLE, "Style wrong, should have WS_VISIBLE\n");
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
-    ret = SetWindowLongPtr(hList, GWL_STYLE, GetWindowLong(hList, GWL_STYLE) & ~LVS_REPORT);
+    ret = SetWindowLongPtrA(hList, GWL_STYLE, GetWindowLongA(hList, GWL_STYLE) & ~LVS_REPORT);
     ok((ret & WS_VISIBLE) && (ret & LVS_REPORT), "Style wrong, should have WS_VISIBLE|LVS_REPORT\n");
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
     DestroyWindow(hList);
 
     /* try to switch LVS_LIST -> LVS_REPORT and back LVS_LIST -> LVS_REPORT */
-    hList = CreateWindow("SysListView32", "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    ret = SetWindowLongPtr(hList, GWL_STYLE,
-                          (GetWindowLongPtr(hList, GWL_STYLE) & ~LVS_LIST) | LVS_REPORT);
+    hList = CreateWindowA("SysListView32", "Test", WS_VISIBLE|LVS_LIST, 0, 0, 100, 100, NULL, NULL,
+                           GetModuleHandleA(NULL), 0);
+    ret = SetWindowLongPtrA(hList, GWL_STYLE,
+                           (GetWindowLongPtrA(hList, GWL_STYLE) & ~LVS_LIST) | LVS_REPORT);
     ok(((ret & WS_VISIBLE) && (ret & LVS_LIST)), "Style wrong, should have WS_VISIBLE|LVS_LIST\n");
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
-    ret = SetWindowLongPtr(hList, GWL_STYLE,
-                          (GetWindowLongPtr(hList, GWL_STYLE) & ~LVS_REPORT) | LVS_LIST);
+    ret = SetWindowLongPtrA(hList, GWL_STYLE,
+                           (GetWindowLongPtrA(hList, GWL_STYLE) & ~LVS_REPORT) | LVS_LIST);
     ok(((ret & WS_VISIBLE) && (ret & LVS_REPORT)), "Style wrong, should have WS_VISIBLE|LVS_REPORT\n");
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
     DestroyWindow(hList);
 
     /* LVS_REPORT without WS_VISIBLE */
-    hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
+                          GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
     /* insert column */
     memset(&col, 0, sizeof(LVCOLUMNA));
     col.mask = LVCF_WIDTH;
     col.cx = 100;
-    r = SendMessage(hList, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
+    r = SendMessageA(hList, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, r);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
     DestroyWindow(hList);
 
     /* LVS_REPORT without WS_VISIBLE, try to show it */
-    hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
+                          GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
     ShowWindow(hList, SW_SHOW);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
     DestroyWindow(hList);
 
     /* LVS_REPORT with LVS_NOCOLUMNHEADER */
-    hList = CreateWindow("SysListView32", "Test", LVS_REPORT|LVS_NOCOLUMNHEADER|WS_VISIBLE,
-                          0, 0, 100, 100, NULL, NULL, GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", LVS_REPORT|LVS_NOCOLUMNHEADER|WS_VISIBLE,
+                          0, 0, 100, 100, NULL, NULL, GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader), "Header should be created\n");
     ok(hHeader == GetDlgItem(hList, 0), "Expected header as dialog item\n");
     /* HDS_DRAGDROP set by default */
-    ok(GetWindowLongPtr(hHeader, GWL_STYLE) & HDS_DRAGDROP, "Expected header to have HDS_DRAGDROP\n");
+    ok(GetWindowLongPtrA(hHeader, GWL_STYLE) & HDS_DRAGDROP, "Expected header to have HDS_DRAGDROP\n");
     DestroyWindow(hList);
 
     /* setting LVS_EX_HEADERDRAGDROP creates header */
-    hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
+                          GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
-    SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader) ||
        broken(!IsWindow(hHeader)), /* 4.7x common controls */
        "Header should be created\n");
@@ -1616,13 +1633,13 @@ static void test_create(void)
     DestroyWindow(hList);
 
     /* setting LVS_EX_GRIDLINES creates header */
-    hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
+                          GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
-    SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_GRIDLINES);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_GRIDLINES);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader) ||
        broken(!IsWindow(hHeader)), /* 4.7x common controls */
        "Header should be created\n");
@@ -1630,13 +1647,13 @@ static void test_create(void)
     DestroyWindow(hList);
 
     /* setting LVS_EX_FULLROWSELECT creates header */
-    hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hList = CreateWindowA("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
+                          GetModuleHandleA(NULL), 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
-    SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(IsWindow(hHeader) ||
        broken(!IsWindow(hHeader)), /* 4.7x common controls */
        "Header should be created\n");
@@ -1645,26 +1662,26 @@ static void test_create(void)
 
     /* not report style accepts LVS_EX_HEADERDRAGDROP too */
     hList = create_listview_control(LVS_ICON);
-    SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
-    r = SendMessage(hList, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
+    SendMessageA(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_HEADERDRAGDROP);
+    r = SendMessageA(hList, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
     ok(r & LVS_EX_HEADERDRAGDROP, "Expected LVS_EX_HEADERDRAGDROP to be set\n");
     DestroyWindow(hList);
 
     /* requesting header info with LVM_GETSUBITEMRECT doesn't create it */
-    hList = CreateWindow("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
-                          GetModuleHandle(NULL), 0);
+    hList = CreateWindowA("SysListView32", "Test", LVS_REPORT, 0, 0, 100, 100, NULL, NULL,
+                          GetModuleHandleA(NULL), 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(NULL == GetDlgItem(hList, 0), "NULL dialog item expected\n");
 
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = -10;
-    r = SendMessage(hList, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
+    r = SendMessageA(hList, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
     /* right value contains garbage, probably because header columns are not set up */
     expect(0, rect.bottom);
     expect(1, r);
 
-    hHeader = (HWND)SendMessage(hList, LVM_GETHEADER, 0, 0);
+    hHeader = (HWND)SendMessageA(hList, LVM_GETHEADER, 0, 0);
     ok(!IsWindow(hHeader), "Header shouldn't be created\n");
     ok(GetDlgItem(hList, 0) == NULL, "NULL dialog item expected\n");
 
@@ -1698,7 +1715,7 @@ static void test_redraw(void)
 
     /* forward WM_ERASEBKGND to parent on CLR_NONE background color */
     /* 1. Without backbuffer */
-    res = ListView_SetBkColor(hwnd, CLR_NONE);
+    res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
     expect(TRUE, res);
 
     hdc = GetWindowDC(hwndparent);
@@ -1709,7 +1726,7 @@ static void test_redraw(void)
     ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, forward_erasebkgnd_parent_seq,
                 "forward WM_ERASEBKGND on CLR_NONE", FALSE);
 
-    res = ListView_SetBkColor(hwnd, CLR_DEFAULT);
+    res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_DEFAULT);
     expect(TRUE, res);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
@@ -1721,7 +1738,7 @@ static void test_redraw(void)
     /* 2. With backbuffer */
     SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_DOUBLEBUFFER,
                                                      LVS_EX_DOUBLEBUFFER);
-    res = ListView_SetBkColor(hwnd, CLR_NONE);
+    res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
     expect(TRUE, res);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
@@ -1730,7 +1747,7 @@ static void test_redraw(void)
     ok_sequence(sequences, PARENT_FULL_SEQ_INDEX, forward_erasebkgnd_parent_seq,
                 "forward WM_ERASEBKGND on CLR_NONE", FALSE);
 
-    res = ListView_SetBkColor(hwnd, CLR_DEFAULT);
+    res = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_DEFAULT);
     expect(TRUE, res);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
@@ -1790,13 +1807,13 @@ static void test_customdraw(void)
     insert_column(hwnd, 1);
     insert_item(hwnd, 0);
 
-    oldwndproc = (WNDPROC)SetWindowLongPtr(hwndparent, GWLP_WNDPROC,
+    oldwndproc = (WNDPROC)SetWindowLongPtrA(hwndparent, GWLP_WNDPROC,
                                            (LONG_PTR)cd_wndproc);
 
     InvalidateRect(hwnd, NULL, TRUE);
     UpdateWindow(hwnd);
 
-    SetWindowLongPtr(hwndparent, GWLP_WNDPROC, (LONG_PTR)oldwndproc);
+    SetWindowLongPtrA(hwndparent, GWLP_WNDPROC, (LONG_PTR)oldwndproc);
 
     DestroyWindow(hwnd);
 }
@@ -1813,25 +1830,25 @@ static void test_icon_spacing(void)
     hwnd = create_listview_control(LVS_ICON);
     ok(hwnd != NULL, "failed to create a listview window\n");
 
-    r = SendMessage(hwnd, WM_NOTIFYFORMAT, (WPARAM)hwndparent, NF_REQUERY);
+    r = SendMessageA(hwnd, WM_NOTIFYFORMAT, (WPARAM)hwndparent, NF_REQUERY);
     expect(NFR_ANSI, r);
 
     /* reset the icon spacing to defaults */
-    SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
+    SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
 
     /* now we can request what the defaults are */
-    r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
+    r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1, -1));
     w = LOWORD(r);
     h = HIWORD(r);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(20, 30));
+    r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(20, 30));
     ok(r == MAKELONG(w, h) ||
        broken(r == MAKELONG(w, w)), /* win98 */
        "Expected %d, got %d\n", MAKELONG(w, h), r);
 
-    r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(25, 35));
+    r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(25, 35));
     if (r == 0)
     {
         /* version 4.0 */
@@ -1841,7 +1858,7 @@ static void test_icon_spacing(void)
     }
     expect(MAKELONG(20,30), r);
 
-    r = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1,-1));
+    r = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(-1,-1));
     expect(MAKELONG(25,35), r);
 
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_icon_spacing_seq, "test icon spacing seq", FALSE);
@@ -1869,19 +1886,19 @@ static void test_color(void)
     {
         color = colors[i];
 
-        r = SendMessage(hwnd, LVM_SETBKCOLOR, 0, color);
+        r = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, color);
         expect(TRUE, r);
-        r = SendMessage(hwnd, LVM_GETBKCOLOR, 0, 0);
+        r = SendMessageA(hwnd, LVM_GETBKCOLOR, 0, 0);
         expect(color, r);
 
-        r = SendMessage(hwnd, LVM_SETTEXTCOLOR, 0, color);
+        r = SendMessageA(hwnd, LVM_SETTEXTCOLOR, 0, color);
         expect (TRUE, r);
-        r = SendMessage(hwnd, LVM_GETTEXTCOLOR, 0, 0);
+        r = SendMessageA(hwnd, LVM_GETTEXTCOLOR, 0, 0);
         expect(color, r);
 
-        r = SendMessage(hwnd, LVM_SETTEXTBKCOLOR, 0, color);
+        r = SendMessageA(hwnd, LVM_SETTEXTBKCOLOR, 0, color);
         expect(TRUE, r);
-        r = SendMessage(hwnd, LVM_GETTEXTBKCOLOR, 0, 0);
+        r = SendMessageA(hwnd, LVM_GETTEXTBKCOLOR, 0, 0);
         expect(color, r);
     }
 
@@ -1891,7 +1908,7 @@ static void test_color(void)
     /* invalidation test done separately to avoid a message chain mess */
     r = ValidateRect(hwnd, NULL);
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_SETBKCOLOR, 0, colors[0]);
+    r = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, colors[0]);
     expect(TRUE, r);
 
     rect.right = rect.bottom = 1;
@@ -1901,7 +1918,7 @@ static void test_color(void)
 
     r = ValidateRect(hwnd, NULL);
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_SETTEXTCOLOR, 0, colors[0]);
+    r = SendMessageA(hwnd, LVM_SETTEXTCOLOR, 0, colors[0]);
     expect(TRUE, r);
 
     rect.right = rect.bottom = 1;
@@ -1911,7 +1928,7 @@ static void test_color(void)
 
     r = ValidateRect(hwnd, NULL);
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_SETTEXTBKCOLOR, 0, colors[0]);
+    r = SendMessageA(hwnd, LVM_SETTEXTBKCOLOR, 0, colors[0]);
     expect(TRUE, r);
 
     rect.right = rect.bottom = 1;
@@ -1934,9 +1951,9 @@ static void test_item_count(void)
     RECT rect;
     INT height;
 
-    LVITEM item0;
-    LVITEM item1;
-    LVITEM item2;
+    LVITEMA item0;
+    LVITEMA item1;
+    LVITEMA item2;
     static CHAR item0text[] = "item0";
     static CHAR item1text[] = "item1";
     static CHAR item2text[] = "item2";
@@ -1959,7 +1976,7 @@ static void test_item_count(void)
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(0, r);
 
     /* [item0] */
@@ -1967,7 +1984,7 @@ static void test_item_count(void)
     item0.iItem = 0;
     item0.iSubItem = 0;
     item0.pszText = item0text;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item0);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item0);
     expect(0, r);
 
     /* [item0, item1] */
@@ -1975,7 +1992,7 @@ static void test_item_count(void)
     item1.iItem = 1;
     item1.iSubItem = 0;
     item1.pszText = item1text;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
     expect(1, r);
 
     /* [item0, item1, item2] */
@@ -1983,42 +2000,42 @@ static void test_item_count(void)
     item2.iItem = 2;
     item2.iSubItem = 0;
     item2.pszText = item2text;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item2);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item2);
     expect(2, r);
 
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(3, r);
 
     /* [item0, item1] */
-    r = SendMessage(hwnd, LVM_DELETEITEM, 2, 0);
+    r = SendMessageA(hwnd, LVM_DELETEITEM, 2, 0);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(2, r);
 
     /* [] */
-    r = SendMessage(hwnd, LVM_DELETEALLITEMS, 0, 0);
+    r = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(0, r);
 
     /* [item0] */
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
     expect(0, r);
 
     /* [item0, item1] */
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
     expect(1, r);
 
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(2, r);
 
     /* [item0, item1, item2] */
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item2);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item2);
     expect(2, r);
 
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(3, r);
 
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_item_count_seq, "test item count seq", FALSE);
@@ -2035,9 +2052,9 @@ static void test_item_position(void)
     DWORD r;
     POINT position;
 
-    LVITEM item0;
-    LVITEM item1;
-    LVITEM item2;
+    LVITEMA item0;
+    LVITEMA item1;
+    LVITEMA item2;
     static CHAR item0text[] = "item0";
     static CHAR item1text[] = "item1";
     static CHAR item2text[] = "item2";
@@ -2052,7 +2069,7 @@ static void test_item_position(void)
     item0.iItem = 0;
     item0.iSubItem = 0;
     item0.pszText = item0text;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item0);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item0);
     expect(0, r);
 
     /* [item0, item1] */
@@ -2060,7 +2077,7 @@ static void test_item_position(void)
     item1.iItem = 1;
     item1.iSubItem = 0;
     item1.pszText = item1text;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item1);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item1);
     expect(1, r);
 
     /* [item0, item1, item2] */
@@ -2068,24 +2085,24 @@ static void test_item_position(void)
     item2.iItem = 2;
     item2.iSubItem = 0;
     item2.pszText = item2text;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item2);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item2);
     expect(2, r);
 
-    r = SendMessage(hwnd, LVM_SETITEMPOSITION, 1, MAKELPARAM(10,5));
+    r = SendMessageA(hwnd, LVM_SETITEMPOSITION, 1, MAKELPARAM(10,5));
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_GETITEMPOSITION, 1, (LPARAM) &position);
+    r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 1, (LPARAM) &position);
     expect(TRUE, r);
     expect2(10, 5, position.x, position.y);
 
-    r = SendMessage(hwnd, LVM_SETITEMPOSITION, 2, MAKELPARAM(0,0));
+    r = SendMessageA(hwnd, LVM_SETITEMPOSITION, 2, MAKELPARAM(0,0));
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_GETITEMPOSITION, 2, (LPARAM) &position);
+    r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 2, (LPARAM) &position);
     expect(TRUE, r);
     expect2(0, 0, position.x, position.y);
 
-    r = SendMessage(hwnd, LVM_SETITEMPOSITION, 0, MAKELPARAM(20,20));
+    r = SendMessageA(hwnd, LVM_SETITEMPOSITION, 0, MAKELPARAM(20,20));
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM) &position);
+    r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM) &position);
     expect(TRUE, r);
     expect2(20, 20, position.x, position.y);
 
@@ -2109,7 +2126,7 @@ static void test_getorigin(void)
     ok(hwnd != NULL, "failed to create a listview window\n");
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
+    r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
     expect(TRUE, r);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     DestroyWindow(hwnd);
@@ -2118,7 +2135,7 @@ static void test_getorigin(void)
     ok(hwnd != NULL, "failed to create a listview window\n");
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
+    r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
     expect(TRUE, r);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     DestroyWindow(hwnd);
@@ -2127,7 +2144,7 @@ static void test_getorigin(void)
     ok(hwnd != NULL, "failed to create a listview window\n");
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
+    r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
     expect(FALSE, r);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     DestroyWindow(hwnd);
@@ -2136,7 +2153,7 @@ static void test_getorigin(void)
     ok(hwnd != NULL, "failed to create a listview window\n");
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    r = SendMessage(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
+    r = SendMessageA(hwnd, LVM_GETORIGIN, 0, (LPARAM)&position);
     expect(FALSE, r);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     DestroyWindow(hwnd);
@@ -2174,7 +2191,7 @@ static void test_multiselect(void)
     for (i = 0; i < items; i++)
         insert_item(hwnd, 0);
 
-    item_count = (int)SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    item_count = (int)SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(items, item_count);
 
     for (i = 0; i < 4; i++) {
@@ -2186,10 +2203,10 @@ static void test_multiselect(void)
         item.state = 0;
         item.stateMask = LVIS_SELECTED;
         SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
-       SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
+       SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
 
        /* set initial position */
-       SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, (task.initPos == -1 ? item_count -1 : task.initPos));
+       SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, (task.initPos == -1 ? item_count -1 : task.initPos));
 
         item.state = LVIS_SELECTED;
         item.stateMask = LVIS_SELECTED;
@@ -2204,13 +2221,13 @@ static void test_multiselect(void)
         SetKeyboardState(kstate);
 
        for (j=1;j<=(task.count == -1 ? item_count : task.count);j++) {
-           r = SendMessage(hwnd, WM_KEYDOWN, task.loopVK, 0);
+           r = SendMessageA(hwnd, WM_KEYDOWN, task.loopVK, 0);
            expect(0,r);
-           r = SendMessage(hwnd, WM_KEYUP, task.loopVK, 0);
+           r = SendMessageA(hwnd, WM_KEYUP, task.loopVK, 0);
            expect(0,r);
        }
 
-       selected_count = (int)SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
+       selected_count = (int)SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
 
        ok((task.result == -1 ? item_count : task.result) == selected_count, "Failed multiple selection %s. There should be %d selected items (is %d)\n", task.descr, item_count, selected_count);
 
@@ -2226,7 +2243,7 @@ static void test_multiselect(void)
     for (i=0;i<items;i++) {
            insert_item(hwnd, 0);
     }
-    item_count = (int)SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    item_count = (int)SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
     expect(items,item_count);
 
     /* try with NULL pointer */
@@ -2299,16 +2316,16 @@ static void test_multiselect(void)
     ok_sequence(sequences, PARENT_SEQ_INDEX, changing_all_parent_seq,
                 "set state all notification 3", FALSE);
 
-    SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
+    SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
     for (i = 0; i < 3; i++) {
         item.state = LVIS_SELECTED;
         item.stateMask = LVIS_SELECTED;
         SendMessageA(hwnd, LVM_SETITEMSTATE, i, (LPARAM)&item);
     }
 
-    r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
     expect(3, r);
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(-1, r);
 
     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
@@ -2319,12 +2336,12 @@ static void test_multiselect(void)
     ok(style & LVS_SINGLESEL, "LVS_SINGLESEL expected\n");
 
     for (i=0;i<3;i++) {
-        r = ListView_GetItemState(hwnd, i, LVIS_SELECTED);
+        r = SendMessageA(hwnd, LVM_GETITEMSTATE, i, LVIS_SELECTED);
         ok(r & LVIS_SELECTED, "Expected item %d to be selected\n", i);
     }
-    r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
     expect(3, r);
-    SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(3, r);
 
     /* select one more */
@@ -2333,119 +2350,120 @@ static void test_multiselect(void)
     SendMessageA(hwnd, LVM_SETITEMSTATE, 3, (LPARAM)&item);
 
     for (i=0;i<3;i++) {
-        r = ListView_GetItemState(hwnd, i, LVIS_SELECTED);
+        r = SendMessageA(hwnd, LVM_GETITEMSTATE, i, LVIS_SELECTED);
         ok(!(r & LVIS_SELECTED), "Expected item %d to be unselected\n", i);
     }
-    r = ListView_GetItemState(hwnd, 3, LVIS_SELECTED);
+
+    r = SendMessageA(hwnd, LVM_GETITEMSTATE, 3, LVIS_SELECTED);
     ok(r & LVIS_SELECTED, "Expected item %d to be selected\n", i);
 
-    r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
     expect(1, r);
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(-1, r);
 
     /* try to select all on LVS_SINGLESEL */
     memset(&item, 0, sizeof(item));
     item.stateMask = LVIS_SELECTED;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
     expect(TRUE, r);
-    SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
+    SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
 
     item.stateMask = LVIS_SELECTED;
     item.state     = LVIS_SELECTED;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
     expect(FALSE, r);
 
-    r = ListView_GetSelectedCount(hwnd);
+    r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
     expect(0, r);
-    r = ListView_GetSelectionMark(hwnd);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(-1, r);
 
     /* try to deselect all on LVS_SINGLESEL */
     item.stateMask = LVIS_SELECTED;
     item.state     = LVIS_SELECTED;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
     expect(TRUE, r);
 
     item.stateMask = LVIS_SELECTED;
     item.state     = 0;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
     expect(TRUE, r);
-    r = ListView_GetSelectedCount(hwnd);
+    r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
     expect(0, r);
 
     /* 1. selection mark is update when new focused item is set */
     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_SINGLESEL);
 
-    r = SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
+    r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
     expect(-1, r);
 
     item.stateMask = LVIS_FOCUSED;
     item.state     = LVIS_FOCUSED;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(0, r);
 
     /* it's not updated if already set */
     item.stateMask = LVIS_FOCUSED;
     item.state     = LVIS_FOCUSED;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, 1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, 1, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(0, r);
 
-    r = SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
+    r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
     expect(0, r);
 
     item.stateMask = LVIS_FOCUSED;
     item.state     = LVIS_FOCUSED;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, 1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, 1, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(-1, r);
 
     /* need to reset focused item first */
     item.stateMask = LVIS_FOCUSED;
     item.state     = 0;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
     expect(TRUE, r);
 
     item.stateMask = LVIS_FOCUSED;
     item.state     = LVIS_FOCUSED;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, 2, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, 2, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(2, r);
 
     item.stateMask = LVIS_FOCUSED;
     item.state     = 0;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(2, r);
 
     /* 2. same tests, with LVM_SETITEM */
     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_SINGLESEL);
 
-    r = SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
+    r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
     expect(2, r);
 
     item.stateMask = LVIS_FOCUSED;
     item.state     = LVIS_FOCUSED;
     item.mask      = LVIF_STATE;
     item.iItem = item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(0, r);
 
     /* it's not updated if already set */
@@ -2454,13 +2472,13 @@ static void test_multiselect(void)
     item.mask      = LVIF_STATE;
     item.iItem     = 1;
     item.iSubItem  = 0;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(0, r);
 
-    r = SendMessage(hwnd, LVM_SETSELECTIONMARK, 0, -1);
+    r = SendMessageA(hwnd, LVM_SETSELECTIONMARK, 0, -1);
     expect(0, r);
 
     item.stateMask = LVIS_FOCUSED;
@@ -2468,16 +2486,16 @@ static void test_multiselect(void)
     item.mask      = LVIF_STATE;
     item.iItem     = 1;
     item.iSubItem  = 0;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(-1, r);
 
     /* need to reset focused item first */
     item.stateMask = LVIS_FOCUSED;
     item.state     = 0;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
     expect(TRUE, r);
 
     item.stateMask = LVIS_FOCUSED;
@@ -2485,18 +2503,18 @@ static void test_multiselect(void)
     item.mask      = LVIF_STATE;
     item.iItem     = 2;
     item.iSubItem  = 0;
-    r = SendMessage(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(2, r);
 
     item.stateMask = LVIS_FOCUSED;
     item.state     = 0;
-    r = SendMessage(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMSTATE, -1, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(2, r);
 
     DestroyWindow(hwnd);
@@ -2506,7 +2524,7 @@ static void test_subitem_rect(void)
 {
     HWND hwnd;
     DWORD r;
-    LVCOLUMN col;
+    LVCOLUMNA col;
     RECT rect, rect2;
     INT arr[3];
 
@@ -2514,28 +2532,28 @@ static void test_subitem_rect(void)
     hwnd = create_listview_control(LVS_REPORT);
     ok(hwnd != NULL, "failed to create a listview window\n");
     /* add some columns */
-    memset(&col, 0, sizeof(LVCOLUMN));
+    memset(&col, 0, sizeof(LVCOLUMNA));
     col.mask = LVCF_WIDTH;
     col.cx = 100;
-    r = SendMessage(hwnd, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, r);
     col.cx = 150;
-    r = SendMessage(hwnd, LVM_INSERTCOLUMN, 1, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 1, (LPARAM)&col);
     expect(1, r);
     col.cx = 200;
-    r = SendMessage(hwnd, LVM_INSERTCOLUMN, 2, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 2, (LPARAM)&col);
     expect(2, r);
     /* item = -1 means header, subitem index is 1 based */
     rect.left = LVIR_BOUNDS;
     rect.top  = 0;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
     expect(0, r);
 
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
     expect(1, r);
 
     expect(100, rect.left);
@@ -2545,7 +2563,7 @@ static void test_subitem_rect(void)
     rect.left = LVIR_BOUNDS;
     rect.top  = 2;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
     expect(1, r);
 
     expect(250, rect.left);
@@ -2558,7 +2576,7 @@ static void test_subitem_rect(void)
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(1, r);
     expect(100, rect.left);
     expect(250, rect.right);
@@ -2566,7 +2584,7 @@ static void test_subitem_rect(void)
     rect.left = LVIR_ICON;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(1, r);
     /* no icon attached - zero width rectangle, with no left padding */
     expect(100, rect.left);
@@ -2575,23 +2593,23 @@ static void test_subitem_rect(void)
     rect.left = LVIR_LABEL;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(1, r);
     /* same as full LVIR_BOUNDS */
     expect(100, rect.left);
     expect(250, rect.right);
 
-    SendMessage(hwnd, LVM_SCROLL, 10, 0);
+    SendMessageA(hwnd, LVM_SCROLL, 10, 0);
 
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(1, r);
     expect(90, rect.left);
     expect(240, rect.right);
 
-    SendMessage(hwnd, LVM_SCROLL, -10, 0);
+    SendMessageA(hwnd, LVM_SCROLL, -10, 0);
 
     /* test header interaction */
     subclass_header(hwnd);
@@ -2600,25 +2618,25 @@ static void test_subitem_rect(void)
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
     expect(1, r);
 
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(1, r);
 
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -10, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -10, (LPARAM)&rect);
     expect(1, r);
 
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = 0;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 20, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 20, (LPARAM)&rect);
     expect(1, r);
 
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getsubitemrect_seq, "LVM_GETSUBITEMRECT negative index", FALSE);
@@ -2628,19 +2646,19 @@ static void test_subitem_rect(void)
     /* test subitem rects after re-arranging columns */
     hwnd = create_listview_control(LVS_REPORT);
     ok(hwnd != NULL, "failed to create a listview window\n");
-    memset(&col, 0, sizeof(LVCOLUMN));
+    memset(&col, 0, sizeof(LVCOLUMNA));
     col.mask = LVCF_WIDTH;
 
     col.cx = 100;
-    r = SendMessage(hwnd, LVM_INSERTCOLUMN, 0, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, r);
 
     col.cx = 200;
-    r = SendMessage(hwnd, LVM_INSERTCOLUMN, 1, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 1, (LPARAM)&col);
     expect(1, r);
 
     col.cx = 300;
-    r = SendMessage(hwnd, LVM_INSERTCOLUMN, 2, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 2, (LPARAM)&col);
     expect(2, r);
 
     insert_item(hwnd, 0);
@@ -2650,20 +2668,20 @@ static void test_subitem_rect(void)
     rect.left = LVIR_BOUNDS;
     rect.top  = 0;
     rect.right = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect);
     expect(FALSE, r);
 
     /* for subitems rectangle is calculated even if there's no item added */
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect);
     expect(TRUE, r);
 
     rect2.left = LVIR_BOUNDS;
     rect2.top  = 1;
     rect2.right = rect2.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect2);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 2, (LPARAM)&rect2);
     expect(TRUE, r);
     expect(rect.right, rect2.right);
     expect(rect.left, rect2.left);
@@ -2671,13 +2689,13 @@ static void test_subitem_rect(void)
     ok(rect2.bottom > rect2.top, "expected not zero height\n");
 
     arr[0] = 1; arr[1] = 0; arr[2] = 2;
-    r = SendMessage(hwnd, LVM_SETCOLUMNORDERARRAY, 3, (LPARAM)arr);
+    r = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 3, (LPARAM)arr);
     expect(TRUE, r);
 
     rect.left = LVIR_BOUNDS;
     rect.top  = 0;
     rect.right = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     expect(0, rect.left);
     expect(600, rect.right);
@@ -2685,7 +2703,7 @@ static void test_subitem_rect(void)
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     expect(0, rect.left);
     expect(200, rect.right);
@@ -2693,7 +2711,7 @@ static void test_subitem_rect(void)
     rect2.left = LVIR_BOUNDS;
     rect2.top  = 1;
     rect2.right = rect2.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect2);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 1, (LPARAM)&rect2);
     expect(TRUE, r);
     expect(0, rect2.left);
     expect(200, rect2.right);
@@ -2705,7 +2723,7 @@ static void test_subitem_rect(void)
     rect.left = LVIR_BOUNDS;
     rect.top  = 2;
     rect.right = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     expect(300, rect.left);
     expect(600, rect.right);
@@ -2713,12 +2731,12 @@ static void test_subitem_rect(void)
     DestroyWindow(hwnd);
 
     /* try it for non LVS_REPORT style */
-    hwnd = CreateWindow("SysListView32", "Test", LVS_ICON, 0, 0, 100, 100, NULL, NULL,
-                         GetModuleHandle(NULL), 0);
+    hwnd = CreateWindowA("SysListView32", "Test", LVS_ICON, 0, 0, 100, 100, NULL, NULL,
+                         GetModuleHandleA(NULL), 0);
     rect.left = LVIR_BOUNDS;
     rect.top  = 1;
     rect.right = rect.bottom = -10;
-    r = SendMessage(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETSUBITEMRECT, -1, (LPARAM)&rect);
     expect(0, r);
     /* rect is unchanged */
     expect(0, rect.left);
@@ -2753,14 +2771,14 @@ static void test_sorting(void)
     item.iItem = 0;
     item.iSubItem = 0;
     item.lParam = 3;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
 
     item.mask = LVIF_PARAM;
     item.iItem = 1;
     item.iSubItem = 0;
     item.lParam = 2;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     item.mask = LVIF_STATE | LVIF_PARAM;
@@ -2768,27 +2786,27 @@ static void test_sorting(void)
     item.iItem = 2;
     item.iSubItem = 0;
     item.lParam = 4;
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(2, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(-1, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
     expect(2, r);
 
-    r = SendMessage(hwnd, LVM_SORTITEMS, 0, (LPARAM)test_CallBackCompare);
+    r = SendMessageA(hwnd, LVM_SORTITEMS, 0, (LPARAM)test_CallBackCompare);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTEDCOUNT, 0, 0);
     expect(2, r);
-    r = SendMessage(hwnd, LVM_GETSELECTIONMARK, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETSELECTIONMARK, 0, 0);
     expect(-1, r);
-    r = SendMessage(hwnd, LVM_GETITEMSTATE, 0, LVIS_SELECTED);
+    r = SendMessageA(hwnd, LVM_GETITEMSTATE, 0, LVIS_SELECTED);
     expect(0, r);
-    r = SendMessage(hwnd, LVM_GETITEMSTATE, 1, LVIS_SELECTED);
+    r = SendMessageA(hwnd, LVM_GETITEMSTATE, 1, LVIS_SELECTED);
     expect(LVIS_SELECTED, r);
-    r = SendMessage(hwnd, LVM_GETITEMSTATE, 2, LVIS_SELECTED);
+    r = SendMessageA(hwnd, LVM_GETITEMSTATE, 2, LVIS_SELECTED);
     expect(LVIS_SELECTED, r);
 
     DestroyWindow(hwnd);
@@ -2801,21 +2819,21 @@ static void test_sorting(void)
     item.iItem = 0;
     item.iSubItem = 0;
     item.pszText = names[1];
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
 
     item.mask = LVIF_TEXT;
     item.iItem = 1;
     item.iSubItem = 0;
     item.pszText = names[2];
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(1, r);
 
     item.mask = LVIF_TEXT;
     item.iItem = 2;
     item.iSubItem = 0;
     item.pszText = names[0];
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(2, r);
 
     style = GetWindowLongPtrA(hwnd, GWL_STYLE);
@@ -2828,87 +2846,87 @@ static void test_sorting(void)
     item.iItem = 0;
     item.pszText = buff;
     item.cchTextMax = sizeof(buff);
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
+    ok(lstrcmpA(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
 
     item.iItem = 1;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
+    ok(lstrcmpA(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
 
     item.iItem = 2;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
+    ok(lstrcmpA(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
 
     /* adding new item doesn't resort list */
     item.mask = LVIF_TEXT;
     item.iItem = 3;
     item.iSubItem = 0;
     item.pszText = names[3];
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(3, r);
 
     item.mask = LVIF_TEXT;
     item.iItem = 0;
     item.pszText = buff;
     item.cchTextMax = sizeof(buff);
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
+    ok(lstrcmpA(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
 
     item.iItem = 1;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
+    ok(lstrcmpA(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
 
     item.iItem = 2;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
+    ok(lstrcmpA(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
 
     item.iItem = 3;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
+    ok(lstrcmpA(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
 
     /* corner case - item should be placed at first position */
     item.mask = LVIF_TEXT;
     item.iItem = 4;
     item.iSubItem = 0;
     item.pszText = names[4];
-    r = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM) &item);
     expect(0, r);
 
     item.iItem = 0;
     item.pszText = buff;
     item.cchTextMax = sizeof(buff);
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[4]) == 0, "Expected '%s', got '%s'\n", names[4], buff);
+    ok(lstrcmpA(buff, names[4]) == 0, "Expected '%s', got '%s'\n", names[4], buff);
 
     item.iItem = 1;
     item.pszText = buff;
     item.cchTextMax = sizeof(buff);
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
+    ok(lstrcmpA(buff, names[1]) == 0, "Expected '%s', got '%s'\n", names[1], buff);
 
     item.iItem = 2;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
+    ok(lstrcmpA(buff, names[2]) == 0, "Expected '%s', got '%s'\n", names[2], buff);
 
     item.iItem = 3;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
+    ok(lstrcmpA(buff, names[0]) == 0, "Expected '%s', got '%s'\n", names[0], buff);
 
     item.iItem = 4;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM) &item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM) &item);
     expect(TRUE, r);
-    ok(lstrcmp(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
+    ok(lstrcmpA(buff, names[3]) == 0, "Expected '%s', got '%s'\n", names[3], buff);
 
     DestroyWindow(hwnd);
 }
@@ -3013,11 +3031,11 @@ static void test_ownerdata(void)
     item.iItem = 0;
     item.stateMask = LVIS_SELECTED;
     item.state     = LVIS_SELECTED;
-    res = SendMessageA(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(FALSE, res);
     memset(&item, 0, sizeof(item));
     item.pszText = test_str;
-    res = SendMessageA(hwnd, LVM_SETITEMTEXT, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
     expect(FALSE, res);
     DestroyWindow(hwnd);
 
@@ -3172,7 +3190,7 @@ static void test_ownerdata(void)
     /* focus single item, remove all */
     item.stateMask = LVIS_FOCUSED;
     item.state     = LVIS_FOCUSED;
-    res = SendMessage(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_SETITEMSTATE, 0, (LPARAM)&item);
     expect(TRUE, res);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     item.stateMask = LVIS_FOCUSED;
@@ -3326,21 +3344,21 @@ static void test_norecompute(void)
     item.stateMask = LVIS_SELECTED;
     item.state     = LVIS_SELECTED;
     item.pszText   = testA;
-    res = SendMessageA(hwnd, LVM_INSERTITEM, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(0, res);
     /* retrieve with LVIF_NORECOMPUTE */
     item.mask  = LVIF_TEXT | LVIF_NORECOMPUTE;
     item.iItem = 0;
     item.pszText    = buff;
     item.cchTextMax = sizeof(buff)/sizeof(CHAR);
-    res = SendMessageA(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
     expect(TRUE, res);
-    ok(lstrcmp(buff, testA) == 0, "Expected (%s), got (%s)\n", testA, buff);
+    ok(lstrcmpA(buff, testA) == 0, "Expected (%s), got (%s)\n", testA, buff);
 
     item.mask = LVIF_TEXT;
     item.iItem = 1;
-    item.pszText = LPSTR_TEXTCALLBACK;
-    res = SendMessageA(hwnd, LVM_INSERTITEM, 0, (LPARAM)&item);
+    item.pszText = LPSTR_TEXTCALLBACKA;
+    res = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(1, res);
 
     item.mask  = LVIF_TEXT | LVIF_NORECOMPUTE;
@@ -3349,10 +3367,10 @@ static void test_norecompute(void)
     item.cchTextMax = sizeof(buff)/sizeof(CHAR);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    res = SendMessageA(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
     expect(TRUE, res);
-    ok(item.pszText == LPSTR_TEXTCALLBACK, "Expected (%p), got (%p)\n",
-       LPSTR_TEXTCALLBACK, (VOID*)item.pszText);
+    ok(item.pszText == LPSTR_TEXTCALLBACKA, "Expected (%p), got (%p)\n",
+       LPSTR_TEXTCALLBACKA, (VOID*)item.pszText);
     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "retrieve with LVIF_NORECOMPUTE seq", FALSE);
 
     DestroyWindow(hwnd);
@@ -3365,7 +3383,7 @@ static void test_norecompute(void)
     item.stateMask = LVIS_SELECTED;
     item.state     = LVIS_SELECTED;
     item.iItem = 0;
-    res = SendMessageA(hwnd, LVM_INSERTITEM, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(0, res);
 
     item.mask  = LVIF_TEXT | LVIF_NORECOMPUTE;
@@ -3373,10 +3391,10 @@ static void test_norecompute(void)
     item.pszText    = buff;
     item.cchTextMax = sizeof(buff)/sizeof(CHAR);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    res = SendMessageA(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
+    res = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
     expect(TRUE, res);
-    ok(item.pszText == LPSTR_TEXTCALLBACK, "Expected (%p), got (%p)\n",
-       LPSTR_TEXTCALLBACK, (VOID*)item.pszText);
+    ok(item.pszText == LPSTR_TEXTCALLBACKA, "Expected (%p), got (%p)\n",
+       LPSTR_TEXTCALLBACKA, (VOID*)item.pszText);
     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "retrieve with LVIF_NORECOMPUTE seq 2", FALSE);
 
     DestroyWindow(hwnd);
@@ -3393,13 +3411,13 @@ static void test_nosortheader(void)
     header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "header expected\n");
 
-    style = GetWindowLongPtr(header, GWL_STYLE);
+    style = GetWindowLongPtrA(header, GWL_STYLE);
     ok(style & HDS_BUTTONS, "expected header to have HDS_BUTTONS\n");
 
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
-    SetWindowLongPtr(hwnd, GWL_STYLE, style | LVS_NOSORTHEADER);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
+    SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_NOSORTHEADER);
     /* HDS_BUTTONS retained */
-    style = GetWindowLongPtr(header, GWL_STYLE);
+    style = GetWindowLongPtrA(header, GWL_STYLE);
     ok(style & HDS_BUTTONS, "expected header to retain HDS_BUTTONS\n");
 
     DestroyWindow(hwnd);
@@ -3411,13 +3429,13 @@ static void test_nosortheader(void)
     header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "header expected\n");
 
-    style = GetWindowLongPtr(header, GWL_STYLE);
+    style = GetWindowLongPtrA(header, GWL_STYLE);
     ok(!(style & HDS_BUTTONS), "expected header to have no HDS_BUTTONS\n");
 
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
-    SetWindowLongPtr(hwnd, GWL_STYLE, style & ~LVS_NOSORTHEADER);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
+    SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_NOSORTHEADER);
     /* not changed here */
-    style = GetWindowLongPtr(header, GWL_STYLE);
+    style = GetWindowLongPtrA(header, GWL_STYLE);
     ok(!(style & HDS_BUTTONS), "expected header to have no HDS_BUTTONS\n");
 
     DestroyWindow(hwnd);
@@ -3438,20 +3456,20 @@ static void test_setredraw(void)
        ListView seems to handle it internally without DefWinProc */
 
     /* default value first */
-    ret = SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
     expect(0, ret);
     /* disable */
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     ok(style & WS_VISIBLE, "Expected WS_VISIBLE to be set\n");
-    ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
     expect(0, ret);
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     ok(style & WS_VISIBLE, "Expected WS_VISIBLE to be set\n");
-    ret = SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
     expect(0, ret);
 
     /* check update rect after redrawing */
-    ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
     expect(0, ret);
     InvalidateRect(hwnd, NULL, FALSE);
     RedrawWindow(hwnd, NULL, NULL, RDW_UPDATENOW);
@@ -3462,20 +3480,20 @@ static void test_setredraw(void)
 
     /* WM_ERASEBKGND */
     hdc = GetWindowDC(hwndparent);
-    ret = SendMessage(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
+    ret = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
     expect(TRUE, ret);
-    ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
     expect(0, ret);
-    ret = SendMessage(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
+    ret = SendMessageA(hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0);
     expect(TRUE, ret);
-    ret = SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, TRUE, 0);
     expect(0, ret);
     ReleaseDC(hwndparent, hdc);
 
     /* check notification messages to show that repainting is disabled */
-    ret = SendMessage(hwnd, LVM_SETITEMCOUNT, 1, 0);
+    ret = SendMessageA(hwnd, LVM_SETITEMCOUNT, 1, 0);
     expect(TRUE, ret);
-    ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
     expect(0, ret);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
@@ -3484,7 +3502,7 @@ static void test_setredraw(void)
     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
                 "redraw after WM_SETREDRAW (FALSE)", FALSE);
 
-    ret = SendMessage(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
+    ret = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, CLR_NONE);
     expect(TRUE, ret);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     InvalidateRect(hwnd, NULL, TRUE);
@@ -3495,7 +3513,7 @@ static void test_setredraw(void)
     /* message isn't forwarded to header */
     subclass_header(hwnd);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    ret = SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
+    ret = SendMessageA(hwnd, WM_SETREDRAW, FALSE, 0);
     expect(0, ret);
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, setredraw_seq,
                 "WM_SETREDRAW: not forwarded to header", FALSE);
@@ -3527,25 +3545,25 @@ static void test_hittest(void)
     item.iSubItem = 0;
     /* the only purpose of that line is to be as long as a half item rect */
     item.pszText  = text;
-    r = SendMessage(hwnd, LVM_SETITEMTEXT, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
-    r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
+    r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
+    r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
     expect(TRUE, r);
 
     memset(&bounds, 0, sizeof(bounds));
     bounds.left = LVIR_BOUNDS;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&bounds);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&bounds);
     expect(1, r);
     ok(bounds.bottom - bounds.top > 0, "Expected non zero item height\n");
     ok(bounds.right - bounds.left > 0, "Expected non zero item width\n");
-    r = SendMessage(hwnd, LVM_GETITEMSPACING, TRUE, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMSPACING, TRUE, 0);
     vert = HIWORD(r);
     ok(bounds.bottom - bounds.top == vert,
         "Vertical spacing inconsistent (%d != %d)\n", bounds.bottom - bounds.top, vert);
-    r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pos);
+    r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pos);
     expect(TRUE, r);
 
     /* LVS_EX_FULLROWSELECT not set, no icons attached */
@@ -3599,7 +3617,7 @@ static void test_hittest(void)
     test_lvm_hittest(hwnd, x, y, -1, LVHT_NOWHERE, 0, FALSE, TRUE);
     test_lvm_subitemhittest(hwnd, x, y, 0, 1, LVHT_ONITEMLABEL, FALSE, FALSE, FALSE);
     /* the same with LVS_EX_FULLROWSELECT */
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
     x = pos.x + 150; /* outside column */
     y = pos.y + (bounds.bottom - bounds.top) / 2;
     test_lvm_hittest(hwnd, x, y, 0, LVHT_ONITEM, LVHT_ONITEMLABEL, FALSE, FALSE);
@@ -3634,14 +3652,14 @@ static void test_hittest(void)
     r = ImageList_Add(himl, hbmp, 0);
     ok(r == 1, "should be one\n");
 
-    r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
+    r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
     expect(0, r);
 
     item.mask = LVIF_IMAGE;
     item.iImage = 0;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
     /* on state icon */
     x = pos.x + 8;
@@ -3657,7 +3675,7 @@ static void test_hittest(void)
     item.stateMask = LVIS_STATEIMAGEMASK;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
     /* on state icon */
     x = pos.x + 8;
@@ -3667,10 +3685,10 @@ static void test_hittest(void)
     y = (bounds.bottom - bounds.top) / 2;
     test_lvm_subitemhittest(hwnd, x, y, 0, 0, LVHT_ONITEMSTATEICON, FALSE, FALSE, FALSE);
 
-    himl2 = (HIMAGELIST)SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
+    himl2 = (HIMAGELIST)SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
     ok(himl2 == himl, "should return handle\n");
 
-    r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
+    r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
     expect(0, r);
     /* on item icon */
     x = pos.x + 8;
@@ -3694,7 +3712,7 @@ static void test_getviewrect(void)
     ok(hwnd != NULL, "failed to create a listview window\n");
 
     /* empty */
-    r = SendMessage(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
 
     insert_column(hwnd, 0);
@@ -3703,15 +3721,15 @@ static void test_getviewrect(void)
     memset(&item, 0, sizeof(item));
     item.iItem = 0;
     item.iSubItem = 0;
-    SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
+    SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
 
-    r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
+    r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
     expect(TRUE, r);
-    r = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(120, 0));
+    r = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(120, 0));
     expect(TRUE, r);
 
     rect.left = rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* left is set to (2e31-1) - XP SP2 */
     expect(0, rect.right);
@@ -3719,10 +3737,10 @@ static void test_getviewrect(void)
     expect(0, rect.bottom);
 
     /* switch to LVS_ICON */
-    SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~LVS_REPORT);
+    SetWindowLongA(hwnd, GWL_STYLE, GetWindowLongA(hwnd, GWL_STYLE) & ~LVS_REPORT);
 
     rect.left = rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETVIEWRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     expect(0, rect.left);
     expect(0, rect.top);
@@ -3750,7 +3768,7 @@ static void test_getitemposition(void)
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
     pt.x = pt.y = -1;
-    r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
+    r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
     expect(TRUE, r);
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getitemposition_seq1, "get item position 1", FALSE);
 
@@ -3760,12 +3778,12 @@ static void test_getitemposition(void)
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
     pt.x = pt.y = -1;
-    r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
+    r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
     expect(TRUE, r);
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, getitemposition_seq2, "get item position 2", TRUE);
 
     memset(&rect, 0, sizeof(rect));
-    SendMessage(header, HDM_GETITEMRECT, 0, (LPARAM)&rect);
+    SendMessageA(header, HDM_GETITEMRECT, 0, (LPARAM)&rect);
     /* some padding? */
     expect(2, pt.x);
     /* offset by header height */
@@ -3785,9 +3803,9 @@ static void test_columnscreation(void)
     insert_item(hwnd, 0);
 
     /* headers columns aren't created automatically */
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "Expected header handle\n");
-    r = SendMessage(header, HDM_GETITEMCOUNT, 0, 0);
+    r = SendMessageA(header, HDM_GETITEMCOUNT, 0, 0);
     expect(0, r);
 
     DestroyWindow(hwnd);
@@ -3811,10 +3829,10 @@ static void test_getitemrect(void)
     memset(&item, 0, sizeof(item));
     item.mask = 0;
     item.iItem = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(0, r);
     rect.left = LVIR_LABEL;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     expect(0, rect.left);
     expect(0, rect.top);
@@ -3830,12 +3848,12 @@ static void test_getitemrect(void)
     memset(&item, 0, sizeof(item));
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(0, r);
 
     rect.left = LVIR_BOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
 
     /* zero width rectangle with no padding */
@@ -3847,17 +3865,17 @@ static void test_getitemrect(void)
 
     col.mask = LVCF_WIDTH;
     col.cx   = 50;
-    r = SendMessage(hwnd, LVM_SETCOLUMN, 0, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_SETCOLUMNA, 0, (LPARAM)&col);
     expect(TRUE, r);
 
     col.mask = LVCF_WIDTH;
     col.cx   = 100;
-    r = SendMessage(hwnd, LVM_SETCOLUMN, 1, (LPARAM)&col);
+    r = SendMessageA(hwnd, LVM_SETCOLUMNA, 1, (LPARAM)&col);
     expect(TRUE, r);
 
     rect.left = LVIR_BOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
 
     /* still no left padding */
@@ -3866,14 +3884,14 @@ static void test_getitemrect(void)
 
     rect.left = LVIR_SELECTBOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding */
     expect(2, rect.left);
 
     rect.left = LVIR_LABEL;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding, column width */
     expect(2, rect.left);
@@ -3882,7 +3900,7 @@ static void test_getitemrect(void)
     /* no icons attached */
     rect.left = LVIR_ICON;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding */
     expect(2, rect.left);
@@ -3890,17 +3908,17 @@ static void test_getitemrect(void)
 
     /* change order */
     order[0] = 1; order[1] = 0;
-    r = SendMessage(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
+    r = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
     expect(TRUE, r);
     pt.x = -1;
-    r = SendMessage(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
+    r = SendMessageA(hwnd, LVM_GETITEMPOSITION, 0, (LPARAM)&pt);
     expect(TRUE, r);
     /* 1 indexed column width + padding */
     expect(102, pt.x);
     /* rect is at zero too */
     rect.left = LVIR_BOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     expect(0, rect.left);
     /* just width sum */
@@ -3908,14 +3926,14 @@ static void test_getitemrect(void)
 
     rect.left = LVIR_SELECTBOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* column width + padding */
     expect(102, rect.left);
 
     /* back to initial order */
     order[0] = 0; order[1] = 1;
-    r = SendMessage(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
+    r = SendMessageA(hwnd, LVM_SETCOLUMNORDERARRAY, 2, (LPARAM)&order);
     expect(TRUE, r);
 
     /* state icons */
@@ -3930,7 +3948,7 @@ static void test_getitemrect(void)
     r = ImageList_Add(himl, hbm, 0);
     expect(1, r);
 
-    r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
+    r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)himl);
     expect(0, r);
 
     item.mask = LVIF_STATE;
@@ -3938,13 +3956,13 @@ static void test_getitemrect(void)
     item.stateMask = LVIS_STATEIMAGEMASK;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
     /* icon bounds */
     rect.left = LVIR_ICON;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding + stateicon width */
     expect(18, rect.left);
@@ -3952,16 +3970,16 @@ static void test_getitemrect(void)
     /* label bounds */
     rect.left = LVIR_LABEL;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding + stateicon width -> column width */
     expect(18, rect.left);
     expect(50, rect.right);
 
-    himl_ret = (HIMAGELIST)SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
+    himl_ret = (HIMAGELIST)SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_STATE, 0);
     ok(himl_ret == himl, "got %p, expected %p\n", himl_ret, himl);
 
-    r = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
+    r = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_SMALL, (LPARAM)himl);
     expect(0, r);
 
     item.mask = LVIF_STATE | LVIF_IMAGE;
@@ -3970,13 +3988,13 @@ static void test_getitemrect(void)
     item.stateMask = ~0;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
     /* icon bounds */
     rect.left = LVIR_ICON;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding, icon width */
     expect(2, rect.left);
@@ -3984,7 +4002,7 @@ static void test_getitemrect(void)
     /* label bounds */
     rect.left = LVIR_LABEL;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding + icon width -> column width */
     expect(18, rect.left);
@@ -3993,7 +4011,7 @@ static void test_getitemrect(void)
     /* select bounds */
     rect.left = LVIR_SELECTBOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding, column width */
     expect(2, rect.left);
@@ -4004,13 +4022,13 @@ static void test_getitemrect(void)
     item.iIndent = 1;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_SETITEM, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
     /* bounds */
     rect.left = LVIR_BOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding + 1 icon width, column width */
     expect(0, rect.left);
@@ -4019,7 +4037,7 @@ static void test_getitemrect(void)
     /* select bounds */
     rect.left = LVIR_SELECTBOUNDS;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding + 1 icon width, column width */
     expect(2 + 16, rect.left);
@@ -4028,7 +4046,7 @@ static void test_getitemrect(void)
     /* label bounds */
     rect.left = LVIR_LABEL;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding + 2 icon widths, column width */
     expect(2 + 16*2, rect.left);
@@ -4037,7 +4055,7 @@ static void test_getitemrect(void)
     /* icon bounds */
     rect.left = LVIR_ICON;
     rect.right = rect.top = rect.bottom = -1;
-    r = SendMessage(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
+    r = SendMessageA(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect);
     expect(TRUE, r);
     /* padding + 1 icon width indentation, icon width */
     expect(2 + 16, rect.left);
@@ -4066,12 +4084,12 @@ static void test_editbox(void)
     item.pszText = testitemA;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(0, r);
 
     /* test notifications without edit created */
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)0xdeadbeef);
+    r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)0xdeadbeef);
     expect(0, r);
     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
                 "edit box WM_COMMAND (EN_SETFOCUS), no edit created", FALSE);
@@ -4079,7 +4097,7 @@ static void test_editbox(void)
     hwndedit = CreateWindowA("Edit", "Test edit", WS_VISIBLE | WS_CHILD, 0, 0, 20,
                 10, hwnd, (HMENU)1, (HINSTANCE)GetWindowLongPtrA(hwnd, GWLP_HINSTANCE), 0);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)hwndedit);
+    r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_SETFOCUS), (LPARAM)hwndedit);
     expect(0, r);
     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
                 "edit box WM_COMMAND (EN_SETFOCUS), no edit created #2", FALSE);
@@ -4087,7 +4105,7 @@ static void test_editbox(void)
 
     /* setting focus is necessary */
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
 
     /* test children Z-order after Edit box created */
@@ -4097,7 +4115,7 @@ static void test_editbox(void)
     ok(GetNextWindow(header, GW_HWNDNEXT) == hwndedit, "got %p\n", GetNextWindow(header, GW_HWNDNEXT));
 
     /* modify initial string */
-    r = SendMessage(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
+    r = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
     expect(TRUE, r);
 
     /* edit window is resized and repositioned,
@@ -4114,23 +4132,23 @@ static void test_editbox(void)
     item.cchTextMax = sizeof(buffer);
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
     ok(strcmp(buffer, testitem1A) == 0, "Expected item text to change\n");
 
     /* send LVM_EDITLABEL on already created edit */
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     /* focus will be set to edit */
     ok(GetFocus() == hwndedit, "Expected Edit window to be focused\n");
-    hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit2), "Expected Edit window to be created\n");
 
     /* creating label disabled when control isn't focused */
     SetFocus(0);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     todo_wine ok(hwndedit == NULL, "Expected Edit window not to be created\n");
 
     /* check EN_KILLFOCUS handling */
@@ -4138,17 +4156,17 @@ static void test_editbox(void)
     item.pszText = testitemA;
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     /* modify edit and notify control that it lost focus */
-    r = SendMessage(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
+    r = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem1A);
     expect(TRUE, r);
     g_editbox_disp_info.item.pszText = NULL;
-    r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
+    r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
     expect(0, r);
     ok(g_editbox_disp_info.item.pszText != NULL, "expected notification with not null text\n");
 
@@ -4157,20 +4175,20 @@ static void test_editbox(void)
     item.cchTextMax = sizeof(buffer);
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
-    expect(lstrlen(item.pszText), r);
+    r = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
+    expect(lstrlenA(item.pszText), r);
     ok(strcmp(buffer, testitem1A) == 0, "Expected item text to change\n");
     ok(!IsWindow(hwndedit), "Expected Edit window to be freed\n");
 
     /* change item name to differ in casing only */
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     /* modify edit and notify control that it lost focus */
-    r = SendMessage(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem2A);
+    r = SendMessageA(hwndedit, WM_SETTEXT, 0, (LPARAM)testitem2A);
     expect(TRUE, r);
     g_editbox_disp_info.item.pszText = NULL;
-    r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
+    r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
     expect(0, r);
     ok(g_editbox_disp_info.item.pszText != NULL, "got %p\n", g_editbox_disp_info.item.pszText);
 
@@ -4179,24 +4197,24 @@ static void test_editbox(void)
     item.cchTextMax = sizeof(buffer);
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
-    expect(lstrlen(item.pszText), r);
+    r = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
+    expect(lstrlenA(item.pszText), r);
     ok(strcmp(buffer, testitem2A) == 0, "got %s, expected %s\n", buffer, testitem2A);
     ok(!IsWindow(hwndedit), "Expected Edit window to be freed\n");
 
     /* end edit without saving */
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    r = SendMessage(hwndedit, WM_KEYDOWN, VK_ESCAPE, 0);
+    r = SendMessageA(hwndedit, WM_KEYDOWN, VK_ESCAPE, 0);
     expect(0, r);
     ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
                 "edit box - end edit, no change, escape", TRUE);
     /* end edit with saving */
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    r = SendMessage(hwndedit, WM_KEYDOWN, VK_RETURN, 0);
+    r = SendMessageA(hwndedit, WM_KEYDOWN, VK_RETURN, 0);
     expect(0, r);
     ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
                 "edit box - end edit, no change, return", TRUE);
@@ -4206,38 +4224,38 @@ static void test_editbox(void)
     item.cchTextMax = sizeof(buffer);
     item.iItem = 0;
     item.iSubItem = 0;
-    r = SendMessage(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
-    expect(lstrlen(item.pszText), r);
+    r = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&item);
+    expect(lstrlenA(item.pszText), r);
     ok(strcmp(buffer, testitem2A) == 0, "Expected item text to change\n");
 
     /* LVM_EDITLABEL with -1 destroys current edit */
-    hwndedit = (HWND)SendMessage(hwnd, LVM_GETEDITCONTROL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_GETEDITCONTROL, 0, 0);
     ok(hwndedit == NULL, "Expected Edit window not to be created\n");
     /* no edit present */
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, -1, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, -1, 0);
     ok(hwndedit == NULL, "Expected Edit window not to be created\n");
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     /* edit present */
     ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
-    hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, -1, 0);
+    hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, -1, 0);
     ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
     ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
     ok(GetFocus() == hwnd, "Expected List to be focused\n");
     /* check another negative value */
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
-    hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, -2, 0);
+    hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, -2, 0);
     ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
     ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
     ok(GetFocus() == hwnd, "Expected List to be focused\n");
     /* and value greater than max item index */
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     ok(GetFocus() == hwndedit, "Expected Edit to be focused\n");
-    r = SendMessage(hwnd, LVM_GETITEMCOUNT, 0, 0);
-    hwndedit2 = (HWND)SendMessage(hwnd, LVM_EDITLABEL, r, 0);
+    r = SendMessageA(hwnd, LVM_GETITEMCOUNT, 0, 0);
+    hwndedit2 = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, r, 0);
     ok(hwndedit2 == NULL, "Expected Edit window not to be created\n");
     ok(!IsWindow(hwndedit), "Expected Edit window to be destroyed\n");
     ok(GetFocus() == hwnd, "Expected List to be focused\n");
@@ -4246,7 +4264,7 @@ static void test_editbox(void)
     SetFocus(hwnd);
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     blockEdit = FALSE;
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     /* testing only sizing messages */
     ok_sequence(sequences, EDITBOX_SEQ_INDEX, editbox_create_pos,
@@ -4254,10 +4272,10 @@ static void test_editbox(void)
 
     /* WM_COMMAND with EN_KILLFOCUS isn't forwarded to parent */
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected Edit window to be created\n");
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    r = SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
+    r = SendMessageA(hwnd, WM_COMMAND, MAKEWPARAM(0, EN_KILLFOCUS), (LPARAM)hwndedit);
     expect(0, r);
     ok_sequence(sequences, PARENT_SEQ_INDEX, edit_end_nochange,
                 "edit box WM_COMMAND (EN_KILLFOCUS)", TRUE);
@@ -4275,18 +4293,18 @@ static void test_notifyformat(void)
 
     /* CCM_GETUNICODEFORMAT == LVM_GETUNICODEFORMAT,
        CCM_SETUNICODEFORMAT == LVM_SETUNICODEFORMAT */
-    r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(0, r);
-    SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
+    SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
     /* set */
-    r = SendMessage(hwnd, LVM_SETUNICODEFORMAT, 1, 0);
+    r = SendMessageA(hwnd, LVM_SETUNICODEFORMAT, 1, 0);
     expect(0, r);
-    r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     if (r == 1)
     {
-        r = SendMessage(hwnd, LVM_SETUNICODEFORMAT, 0, 0);
+        r = SendMessageA(hwnd, LVM_SETUNICODEFORMAT, 0, 0);
         expect(1, r);
-        r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
+        r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
         expect(0, r);
     }
     else
@@ -4302,29 +4320,29 @@ static void test_notifyformat(void)
     notifyFormat = 0;
     hwnd = create_listview_control(LVS_REPORT);
     ok(hwnd != NULL, "failed to create a listview window\n");
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "expected header to be created\n");
-    r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(0, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     ok( r == 1, "Expected 1, got %d\n", r );
-    r = SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
+    r = SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_QUERY);
     ok(r != 0, "Expected valid format\n");
 
     notifyFormat = NFR_UNICODE;
-    r = SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
+    r = SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
     expect(NFR_UNICODE, r);
-    r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(1, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     ok( r == 1, "Expected 1, got %d\n", r );
 
     notifyFormat = NFR_ANSI;
-    r = SendMessage(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
+    r = SendMessageA(hwnd, WM_NOTIFYFORMAT, 0, NF_REQUERY);
     expect(NFR_ANSI, r);
-    r = SendMessage(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(0, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     ok( r == 1, "Expected 1, got %d\n", r );
 
     DestroyWindow(hwnd);
@@ -4336,55 +4354,55 @@ static void test_notifyformat(void)
     notifyFormat = -1;
     hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
     ok(hwnd != NULL, "failed to create a listview window\n");
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "expected header to be created\n");
     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(1, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     expect(1, r);
     DestroyWindow(hwnd);
     /* receiving error code defaulting to ansi */
     notifyFormat = 0;
     hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
     ok(hwnd != NULL, "failed to create a listview window\n");
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "expected header to be created\n");
     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(0, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     expect(1, r);
     DestroyWindow(hwnd);
     /* receiving ansi code from unicode window, use it */
     notifyFormat = NFR_ANSI;
     hwnd = create_listview_controlW(LVS_REPORT, hwndparentW);
     ok(hwnd != NULL, "failed to create a listview window\n");
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "expected header to be created\n");
     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(0, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     expect(1, r);
     DestroyWindow(hwnd);
     /* unicode listview with ansi parent window */
     notifyFormat = -1;
     hwnd = create_listview_controlW(LVS_REPORT, hwndparent);
     ok(hwnd != NULL, "failed to create a listview window\n");
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "expected header to be created\n");
     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(0, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     expect(1, r);
     DestroyWindow(hwnd);
     /* unicode listview with ansi parent window, return error code */
     notifyFormat = 0;
     hwnd = create_listview_controlW(LVS_REPORT, hwndparent);
     ok(hwnd != NULL, "failed to create a listview window\n");
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "expected header to be created\n");
     r = SendMessageW(hwnd, LVM_GETUNICODEFORMAT, 0, 0);
     expect(0, r);
-    r = SendMessage(header, HDM_GETUNICODEFORMAT, 0, 0);
+    r = SendMessageA(header, HDM_GETUNICODEFORMAT, 0, 0);
     expect(1, r);
     DestroyWindow(hwnd);
 
@@ -4404,14 +4422,14 @@ static void test_indentation(void)
     item.mask = LVIF_INDENT;
     item.iItem = 0;
     item.iIndent = I_INDENTCALLBACK;
-    r = SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&item);
     expect(0, r);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
     item.iItem = 0;
     item.mask = LVIF_INDENT;
-    r = SendMessage(hwnd, LVM_GETITEM, 0, (LPARAM)&item);
+    r = SendMessageA(hwnd, LVM_GETITEMA, 0, (LPARAM)&item);
     expect(TRUE, r);
 
     ok_sequence(sequences, PARENT_SEQ_INDEX, single_getdispinfo_parent_seq,
@@ -4434,7 +4452,7 @@ static BOOL is_below_comctl_5(void)
     ok(hwnd != NULL, "failed to create a listview window\n");
     insert_item(hwnd, 0);
 
-    ret = SendMessage(hwnd, LVM_SORTITEMSEX, 0, (LPARAM)&DummyCompareEx);
+    ret = SendMessageA(hwnd, LVM_SORTITEMSEX, 0, (LPARAM)&DummyCompareEx);
 
     DestroyWindow(hwnd);
 
@@ -4451,37 +4469,37 @@ static void test_get_set_view(void)
     hwnd = create_listview_control(LVS_REPORT);
     ok(hwnd != NULL, "failed to create a listview window\n");
 
-    ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
+    ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
     expect(LV_VIEW_DETAILS, ret);
 
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     /* LVS_ICON == 0 */
-    SetWindowLongPtr(hwnd, GWL_STYLE, style & ~LVS_REPORT);
-    ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
+    SetWindowLongPtrA(hwnd, GWL_STYLE, style & ~LVS_REPORT);
+    ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
     expect(LV_VIEW_ICON, ret);
 
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
-    SetWindowLongPtr(hwnd, GWL_STYLE, style | LVS_SMALLICON);
-    ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
+    SetWindowLongPtrA(hwnd, GWL_STYLE, style | LVS_SMALLICON);
+    ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
     expect(LV_VIEW_SMALLICON, ret);
 
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
-    SetWindowLongPtr(hwnd, GWL_STYLE, (style & ~LVS_SMALLICON) | LVS_LIST);
-    ret = SendMessage(hwnd, LVM_GETVIEW, 0, 0);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
+    SetWindowLongPtrA(hwnd, GWL_STYLE, (style & ~LVS_SMALLICON) | LVS_LIST);
+    ret = SendMessageA(hwnd, LVM_GETVIEW, 0, 0);
     expect(LV_VIEW_LIST, ret);
 
     /* switching view doesn't touch window style */
-    ret = SendMessage(hwnd, LVM_SETVIEW, LV_VIEW_DETAILS, 0);
+    ret = SendMessageA(hwnd, LVM_SETVIEW, LV_VIEW_DETAILS, 0);
     expect(1, ret);
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     ok(style & LVS_LIST, "Expected style to be preserved\n");
-    ret = SendMessage(hwnd, LVM_SETVIEW, LV_VIEW_ICON, 0);
+    ret = SendMessageA(hwnd, LVM_SETVIEW, LV_VIEW_ICON, 0);
     expect(1, ret);
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     ok(style & LVS_LIST, "Expected style to be preserved\n");
-    ret = SendMessage(hwnd, LVM_SETVIEW, LV_VIEW_SMALLICON, 0);
+    ret = SendMessageA(hwnd, LVM_SETVIEW, LV_VIEW_SMALLICON, 0);
     expect(1, ret);
-    style = GetWindowLongPtr(hwnd, GWL_STYLE);
+    style = GetWindowLongPtrA(hwnd, GWL_STYLE);
     ok(style & LVS_LIST, "Expected style to be preserved\n");
 
     DestroyWindow(hwnd);
@@ -4503,36 +4521,36 @@ static void test_canceleditlabel(void)
 
     /* try without edit created */
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    ret = SendMessage(hwnd, LVM_CANCELEDITLABEL, 0, 0);
+    ret = SendMessageA(hwnd, LVM_CANCELEDITLABEL, 0, 0);
     expect(TRUE, ret);
     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq,
                 "cancel edit label without edit", FALSE);
 
     /* cancel without data change */
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected edit control to be created\n");
-    ret = SendMessage(hwnd, LVM_CANCELEDITLABEL, 0, 0);
+    ret = SendMessageA(hwnd, LVM_CANCELEDITLABEL, 0, 0);
     expect(TRUE, ret);
     ok(!IsWindow(hwndedit), "Expected edit control to be destroyed\n");
 
     /* cancel after data change */
     memset(&itema, 0, sizeof(itema));
     itema.pszText = test;
-    ret = SendMessage(hwnd, LVM_SETITEMTEXT, 0, (LPARAM)&itema);
+    ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&itema);
     expect(TRUE, ret);
     SetFocus(hwnd);
-    hwndedit = (HWND)SendMessage(hwnd, LVM_EDITLABEL, 0, 0);
+    hwndedit = (HWND)SendMessageA(hwnd, LVM_EDITLABELA, 0, 0);
     ok(IsWindow(hwndedit), "Expected edit control to be created\n");
-    ret = SetWindowText(hwndedit, test1);
+    ret = SetWindowTextA(hwndedit, test1);
     expect(1, ret);
-    ret = SendMessage(hwnd, LVM_CANCELEDITLABEL, 0, 0);
+    ret = SendMessageA(hwnd, LVM_CANCELEDITLABEL, 0, 0);
     expect(TRUE, ret);
     ok(!IsWindow(hwndedit), "Expected edit control to be destroyed\n");
     memset(&itema, 0, sizeof(itema));
     itema.pszText = buff;
     itema.cchTextMax = sizeof(buff)/sizeof(CHAR);
-    ret = SendMessage(hwnd, LVM_GETITEMTEXT, 0, (LPARAM)&itema);
+    ret = SendMessageA(hwnd, LVM_GETITEMTEXTA, 0, (LPARAM)&itema);
     expect(5, ret);
     ok(strcmp(buff, test1) == 0, "Expected label text not to change\n");
 
@@ -4548,7 +4566,7 @@ static void test_mapidindex(void)
     hwnd = create_listview_control(LVS_OWNERDATA | LVS_REPORT);
     ok(hwnd != NULL, "failed to create a listview window\n");
     insert_item(hwnd, 0);
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
     expect(-1, ret);
     DestroyWindow(hwnd);
 
@@ -4556,38 +4574,38 @@ static void test_mapidindex(void)
     ok(hwnd != NULL, "failed to create a listview window\n");
 
     /* LVM_MAPINDEXTOID with invalid index */
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
     expect(-1, ret);
 
     insert_item(hwnd, 0);
     insert_item(hwnd, 1);
 
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, -1, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, -1, 0);
     expect(-1, ret);
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 2, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 2, 0);
     expect(-1, ret);
 
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
     expect(0, ret);
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 1, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 1, 0);
     expect(1, ret);
     /* remove 0 indexed item, id retained */
-    SendMessage(hwnd, LVM_DELETEITEM, 0, 0);
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 0, 0);
+    SendMessageA(hwnd, LVM_DELETEITEM, 0, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 0, 0);
     expect(1, ret);
     /* new id starts from previous value */
     insert_item(hwnd, 1);
-    ret = SendMessage(hwnd, LVM_MAPINDEXTOID, 1, 0);
+    ret = SendMessageA(hwnd, LVM_MAPINDEXTOID, 1, 0);
     expect(2, ret);
 
     /* get index by id */
-    ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, -1, 0);
+    ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, -1, 0);
     expect(-1, ret);
-    ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, 0, 0);
+    ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, 0, 0);
     expect(-1, ret);
-    ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, 1, 0);
+    ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, 1, 0);
     expect(0, ret);
-    ret = SendMessage(hwnd, LVM_MAPIDTOINDEX, 2, 0);
+    ret = SendMessageA(hwnd, LVM_MAPIDTOINDEX, 2, 0);
     expect(1, ret);
 
     DestroyWindow(hwnd);
@@ -4605,7 +4623,7 @@ static void test_getitemspacing(void)
 
     /* LVS_ICON */
     hwnd = create_listview_control(LVS_ICON);
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     expect(cx, LOWORD(ret));
     expect(cy, HIWORD(ret));
 
@@ -4614,45 +4632,45 @@ static void test_getitemspacing(void)
     ok(himl40 != NULL, "failed to create imagelist\n");
     himl80 = ImageList_Create(80, 80, 0, 4, 4);
     ok(himl80 != NULL, "failed to create imagelist\n");
-    ret = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
+    ret = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
     expect(0, ret);
 
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     /* spacing + icon size returned */
     expect(cx + 40, LOWORD(ret));
     expect(cy + 40, HIWORD(ret));
     /* try changing icon size */
-    SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl80);
+    SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl80);
 
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     /* spacing + icon size returned */
     expect(cx + 80, LOWORD(ret));
     expect(cy + 80, HIWORD(ret));
 
     /* set own icon spacing */
-    ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(100, 100));
+    ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(100, 100));
     expect(cx + 80, LOWORD(ret));
     expect(cy + 80, HIWORD(ret));
 
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     /* set size returned */
     expect(100, LOWORD(ret));
     expect(100, HIWORD(ret));
 
     /* now change image list - icon spacing should be unaffected */
-    SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
+    SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
 
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     /* set size returned */
     expect(100, LOWORD(ret));
     expect(100, HIWORD(ret));
 
     /* spacing = 0 - keep previous value */
-    ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(0, -1));
+    ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(0, -1));
     expect(100, LOWORD(ret));
     expect(100, HIWORD(ret));
 
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     expect(100, LOWORD(ret));
 
     expect(0xFFFF, HIWORD(ret));
@@ -4660,56 +4678,56 @@ static void test_getitemspacing(void)
     if (sizeof(void*) == 8)
     {
         /* NOTE: -1 is not treated the same as (DWORD)-1 by 64bit listview */
-        ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, (DWORD)-1);
+        ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, (DWORD)-1);
         expect(100, LOWORD(ret));
         expect(0xFFFF, HIWORD(ret));
 
-        ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, -1);
+        ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, -1);
         expect(0xFFFF, LOWORD(ret));
         expect(0xFFFF, HIWORD(ret));
     }
     else
     {
-        ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, -1);
+        ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, -1);
         expect(100, LOWORD(ret));
         expect(0xFFFF, HIWORD(ret));
     }
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     /* spacing + icon size returned */
     expect(cx + 40, LOWORD(ret));
     expect(cy + 40, HIWORD(ret));
 
-    SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, 0);
+    SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, 0);
     ImageList_Destroy(himl80);
     DestroyWindow(hwnd);
     /* LVS_SMALLICON */
     hwnd = create_listview_control(LVS_SMALLICON);
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     expect(cx, LOWORD(ret));
     expect(cy, HIWORD(ret));
 
     /* spacing does not depend on selected view type */
-    ret = SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
+    ret = SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, (LPARAM)himl40);
     expect(0, ret);
 
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     /* spacing + icon size returned */
     expect(cx + 40, LOWORD(ret));
     expect(cy + 40, HIWORD(ret));
 
-    SendMessage(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, 0);
+    SendMessageA(hwnd, LVM_SETIMAGELIST, LVSIL_NORMAL, 0);
     ImageList_Destroy(himl40);
     DestroyWindow(hwnd);
     /* LVS_REPORT */
     hwnd = create_listview_control(LVS_REPORT);
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     expect(cx, LOWORD(ret));
     expect(cy, HIWORD(ret));
 
     DestroyWindow(hwnd);
     /* LVS_LIST */
     hwnd = create_listview_control(LVS_LIST);
-    ret = SendMessage(hwnd, LVM_GETITEMSPACING, FALSE, 0);
+    ret = SendMessageA(hwnd, LVM_GETITEMSPACING, FALSE, 0);
     expect(cx, LOWORD(ret));
     expect(cy, HIWORD(ret));
 
@@ -4727,26 +4745,26 @@ static void test_getcolumnwidth(void)
 
     /* default column width */
     hwnd = create_listview_control(LVS_ICON);
-    ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
+    ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
     expect(0, ret);
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    SetWindowLong(hwnd, GWL_STYLE, style | LVS_LIST);
-    ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
+    SetWindowLongA(hwnd, GWL_STYLE, style | LVS_LIST);
+    ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
     todo_wine expect(8, ret);
-    style = GetWindowLong(hwnd, GWL_STYLE) & ~LVS_LIST;
-    SetWindowLong(hwnd, GWL_STYLE, style | LVS_REPORT);
+    style = GetWindowLongA(hwnd, GWL_STYLE) & ~LVS_LIST;
+    SetWindowLongA(hwnd, GWL_STYLE, style | LVS_REPORT);
     col.mask = 0;
-    ret = SendMessage(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
+    ret = SendMessageA(hwnd, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, ret);
-    ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
+    ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
     expect(10, ret);
     DestroyWindow(hwnd);
 
     /* default column width with item added */
     hwnd = create_listview_control(LVS_LIST);
     memset(&itema, 0, sizeof(itema));
-    SendMessage(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&itema);
-    ret = SendMessage(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
+    SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&itema);
+    ret = SendMessageA(hwnd, LVM_GETCOLUMNWIDTH, 0, 0);
     hdc = GetDC(hwnd);
     todo_wine expect(((GetDeviceCaps(hdc, LOGPIXELSX) + 15) / 16) * 16, ret);
     ReleaseDC(hwnd, hdc);
@@ -4765,26 +4783,26 @@ static void test_scrollnotify(void)
     insert_item(hwnd, 0);
 
     /* make it scrollable - resize */
-    ret = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
+    ret = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(100, 0));
     expect(TRUE, ret);
-    ret = SendMessage(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
+    ret = SendMessageA(hwnd, LVM_SETCOLUMNWIDTH, 1, MAKELPARAM(100, 0));
     expect(TRUE, ret);
 
     /* try with dummy call */
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    ret = SendMessage(hwnd, LVM_SCROLL, 0, 0);
+    ret = SendMessageA(hwnd, LVM_SCROLL, 0, 0);
     expect(TRUE, ret);
     ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
                 "scroll notify 1", TRUE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    ret = SendMessage(hwnd, LVM_SCROLL, 1, 0);
+    ret = SendMessageA(hwnd, LVM_SCROLL, 1, 0);
     expect(TRUE, ret);
     ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
                 "scroll notify 2", TRUE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    ret = SendMessage(hwnd, LVM_SCROLL, 1, 1);
+    ret = SendMessageA(hwnd, LVM_SCROLL, 1, 1);
     expect(TRUE, ret);
     ok_sequence(sequences, PARENT_SEQ_INDEX, scroll_parent_seq,
                 "scroll notify 3", TRUE);
@@ -4800,13 +4818,13 @@ static void test_LVS_EX_TRANSPARENTBKGND(void)
 
     hwnd = create_listview_control(LVS_REPORT);
 
-    ret = SendMessage(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
+    ret = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
     expect(TRUE, ret);
 
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
                                                     LVS_EX_TRANSPARENTBKGND);
 
-    ret = SendMessage(hwnd, LVM_GETBKCOLOR, 0, 0);
+    ret = SendMessageA(hwnd, LVM_GETBKCOLOR, 0, 0);
     if (ret != CLR_NONE)
     {
         win_skip("LVS_EX_TRANSPARENTBKGND unsupported\n");
@@ -4815,13 +4833,13 @@ static void test_LVS_EX_TRANSPARENTBKGND(void)
     }
 
     /* try to set some back color and check this style bit */
-    ret = SendMessage(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
+    ret = SendMessageA(hwnd, LVM_SETBKCOLOR, 0, RGB(0, 0, 0));
     expect(TRUE, ret);
-    ret = SendMessage(hwnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
+    ret = SendMessageA(hwnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
     ok(!(ret & LVS_EX_TRANSPARENTBKGND), "Expected LVS_EX_TRANSPARENTBKGND to unset\n");
 
     /* now test what this style actually does */
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_TRANSPARENTBKGND,
                                                     LVS_EX_TRANSPARENTBKGND);
 
     hdc = GetWindowDC(hwndparent);
@@ -4852,17 +4870,17 @@ static void test_approximate_viewrect(void)
     ok(hbmp != NULL, "failed to create bitmap\n");
     ret = ImageList_Add(himl, hbmp, 0);
     expect(0, ret);
-    ret = SendMessage(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
+    ret = SendMessageA(hwnd, LVM_SETIMAGELIST, 0, (LPARAM)himl);
     expect(0, ret);
 
     itema.mask = LVIF_IMAGE;
     itema.iImage = 0;
     itema.iItem = 0;
     itema.iSubItem = 0;
-    ret = SendMessage(hwnd, LVM_INSERTITEM, 0, (LPARAM)&itema);
+    ret = SendMessageA(hwnd, LVM_INSERTITEMA, 0, (LPARAM)&itema);
     expect(0, ret);
 
-    ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(75, 75));
+    ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(75, 75));
     if (ret == 0)
     {
         /* version 4.0 */
@@ -4870,39 +4888,39 @@ static void test_approximate_viewrect(void)
         return;
     }
 
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
     expect(MAKELONG(77,827), ret);
 
-    ret = SendMessage(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(50, 50));
+    ret = SendMessageA(hwnd, LVM_SETICONSPACING, 0, MAKELPARAM(50, 50));
     ok(ret != 0, "got 0\n");
 
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 11, MAKELPARAM(100,100));
     expect(MAKELONG(102,302), ret);
 
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
     expect(MAKELONG(52,52), ret);
 
     itema.pszText = test;
-    ret = SendMessage(hwnd, LVM_SETITEMTEXT, 0, (LPARAM)&itema);
+    ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, (LPARAM)&itema);
     expect(TRUE, ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, -1, MAKELPARAM(100,100));
     expect(MAKELONG(52,52), ret);
 
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 0, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 0, MAKELPARAM(100,100));
     expect(MAKELONG(52,2), ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 1, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 1, MAKELPARAM(100,100));
     expect(MAKELONG(52,52), ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 2, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 2, MAKELPARAM(100,100));
     expect(MAKELONG(102,52), ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 3, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 3, MAKELPARAM(100,100));
     expect(MAKELONG(102,102), ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 4, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 4, MAKELPARAM(100,100));
     expect(MAKELONG(102,102), ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 5, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 5, MAKELPARAM(100,100));
     expect(MAKELONG(102,152), ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 6, MAKELPARAM(100,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 6, MAKELPARAM(100,100));
     expect(MAKELONG(102,152), ret);
-    ret = SendMessage(hwnd, LVM_APPROXIMATEVIEWRECT, 7, MAKELPARAM(160,100));
+    ret = SendMessageA(hwnd, LVM_APPROXIMATEVIEWRECT, 7, MAKELPARAM(160,100));
     expect(MAKELONG(152,152), ret);
 
     DestroyWindow(hwnd);
@@ -4924,26 +4942,26 @@ static void test_finditem(void)
     strcpy(f, "foo");
     fi.flags = LVFI_STRING;
     fi.psz = f;
-    r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
+    r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
     expect(0, r);
     /* partial string search, inserted text was "foo" */
     strcpy(f, "fo");
     fi.flags = LVFI_STRING | LVFI_PARTIAL;
     fi.psz = f;
-    r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
+    r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
     expect(0, r);
     /* partial string search, part after start char */
     strcpy(f, "oo");
     fi.flags = LVFI_STRING | LVFI_PARTIAL;
     fi.psz = f;
-    r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
+    r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
     expect(-1, r);
 
     /* try with LVFI_SUBSTRING */
     strcpy(f, "fo");
     fi.flags = LVFI_SUBSTRING;
     fi.psz = f;
-    r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
+    r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
     if (r == -1)
     {
         win_skip("LVFI_SUBSTRING not supported\n");
@@ -4954,18 +4972,18 @@ static void test_finditem(void)
     strcpy(f, "f");
     fi.flags = LVFI_SUBSTRING;
     fi.psz = f;
-    r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
+    r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
     expect(0, r);
     strcpy(f, "o");
     fi.flags = LVFI_SUBSTRING;
     fi.psz = f;
-    r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
+    r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
     expect(-1, r);
 
     strcpy(f, "f");
     fi.flags = LVFI_SUBSTRING | LVFI_STRING;
     fi.psz = f;
-    r = SendMessage(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
+    r = SendMessageA(hwnd, LVM_FINDITEMA, -1, (LPARAM)&fi);
     expect(0, r);
 
     DestroyWindow(hwnd);
@@ -4978,10 +4996,10 @@ static void test_LVS_EX_HEADERINALLVIEWS(void)
 
     hwnd = create_listview_control(LVS_ICON);
 
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
                                                     LVS_EX_HEADERINALLVIEWS);
 
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     if (!IsWindow(header))
     {
         win_skip("LVS_EX_HEADERINALLVIEWS unsupported\n");
@@ -5000,8 +5018,8 @@ static void test_LVS_EX_HEADERINALLVIEWS(void)
     ok(!(style & HDS_HIDDEN), "Expected HDS_HIDDEN to be unset\n");
 
     /* try to remove style */
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS, 0);
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "Expected header to be created\n");
     style = GetWindowLongA(header, GWL_STYLE);
     ok(!(style & HDS_HIDDEN), "HDS_HIDDEN not expected\n");
@@ -5010,23 +5028,23 @@ static void test_LVS_EX_HEADERINALLVIEWS(void)
 
     /* check other styles */
     hwnd = create_listview_control(LVS_LIST);
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
                                                     LVS_EX_HEADERINALLVIEWS);
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "Expected header to be created\n");
     DestroyWindow(hwnd);
 
     hwnd = create_listview_control(LVS_SMALLICON);
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
                                                     LVS_EX_HEADERINALLVIEWS);
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "Expected header to be created\n");
     DestroyWindow(hwnd);
 
     hwnd = create_listview_control(LVS_REPORT);
-    SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
+    SendMessageA(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_HEADERINALLVIEWS,
                                                     LVS_EX_HEADERINALLVIEWS);
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(IsWindow(header), "Expected header to be created\n");
     DestroyWindow(hwnd);
 }
@@ -5040,19 +5058,19 @@ static void test_hover(void)
 
     /* test WM_MOUSEHOVER forwarding */
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    r = SendMessage(hwnd, WM_MOUSEHOVER, 0, 0);
+    r = SendMessageA(hwnd, WM_MOUSEHOVER, 0, 0);
     expect(0, r);
     ok_sequence(sequences, PARENT_SEQ_INDEX, hover_parent, "NM_HOVER allow test", TRUE);
     g_block_hover = TRUE;
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
-    r = SendMessage(hwnd, WM_MOUSEHOVER, 0, 0);
+    r = SendMessageA(hwnd, WM_MOUSEHOVER, 0, 0);
     expect(0, r);
     ok_sequence(sequences, PARENT_SEQ_INDEX, hover_parent, "NM_HOVER block test", TRUE);
     g_block_hover = FALSE;
 
-    r = SendMessage(hwnd, LVM_SETHOVERTIME, 0, 500);
+    r = SendMessageA(hwnd, LVM_SETHOVERTIME, 0, 500);
     expect(HOVER_DEFAULT, r);
-    r = SendMessage(hwnd, LVM_GETHOVERTIME, 0, 0);
+    r = SendMessageA(hwnd, LVM_GETHOVERTIME, 0, 0);
     expect(500, r);
 
     DestroyWindow(hwnd);
@@ -5061,6 +5079,7 @@ static void test_hover(void)
 static void test_destroynotify(void)
 {
     HWND hwnd;
+    BOOL ret;
 
     hwnd = create_listview_control(LVS_REPORT);
     ok(hwnd != NULL, "failed to create listview window\n");
@@ -5068,6 +5087,23 @@ static void test_destroynotify(void)
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
     DestroyWindow(hwnd);
     ok_sequence(sequences, COMBINED_SEQ_INDEX, listview_destroy, "check destroy order", FALSE);
+
+    /* same for ownerdata list */
+    hwnd = create_listview_control(LVS_REPORT|LVS_OWNERDATA);
+    ok(hwnd != NULL, "failed to create listview window\n");
+
+    flush_sequences(sequences, NUM_MSG_SEQUENCES);
+    DestroyWindow(hwnd);
+    ok_sequence(sequences, COMBINED_SEQ_INDEX, listview_ownerdata_destroy, "check destroy order, ownerdata", FALSE);
+
+    hwnd = create_listview_control(LVS_REPORT|LVS_OWNERDATA);
+    ok(hwnd != NULL, "failed to create listview window\n");
+
+    flush_sequences(sequences, NUM_MSG_SEQUENCES);
+    ret = SendMessageA(hwnd, LVM_DELETEALLITEMS, 0, 0);
+    ok(ret == TRUE, "got %d\n", ret);
+    ok_sequence(sequences, COMBINED_SEQ_INDEX, listview_ownerdata_deleteall, "deleteall ownerdata", FALSE);
+    DestroyWindow(hwnd);
 }
 
 static void test_header_notification(void)
@@ -5075,7 +5111,7 @@ static void test_header_notification(void)
     static char textA[] = "newtext";
     HWND list, header;
     HDITEMA item;
-    NMHEADER nmh;
+    NMHEADERA nmh;
     LVCOLUMNA col;
     DWORD ret;
     BOOL r;
@@ -5086,7 +5122,7 @@ static void test_header_notification(void)
     memset(&col, 0, sizeof(col));
     col.mask = LVCF_WIDTH;
     col.cx = 100;
-    ret = SendMessage(list, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
+    ret = SendMessageA(list, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, ret);
 
     /* check list parent notification after header item changed,
@@ -5096,7 +5132,7 @@ static void test_header_notification(void)
 
     col.mask = LVCF_TEXT;
     col.pszText = textA;
-    r = SendMessage(list, LVM_SETCOLUMNA, 0, (LPARAM)&col);
+    r = SendMessageA(list, LVM_SETCOLUMNA, 0, (LPARAM)&col);
     expect(TRUE, r);
 
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_header_changed_seq,
@@ -5106,24 +5142,24 @@ static void test_header_notification(void)
 
     header = subclass_header(list);
 
-    ret = SendMessage(header, HDM_GETITEMCOUNT, 0, 0);
+    ret = SendMessageA(header, HDM_GETITEMCOUNT, 0, 0);
     expect(1, ret);
 
     memset(&item, 0, sizeof(item));
     item.mask = HDI_WIDTH;
-    ret = SendMessage(header, HDM_GETITEMA, 0, (LPARAM)&item);
+    ret = SendMessageA(header, HDM_GETITEMA, 0, (LPARAM)&item);
     expect(1, ret);
     expect(100, item.cxy);
 
     nmh.hdr.hwndFrom = header;
-    nmh.hdr.idFrom = GetWindowLongPtr(header, GWLP_ID);
+    nmh.hdr.idFrom = GetWindowLongPtrA(header, GWLP_ID);
     nmh.hdr.code = HDN_ITEMCHANGEDA;
     nmh.iItem = 0;
     nmh.iButton = 0;
     item.mask = HDI_WIDTH;
     item.cxy = 50;
     nmh.pitem = &item;
-    ret = SendMessage(list, WM_NOTIFY, 0, (LPARAM)&nmh);
+    ret = SendMessageA(list, WM_NOTIFY, 0, (LPARAM)&nmh);
     expect(0, ret);
 
     DestroyWindow(list);
@@ -5150,10 +5186,10 @@ static void test_header_notification2(void)
     col.mask = LVCF_WIDTH | LVCF_TEXT;
     col.cx = 100;
     col.pszText = textA;
-    ret = SendMessage(list, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
+    ret = SendMessageA(list, LVM_INSERTCOLUMNA, 0, (LPARAM)&col);
     expect(0, ret);
 
-    header = ListView_GetHeader(list);
+    header = (HWND)SendMessageA(list, LVM_GETHEADER, 0, 0);
     ok(header != 0, "No header\n");
     memset(&itemW, 0, sizeof(itemW));
     itemW.mask = HDI_WIDTH | HDI_ORDER | HDI_TEXT;
@@ -5163,7 +5199,7 @@ static void test_header_notification2(void)
     expect(1, ret);
 
     nmhdr.hdr.hwndFrom = header;
-    nmhdr.hdr.idFrom = GetWindowLongPtr(header, GWLP_ID);
+    nmhdr.hdr.idFrom = GetWindowLongPtrW(header, GWLP_ID);
     nmhdr.iItem = 0;
     nmhdr.iButton = 0;
     nmhdr.pitem = &itemW;
@@ -5335,10 +5371,10 @@ static void test_LVM_SETITEMTEXT(void)
     insert_item(hwnd, 0);
 
     /* null item pointer */
-    ret = SendMessage(hwnd, LVM_SETITEMTEXTA, 0, 0);
+    ret = SendMessageA(hwnd, LVM_SETITEMTEXTA, 0, 0);
     expect(FALSE, ret);
 
-    ret = SendMessage(hwnd, LVM_SETITEMTEXTW, 0, 0);
+    ret = SendMessageA(hwnd, LVM_SETITEMTEXTW, 0, 0);
     expect(FALSE, ret);
 
     /* index out of bounds */
@@ -5375,7 +5411,7 @@ static void test_imagelists(void)
     header = subclass_header(hwnd);
 
     ok(header != NULL, "Expected header\n");
-    ret = SendMessage(header, HDM_GETIMAGELIST, 0, 0);
+    ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
     ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
@@ -5392,7 +5428,7 @@ static void test_imagelists(void)
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_set_imagelist,
                 "set state image list", TRUE);
 
-    ret = SendMessage(header, HDM_GETIMAGELIST, 0, 0);
+    ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
     ok(ret == 0, "Expected no imagelist, got %p\n", (HIMAGELIST)ret);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
@@ -5402,7 +5438,7 @@ static void test_imagelists(void)
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_header_set_imagelist,
                 "set small image list", FALSE);
 
-    ret = SendMessage(header, HDM_GETIMAGELIST, 0, 0);
+    ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
     ok((HIMAGELIST)ret == himl3, "Expected imagelist %p, got %p\n", himl3, (HIMAGELIST)ret);
     DestroyWindow(hwnd);
 
@@ -5429,15 +5465,15 @@ static void test_imagelists(void)
     ok_sequence(sequences, LISTVIEW_SEQ_INDEX, listview_set_imagelist,
                 "set small image list", FALSE);
 
-    header = ListView_GetHeader(hwnd);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(header == NULL, "Expected no header, got %p\n", header);
 
-    SetWindowLongPtr(hwnd, GWL_STYLE, GetWindowLongPtr(hwnd, GWL_STYLE) | LVS_REPORT);
+    SetWindowLongPtrA(hwnd, GWL_STYLE, GetWindowLongPtrA(hwnd, GWL_STYLE) | LVS_REPORT);
 
-    header = (HWND)SendMessage(hwnd, LVM_GETHEADER, 0, 0);
+    header = (HWND)SendMessageA(hwnd, LVM_GETHEADER, 0, 0);
     ok(header != NULL, "Expected header, got NULL\n");
 
-    ret = SendMessage(header, HDM_GETIMAGELIST, 0, 0);
+    ret = SendMessageA(header, HDM_GETIMAGELIST, 0, 0);
     ok((HIMAGELIST)ret == himl3, "Expected imagelist %p, got %p\n", himl3, (HIMAGELIST)ret);
 
     DestroyWindow(hwnd);
@@ -5557,7 +5593,6 @@ START_TEST(listview)
 
     ULONG_PTR ctx_cookie;
     HANDLE hCtx;
-    HWND hwnd;
 
     hComctl32 = GetModuleHandleA("comctl32.dll");
     pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
@@ -5626,21 +5661,6 @@ START_TEST(listview)
         return;
     }
 
-    /* this is a XP SP3 failure workaround */
-    hwnd = CreateWindowExA(0, WC_LISTVIEW, "foo",
-                           WS_CHILD | WS_BORDER | WS_VISIBLE | LVS_REPORT,
-                           0, 0, 100, 100,
-                           hwndparent, NULL, GetModuleHandleA(NULL), NULL);
-    if (!IsWindow(hwnd))
-    {
-        win_skip("FIXME: failed to create ListView window.\n");
-        unload_v6_module(ctx_cookie, hCtx);
-        DestroyWindow(hwndparent);
-        return;
-    }
-    else
-        DestroyWindow(hwnd);
-
     /* comctl32 version 6 tests start here */
     test_get_set_view();
     test_canceleditlabel();
index c1f4e1c..068e57c 100644 (file)
@@ -102,8 +102,8 @@ static void test_GetPtrAW(void)
         ok (count == sourcelen ||
             broken(count == 0), /* win9x */
             "Expected count to be %d, it was %d\n", sourcelen, count);
-        ok (!lstrcmp(dest, desttest) ||
-            broken(!lstrcmp(dest, "")), /* Win7 */
+        ok (!lstrcmpA(dest, desttest) ||
+            broken(!lstrcmpA(dest, "")), /* Win7 */
             "Expected destination to not have changed\n");
 
         count = pStr_GetPtrA(source, NULL, destsize);
@@ -115,7 +115,7 @@ static void test_GetPtrAW(void)
         ok (count == sourcelen ||
             broken(count == sourcelen - 1), /* win9x */
             "Expected count to be %d, it was %d\n", sourcelen, count);
-        ok (!lstrcmp(source, dest), "Expected source and destination to be the same\n");
+        ok (!lstrcmpA(source, dest), "Expected source and destination to be the same\n");
 
         strcpy(dest, desttest);
         count = pStr_GetPtrA(NULL, dest, destsize);
index 54a982e..466612b 100644 (file)
@@ -272,7 +272,7 @@ static void test_monthcal(void)
 
     /* test range just after creation */
     memset(&st, 0xcc, sizeof(st));
-    limits = SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st);
+    limits = SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st);
     ok(limits == 0 ||
        broken(limits == GDTR_MIN), /* comctl32 <= 4.70 */
        "No limits should be set (%d)\n", limits);
@@ -310,21 +310,21 @@ static void test_monthcal(void)
     GetSystemTime(&st[0]);
     st[1] = st[0];
 
-    SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&today);
+    SendMessageA(hwnd, MCM_GETTODAY, 0, (LPARAM)&today);
 
     /* Invalid date/time */
     st[0].wYear  = 2000;
     /* Time should not matter */
     st[1].wHour = st[1].wMinute = st[1].wSecond = 70;
     st[1].wMilliseconds = 1200;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set MAX limit\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set MAX limit\n");
     /* invalid timestamp is written back with today data and msecs untouched */
     expect(today.wHour, st[1].wHour);
     expect(today.wMinute, st[1].wMinute);
     expect(today.wSecond, st[1].wSecond);
     expect(1200, st[1].wMilliseconds);
 
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
     ok(st1[0].wYear != 2000, "Lower limit changed\n");
     /* invalid timestamp should be replaced with today data, except msecs */
     expect(today.wHour, st1[1].wHour);
@@ -337,7 +337,7 @@ static void test_monthcal(void)
     st[1] = st[0];
     /* Time should not matter */
     st[1].wMilliseconds = 1200;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set MAX limit\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set MAX limit\n");
     /* invalid milliseconds field doesn't lead to invalid timestamp */
     expect(st[0].wHour,   st[1].wHour);
     expect(st[0].wMinute, st[1].wMinute);
@@ -347,11 +347,13 @@ static void test_monthcal(void)
     GetSystemTime(&st[0]);
 
     st[1].wMonth = 0;
-    ok(!SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Should have failed to set limits\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
+    ok(!SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st),
+            "Should have failed to set limits\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
     ok(st1[0].wYear != 2000, "Lower limit changed\n");
-    ok(!SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Should have failed to set MAX limit\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
+    ok(!SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st),
+            "Should have failed to set MAX limit\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
     ok(st1[0].wYear != 2000, "Lower limit changed\n");
 
     GetSystemTime(&st[0]);
@@ -359,44 +361,52 @@ static void test_monthcal(void)
     st[0].wMonth = 5;
     st[1] = st[0];
 
-    month_range = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
+    month_range = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
     st[1].wMonth--;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
-    res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st),
+            "Failed to set both min and max limits\n");
+    res = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
     ok(res == month_range, "Invalid month range (%d)\n", res);
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == (GDTR_MIN|GDTR_MAX), "Limits should be set\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == (GDTR_MIN|GDTR_MAX),
+            "Limits should be set\n");
 
     st[1].wMonth += 2;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
-    res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st),
+            "Failed to set both min and max limits\n");
+    res = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
     ok(res == month_range, "Invalid month range (%d)\n", res);
 
     st[1].wYear --;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st),
+            "Failed to set both min and max limits\n");
     st[1].wYear += 1;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st),
+            "Failed to set both min and max limits\n");
 
     st[1].wMonth -= 3;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "Only MAX limit should be set\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX,
+            "Only MAX limit should be set\n");
     st[1].wMonth += 4;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
     st[1].wYear -= 3;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
     st[1].wYear += 4;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "Only MAX limit should be set\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX,
+            "Only MAX limit should be set\n");
 
     /* set both limits, then set max < min */
     GetSystemTime(&st[0]);
     st[0].wDay = 25;
     st[1] = st[0];
     st[1].wYear++;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN|GDTR_MAX, (LPARAM)st), "Failed to set limits\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == (GDTR_MIN|GDTR_MAX), "Min limit expected\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN|GDTR_MAX, (LPARAM)st), "Failed to set limits\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == (GDTR_MIN|GDTR_MAX),
+            "Min limit expected\n");
     st[1].wYear -= 2;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set limits\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "Max limit expected\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set limits\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "Max limit expected\n");
 
     expect(0, st1[0].wYear);
     expect(0, st1[0].wMonth);
@@ -418,11 +428,12 @@ static void test_monthcal(void)
 
     st[1] = st[0];
     st[1].wYear++;
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN|GDTR_MAX, (LPARAM)st), "Failed to set limits\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == (GDTR_MIN|GDTR_MAX), "Min limit expected\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN|GDTR_MAX, (LPARAM)st), "Failed to set limits\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == (GDTR_MIN|GDTR_MAX),
+            "Min limit expected\n");
     st[0].wYear++; /* start == end now */
-    ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN, (LPARAM)st), "Failed to set limits\n");
-    ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MIN, "Min limit expected\n");
+    ok(SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN, (LPARAM)st), "Failed to set limits\n");
+    ok(SendMessageA(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MIN, "Min limit expected\n");
 
     expect(st[0].wYear,      st1[0].wYear);
     expect(st[0].wMonth,     st1[0].wMonth);
@@ -492,13 +503,12 @@ static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LP
           {
             NMSELCHANGE *nmchg = (NMSELCHANGE*)lParam;
             SYSTEMTIME st[2];
-            BOOL is_multisel = GetWindowLongPtr(nmchg->nmhdr.hwndFrom, GWL_STYLE) &
-                        MCS_MULTISELECT;
+            BOOL is_multisel = GetWindowLongPtrA(nmchg->nmhdr.hwndFrom, GWL_STYLE) & MCS_MULTISELECT;
 
-            if(GetWindowLongPtr(nmchg->nmhdr.hwndFrom, GWLP_ID) != SEL_NOTIFY_TEST_ID)
+            if(GetWindowLongPtrA(nmchg->nmhdr.hwndFrom, GWLP_ID) != SEL_NOTIFY_TEST_ID)
               break;
-            SendMessage(nmchg->nmhdr.hwndFrom, is_multisel ? MCM_GETSELRANGE :
-                        MCM_GETCURSEL, 0, (LPARAM)st);
+            SendMessageA(nmchg->nmhdr.hwndFrom, is_multisel ? MCM_GETSELRANGE : MCM_GETCURSEL,
+                    0, (LPARAM)st);
 
             expect(st[0].wYear,  nmchg->stSelStart.wYear);
             expect(st[0].wMonth, nmchg->stSelStart.wMonth);
@@ -542,7 +552,7 @@ static BOOL register_parent_wnd_class(void)
     cls.cbWndExtra = 0;
     cls.hInstance = GetModuleHandleA(NULL);
     cls.hIcon = 0;
-    cls.hCursor = LoadCursorA(0, IDC_ARROW);
+    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
     cls.lpszMenuName = NULL;
     cls.lpszClassName = "Month-Cal test parent class";
@@ -561,14 +571,10 @@ static HWND create_parent_window(void)
     if (!register_parent_wnd_class())
         return NULL;
 
-    hwnd = CreateWindowEx(0, "Month-Cal test parent class",
-                          "Month-Cal test parent window",
-                          WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
-                          WS_MAXIMIZEBOX | WS_VISIBLE,
-                          0, 0, 500, 500,
-                          GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
-
-    assert(hwnd);
+    hwnd = CreateWindowExA(0, "Month-Cal test parent class", "Month-Cal test parent window",
+            WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE,
+            0, 0, 500, 500, GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
+    ok(hwnd != NULL, "failed to create parent wnd\n");
 
     /* check for message sequences */
     ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_window_seq, "create parent window", FALSE);
@@ -611,20 +617,16 @@ static HWND create_monthcal_control(DWORD style)
     WNDPROC oldproc;
     HWND hwnd;
 
-    hwnd = CreateWindowEx(0,
-                    MONTHCAL_CLASS,
-                    "",
-                    WS_CHILD | WS_BORDER | WS_VISIBLE | style,
-                    0, 0, 300, 400,
-                    parent_wnd, NULL, GetModuleHandleA(NULL), NULL);
-
+    hwnd = CreateWindowExA(0, MONTHCAL_CLASSA, "", WS_CHILD | WS_BORDER | WS_VISIBLE | style,
+                    0, 0, 300, 400, parent_wnd, NULL, GetModuleHandleA(NULL), NULL);
+    ok(hwnd != NULL, "failed to create monthcal wnd\n");
     if (!hwnd) return NULL;
 
     oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
                                         (LONG_PTR)monthcal_subclass_proc);
     SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
 
-    SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(SYSTEM_FONT), 0);
+    SendMessageA(hwnd, WM_SETFONT, (WPARAM)GetStockObject(SYSTEM_FONT), 0);
 
     return hwnd;
 }
@@ -640,69 +642,69 @@ static void test_color(void)
     hwnd = create_monthcal_control(0);
 
     /* invalid color index */
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT + 1, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT + 1, 0);
     expect(~0u, color);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT + 1, RGB(255,255,255));
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT + 1, RGB(255,255,255));
     expect(~0u, prev);
 
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_BACKGROUND, RGB(0,0,0));
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_BACKGROUND, RGB(0,0,0));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
     expect(RGB(0,0,0), color);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_BACKGROUND, RGB(255,255,255));
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_BACKGROUND, RGB(255,255,255));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
     expect(RGB(255,255,255), color);
 
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_MONTHBK, RGB(0,0,0));
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_MONTHBK, RGB(0,0,0));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
     expect(RGB(0,0,0), color);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_MONTHBK, RGB(255,255,255));
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_MONTHBK, RGB(255,255,255));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
     expect(RGB(255,255,255), color);
 
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TEXT, RGB(0,0,0));
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TEXT, RGB(0,0,0));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
     expect(RGB(0,0,0), color);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TEXT, RGB(255,255,255));
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TEXT, RGB(255,255,255));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
     expect(RGB(255,255,255), color);
 
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLEBK, RGB(0,0,0));
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TITLEBK, RGB(0,0,0));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
     expect(RGB(0,0,0), color);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLEBK, RGB(255,255,255));
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TITLEBK, RGB(255,255,255));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
     expect(RGB(255,255,255), color);
 
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLETEXT, RGB(0,0,0));
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TITLETEXT, RGB(0,0,0));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
     expect(RGB(0,0,0), color);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLETEXT, RGB(255,255,255));
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TITLETEXT, RGB(255,255,255));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
     expect(RGB(255,255,255), color);
 
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT, RGB(0,0,0));
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT, RGB(0,0,0));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
     expect(RGB(0,0,0), color);
-    prev = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT, RGB(255,255,255));
+    prev = SendMessageA(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT, RGB(255,255,255));
     expect(color, prev);
-    color = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
+    color = SendMessageA(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
     expect(RGB(255,255,255), color);
 
     DestroyWindow(hwnd);
@@ -731,12 +733,12 @@ static void test_currdate(void)
     st_new = st_test = st_original;
 
     /* Should not validate the time */
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
     expect(1,res);
 
     /* Overflow matters, check for wDay */
     st_test.wDay += 4;
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
     expect(0,res);
 
     /* correct wDay before checking for wMonth */
@@ -745,7 +747,7 @@ static void test_currdate(void)
 
     /* Overflow matters, check for wMonth */
     st_test.wMonth += 4;
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
     expect(0,res);
 
     /* checking if gets the information right, modify st_new */
@@ -756,7 +758,7 @@ static void test_currdate(void)
     st_new.wMinute += 4;
     st_new.wSecond += 4;
 
-    res = SendMessage(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_new);
     expect(1, res);
 
     /* st_new change to st_origin, above settings with overflow */
@@ -775,7 +777,7 @@ static void test_currdate(void)
        "Expected %d, got %d\n", st_original.wSecond, st_new.wSecond);
 
     /* lparam cannot be NULL */
-    res = SendMessage(hwnd, MCM_GETCURSEL, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETCURSEL, 0, 0);
     expect(0, res);
 
     ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_curr_date_seq, "monthcal currDate", TRUE);
@@ -785,10 +787,10 @@ static void test_currdate(void)
     st_new.wYear = 9999;
     st_new.wMonth = 12;
     st_new.wDay = 31;
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
     expect(1, res);
     memset(&st_test, 0, sizeof(st_test));
-    res = SendMessage(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_test);
     expect(1, res);
     expect(st_new.wYear, st_test.wYear);
     expect(st_new.wMonth, st_test.wMonth);
@@ -801,14 +803,14 @@ static void test_currdate(void)
     st_new.wYear = 10000;
     st_new.wMonth = 1;
     st_new.wDay = 1;
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
     ok(0 == res ||
        broken(1 == res), /* comctl32 <= 4.72 */
        "Expected 0, got %d\n", res);
     if (0 == res)
     {
         memset(&st_test, 0, sizeof(st_test));
-        res = SendMessage(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_test);
+        res = SendMessageA(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_test);
         expect(1, res);
         expect(st_original.wYear, st_test.wYear);
         expect(st_original.wMonth, st_test.wMonth);
@@ -823,16 +825,16 @@ static void test_currdate(void)
     st_new.wYear = 2009;
     st_new.wDay  = 5;
     st_new.wMonth = 10;
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
     expect(1, res);
     memset(&st_test, 0, sizeof(st_test));
     st_test.wYear = 2009;
     st_test.wDay  = 6;
     st_test.wMonth = 10;
-    res = SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETRANGE, GDTR_MIN, (LPARAM)&st_test);
     expect(1, res);
     /* set to current again */
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_new);
     expect(1, res);
 
     /* set with invalid day of week */
@@ -841,11 +843,11 @@ static void test_currdate(void)
     st_test.wDay  = 7;
     st_test.wMonth = 10;
     st_test.wDayOfWeek = 100;
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
     expect(1, res);
 
     memset(&st_test, 0, sizeof(st_test));
-    res = SendMessage(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_test);
     expect(1, res);
     expect(2009, st_test.wYear);
     expect(7, st_test.wDay);
@@ -881,16 +883,16 @@ static void test_firstDay(void)
     /* check for locale first day */
     if(GetLocaleInfoA(lcid, LOCALE_IFIRSTDAYOFWEEK, b, 128)){
         fday = atoi(b);
-        res = SendMessage(hwnd, MCM_GETFIRSTDAYOFWEEK, 0, 0);
+        res = SendMessageA(hwnd, MCM_GETFIRSTDAYOFWEEK, 0, 0);
         expect(fday, res);
         prev = fday;
 
         /* checking for the values that actually will be stored as */
         /* current first day when we set a new value */
         for (i = -5; i < 12; i++){
-            res = SendMessage(hwnd, MCM_SETFIRSTDAYOFWEEK, 0, i);
+            res = SendMessageA(hwnd, MCM_SETFIRSTDAYOFWEEK, 0, i);
             expect(prev, res);
-            res = SendMessage(hwnd, MCM_GETFIRSTDAYOFWEEK, 0, 0);
+            res = SendMessageA(hwnd, MCM_GETFIRSTDAYOFWEEK, 0, 0);
             prev = res;
 
             if (i == -1){
@@ -924,30 +926,30 @@ static void test_unicode(void)
     /* Setter and Getters for Unicode format */
 
     /* getting the current settings */
-    temp = SendMessage(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
+    temp = SendMessageA(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
 
     /* setting to 1, should return previous settings */
-    res = SendMessage(hwnd, MCM_SETUNICODEFORMAT, 1, 0);
+    res = SendMessageA(hwnd, MCM_SETUNICODEFORMAT, 1, 0);
     expect(temp, res);
 
     /* current setting is 1, so, should return 1 */
-    res = SendMessage(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
     ok(1 == res ||
        broken(0 == res), /* comctl32 <= 4.70 */
        "Expected 1, got %d\n", res);
 
     /* setting to 0, should return previous settings */
-    res = SendMessage(hwnd, MCM_SETUNICODEFORMAT, 0, 0);
+    res = SendMessageA(hwnd, MCM_SETUNICODEFORMAT, 0, 0);
     ok(1 == res ||
        broken(0 == res), /* comctl32 <= 4.70 */
        "Expected 1, got %d\n", res);
 
     /* current setting is 0, so, it should return 0 */
-    res = SendMessage(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
     expect(0, res);
 
     /* should return previous settings */
-    res = SendMessage(hwnd, MCM_SETUNICODEFORMAT, 1, 0);
+    res = SendMessageA(hwnd, MCM_SETUNICODEFORMAT, 1, 0);
     expect(0, res);
 
     ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_unicode_seq, "monthcal unicode", FALSE);
@@ -960,18 +962,18 @@ static void test_hittest(void)
     typedef struct hittest_test
     {
        UINT ht;
-        int  todo;
+        BOOL  todo;
     } hittest_test_t;
 
     static const hittest_test_t title_hits[] = {
         /* Start is the same everywhere */
-        { MCHT_TITLE,        0 },
-        { MCHT_TITLEBTNPREV, 0 },
+        { MCHT_TITLE,        FALSE },
+        { MCHT_TITLEBTNPREV, FALSE },
         /* The middle piece is only tested for presence of items */
         /* End is the same everywhere */
-        { MCHT_TITLEBTNNEXT, 0 },
-        { MCHT_TITLE,        0 },
-        { MCHT_NOWHERE,      1 }
+        { MCHT_TITLEBTNNEXT, FALSE },
+        { MCHT_TITLE,        FALSE },
+        { MCHT_NOWHERE,      TRUE }
     };
 
     MCHITTESTINFO mchit;
@@ -993,17 +995,17 @@ static void test_hittest(void)
     mchit.cbSize = MCHITTESTINFO_V1_SIZE - 1;
     mchit.pt.x = 0;
     mchit.pt.y = 0;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(0, mchit.pt.x);
     expect(0, mchit.pt.y);
     expect(~0u, res);
     expect(0, mchit.uHit);
     /* test with invalid pointer */
-    res = SendMessage(hwnd, MCM_HITTEST, 0, 0);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, 0);
     expect(~0u, res);
 
     /* resize control to display single Calendar */
-    res = SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
+    res = SendMessageA(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
     if (res == 0)
     {
         win_skip("Message MCM_GETMINREQRECT unsupported. Skipping.\n");
@@ -1023,14 +1025,14 @@ static void test_hittest(void)
     st.wMilliseconds = 0;
     st.wDayOfWeek = 0;
 
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st);
     expect(1,res);
 
     /* (0, 0) is the top left of the control - title */
     mchit.cbSize = MCHITTESTINFO_V1_SIZE;
     mchit.pt.x = 0;
     mchit.pt.y = 0;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(0, mchit.pt.x);
     expect(0, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1039,7 +1041,7 @@ static void test_hittest(void)
     /* bottom right of the control and should not be active */
     mchit.pt.x = r.right;
     mchit.pt.y = r.bottom;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right,  mchit.pt.x);
     expect(r.bottom, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1048,7 +1050,7 @@ static void test_hittest(void)
     /* completely out of the control, should not be active */
     mchit.pt.x = 2 * r.right;
     mchit.pt.y = 2 * r.bottom;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(2 * r.right, mchit.pt.x);
     expect(2 * r.bottom, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1057,7 +1059,7 @@ static void test_hittest(void)
     /* in active area - day of the week */
     mchit.pt.x = r.right / 2;
     mchit.pt.y = r.bottom / 2;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right / 2, mchit.pt.x);
     expect(r.bottom / 2, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1066,7 +1068,7 @@ static void test_hittest(void)
     /* in active area - day of the week #2 */
     mchit.pt.x = r.right / 14; /* half of first day rect */
     mchit.pt.y = r.bottom / 2;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right / 14, mchit.pt.x);
     expect(r.bottom / 2, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1075,27 +1077,28 @@ static void test_hittest(void)
     /* in active area - date from prev month */
     mchit.pt.x = r.right / 14; /* half of first day rect */
     mchit.pt.y = 6 * r.bottom / 19;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right / 14, mchit.pt.x);
     expect(6 * r.bottom / 19, mchit.pt.y);
     expect(mchit.uHit, res);
     expect_hex(MCHT_CALENDARDATEPREV, res);
 
-#if 0
+if (0)
+{
     /* (125, 115) is in active area - date from this month */
     mchit.pt.x = 125;
     mchit.pt.y = 115;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(125, mchit.pt.x);
     expect(115, mchit.pt.y);
     expect(mchit.uHit, res);
     expect(MCHT_CALENDARDATE, res);
-#endif
+}
 
     /* in active area - date from next month */
     mchit.pt.x = 11 * r.right / 14;
     mchit.pt.y = 16 * r.bottom / 19;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(11 * r.right / 14, mchit.pt.x);
     expect(16 * r.bottom / 19, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1104,7 +1107,7 @@ static void test_hittest(void)
     /* in active area - today link */
     mchit.pt.x = r.right / 14;
     mchit.pt.y = 18 * r.bottom / 19;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right / 14, mchit.pt.x);
     expect(18 * r.bottom / 19, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1113,7 +1116,7 @@ static void test_hittest(void)
     /* in active area - today link */
     mchit.pt.x = r.right / 2;
     mchit.pt.y = 18 * r.bottom / 19;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right / 2, mchit.pt.x);
     expect(18 * r.bottom / 19, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1122,7 +1125,7 @@ static void test_hittest(void)
     /* in active area - today link */
     mchit.pt.x = r.right / 10;
     mchit.pt.y = 18 * r.bottom / 19;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right / 10, mchit.pt.x);
     expect(18 * r.bottom / 19, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1135,7 +1138,7 @@ static void test_hittest(void)
        find all elements. */
 
     /* Get the format of the title */
-    GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SYEARMONTH, yearmonth, 80);
+    GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SYEARMONTH, yearmonth, 80);
     /* Find out if we have a month and/or year */
     locale_year = strstr(yearmonth, "y");
     locale_month = strstr(yearmonth, "M");
@@ -1143,14 +1146,14 @@ static void test_hittest(void)
     mchit.pt.x = 0;
     mchit.pt.y = (5/2) * r.bottom / 19;
     title_index = 0;
-    old_res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    old_res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect_hex(title_hits[title_index].ht, old_res);
 
     in_the_middle = FALSE;
     month_count = year_count = 0;
     for (x = 0; x < r.right; x++){
         mchit.pt.x = x;
-        res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+        res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
         expect(x, mchit.pt.x);
         expect((5/2) * r.bottom / 19, mchit.pt.y);
         expect(mchit.uHit, res);
@@ -1218,7 +1221,7 @@ static void test_todaylink(void)
 
     hwnd = create_monthcal_control(0);
 
-    res = SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
+    res = SendMessageA(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
     expect(1, res);
     MoveWindow(hwnd, 0, 0, r.right, r.bottom, FALSE);
 
@@ -1228,7 +1231,7 @@ static void test_todaylink(void)
     mchit.cbSize = MCHITTESTINFO_V1_SIZE;
     mchit.pt.x = r.right / 14;
     mchit.pt.y = 18 * r.bottom / 19;
-    res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
+    res = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     expect(r.right / 14, mchit.pt.x);
     expect(18 * r.bottom / 19, mchit.pt.y);
     expect(mchit.uHit, res);
@@ -1238,21 +1241,21 @@ static void test_todaylink(void)
     st_test.wMonth = 1;
     st_test.wYear = 2005;
 
-    res = SendMessage(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
     expect(0, res);
 
     memset(&st_new, 0, sizeof(st_new));
-    res = SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
     expect(1, res);
     expect(1, st_new.wDay);
     expect(1, st_new.wMonth);
     expect(2005, st_new.wYear);
 
-    res = SendMessage(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, MAKELONG(mchit.pt.x, mchit.pt.y));
+    res = SendMessageA(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, MAKELONG(mchit.pt.x, mchit.pt.y));
     expect(0, res);
 
     memset(&st_new, 0, sizeof(st_new));
-    res = SendMessage(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_new);
     expect(1, res);
     expect(1, st_new.wDay);
     expect(1, st_new.wMonth);
@@ -1283,10 +1286,10 @@ static void test_today(void)
     st_new.wDay = 27;
     st_new.wMonth = 27;
 
-    res = SendMessage(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
     expect(0, res);
 
-    res = SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
     expect(1, res);
 
     /* st_test should not change */
@@ -1301,10 +1304,10 @@ static void test_today(void)
     st_test.wDay = 0;
     st_test.wMonth = 0;
 
-    res = SendMessage(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
+    res = SendMessageA(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
     expect(0, res);
 
-    res = SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
+    res = SendMessageA(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
     expect(1, res);
 
     /* st_test should not change */
@@ -1327,33 +1330,33 @@ static void test_scroll(void)
 
     hwnd = create_monthcal_control(0);
 
-    res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMONTHDELTA, 0, 0);
     expect(2, res);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
     /* Setter and Getters for scroll rate */
-    res = SendMessage(hwnd, MCM_SETMONTHDELTA, 2, 0);
+    res = SendMessageA(hwnd, MCM_SETMONTHDELTA, 2, 0);
     expect(0, res);
 
-    res = SendMessage(hwnd, MCM_SETMONTHDELTA, 3, 0);
+    res = SendMessageA(hwnd, MCM_SETMONTHDELTA, 3, 0);
     expect(2, res);
-    res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMONTHDELTA, 0, 0);
     expect(3, res);
 
-    res = SendMessage(hwnd, MCM_SETMONTHDELTA, 12, 0);
+    res = SendMessageA(hwnd, MCM_SETMONTHDELTA, 12, 0);
     expect(3, res);
-    res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMONTHDELTA, 0, 0);
     expect(12, res);
 
-    res = SendMessage(hwnd, MCM_SETMONTHDELTA, 15, 0);
+    res = SendMessageA(hwnd, MCM_SETMONTHDELTA, 15, 0);
     expect(12, res);
-    res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMONTHDELTA, 0, 0);
     expect(15, res);
 
-    res = SendMessage(hwnd, MCM_SETMONTHDELTA, -5, 0);
+    res = SendMessageA(hwnd, MCM_SETMONTHDELTA, -5, 0);
     expect(15, res);
-    res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMONTHDELTA, 0, 0);
     expect(-5, res);
 
     ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_scroll_seq, "monthcal scroll", FALSE);
@@ -1382,20 +1385,20 @@ static void test_monthrange(void)
     st.wMilliseconds = 0;
     st.wDayOfWeek = 0;
 
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st);
     expect(1,res);
 
     /* to be locale independent */
-    SendMessage(hwnd, MCM_SETFIRSTDAYOFWEEK, 0, (LPARAM)6);
+    SendMessageA(hwnd, MCM_SETFIRSTDAYOFWEEK, 0, (LPARAM)6);
 
-    res = SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
+    res = SendMessageA(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
     expect(TRUE, res);
     /* resize control to display two Calendars */
     MoveWindow(hwnd, 0, 0, r.right, (5/2)*r.bottom, FALSE);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
-    res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st_visible);
+    res = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st_visible);
     expect(2, res);
     expect(2000, st_visible[0].wYear);
     expect(11, st_visible[0].wMonth);
@@ -1404,7 +1407,7 @@ static void test_monthrange(void)
     expect(12, st_visible[1].wMonth);
     expect(31, st_visible[1].wDay);
 
-    res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_DAYSTATE, (LPARAM)st_daystate);
+    res = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_DAYSTATE, (LPARAM)st_daystate);
     expect(4, res);
     expect(2000, st_daystate[0].wYear);
     expect(10, st_daystate[0].wMonth);
@@ -1416,10 +1419,10 @@ static void test_monthrange(void)
     ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_monthrange_seq, "monthcal monthrange", FALSE);
 
     /* with null date array parameter */
-    res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, 0);
+    res = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, 0);
     expect(2, res);
 
-    res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_DAYSTATE, 0);
+    res = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_DAYSTATE, 0);
     expect(4, res);
 
     /* resize control to display single Calendar */
@@ -1430,11 +1433,11 @@ static void test_monthrange(void)
     st.wYear  = 1752;
     st.wDay   = 14;
 
-    res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st);
+    res = SendMessageA(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st);
     expect(1, res);
 
     /* September 1752 has 19 days */
-    res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st_visible);
+    res = SendMessageA(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st_visible);
     expect(1, res);
 
     expect(1752, st_visible[0].wYear);
@@ -1458,59 +1461,59 @@ static void test_maxselday(void)
 
     hwnd = create_monthcal_control(0);
     /* if no style specified default to 1 */
-    res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
     expect(1, res);
-    res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, 5, 0);
+    res = SendMessageA(hwnd, MCM_SETMAXSELCOUNT, 5, 0);
     expect(0, res);
-    res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
     expect(1, res);
 
     /* try to set style */
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    SetWindowLong(hwnd, GWL_STYLE, style | MCS_MULTISELECT);
-    style = GetWindowLong(hwnd, GWL_STYLE);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
+    SetWindowLongA(hwnd, GWL_STYLE, style | MCS_MULTISELECT);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
     ok(!(style & MCS_MULTISELECT), "Expected MCS_MULTISELECT not to be set\n");
     DestroyWindow(hwnd);
 
     hwnd = create_monthcal_control(MCS_MULTISELECT);
     /* try to remove style */
-    style = GetWindowLong(hwnd, GWL_STYLE);
-    SetWindowLong(hwnd, GWL_STYLE, style & ~MCS_MULTISELECT);
-    style = GetWindowLong(hwnd, GWL_STYLE);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
+    SetWindowLongA(hwnd, GWL_STYLE, style & ~MCS_MULTISELECT);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
     ok(style & MCS_MULTISELECT, "Expected MCS_MULTISELECT to be set\n");
     DestroyWindow(hwnd);
 
     hwnd = create_monthcal_control(MCS_MULTISELECT);
 
     /* default width is a week */
-    res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
     expect(7, res);
 
     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 
     /* Setter and Getters for max selected days */
-    res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, 5, 0);
+    res = SendMessageA(hwnd, MCM_SETMAXSELCOUNT, 5, 0);
     expect(1, res);
-    res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
     expect(5, res);
 
-    res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, 15, 0);
+    res = SendMessageA(hwnd, MCM_SETMAXSELCOUNT, 15, 0);
     expect(1, res);
-    res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
     expect(15, res);
 
     /* test invalid value */
-    res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, -1, 0);
+    res = SendMessageA(hwnd, MCM_SETMAXSELCOUNT, -1, 0);
     expect(0, res);
-    res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
     expect(15, res);
 
     ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_max_sel_day_seq, "monthcal MaxSelDay", FALSE);
 
     /* zero value is invalid too */
-    res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_SETMAXSELCOUNT, 0, 0);
     expect(0, res);
-    res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
+    res = SendMessageA(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
     expect(15, res);
 
     DestroyWindow(hwnd);
@@ -1535,14 +1538,14 @@ static void test_size(void)
     hFont2 = CreateFontIndirectA(&logfont);
 
     /* initialize to a font we can compare against */
-    SendMessage(hwnd, WM_SETFONT, (WPARAM)hFont1, 0);
-    res = SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r1);
-    ok(res, "SendMessage(MCM_GETMINREQRECT) failed\n");
+    SendMessageA(hwnd, WM_SETFONT, (WPARAM)hFont1, 0);
+    res = SendMessageA(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r1);
+    ok(res, "SendMessageA(MCM_GETMINREQRECT) failed\n");
 
     /* check that setting a larger font results in an larger rect */
-    SendMessage(hwnd, WM_SETFONT, (WPARAM)hFont2, 0);
-    res = SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r2);
-    ok(res, "SendMessage(MCM_GETMINREQRECT) failed\n");
+    SendMessageA(hwnd, WM_SETFONT, (WPARAM)hFont2, 0);
+    res = SendMessageA(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r2);
+    ok(res, "SendMessageA(MCM_GETMINREQRECT) failed\n");
 
     OffsetRect(&r1, -r1.left, -r1.top);
     OffsetRect(&r2, -r2.left, -r2.top);
@@ -1595,11 +1598,11 @@ static void test_selrange(void)
     hwnd = create_monthcal_control(MCS_MULTISELECT);
 
     /* just after creation selection should start and end today */
-    ret = SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&st);
+    ret = SendMessageA(hwnd, MCM_GETTODAY, 0, (LPARAM)&st);
     expect(TRUE, ret);
 
     memset(range, 0xcc, sizeof(range));
-    ret = SendMessage(hwnd, MCM_GETSELRANGE, 0, (LPARAM)range);
+    ret = SendMessageA(hwnd, MCM_GETSELRANGE, 0, (LPARAM)range);
     expect(TRUE, ret);
     expect(st.wYear,      range[0].wYear);
     expect(st.wMonth,     range[0].wMonth);
@@ -1638,10 +1641,10 @@ static void test_selrange(void)
     range[1] = range[0];
     range[1].wDay   = 3;
 
-    ret = SendMessage(hwnd, MCM_SETSELRANGE, 0, (LPARAM)range);
+    ret = SendMessageA(hwnd, MCM_SETSELRANGE, 0, (LPARAM)range);
     expect(TRUE, ret);
 
-    ret = SendMessage(hwnd, MCM_GETSELRANGE, 0, (LPARAM)range2);
+    ret = SendMessageA(hwnd, MCM_GETSELRANGE, 0, (LPARAM)range2);
     expect(TRUE, ret);
 
     expect(range[1].wYear,      range2[0].wYear);
@@ -1669,17 +1672,17 @@ static void test_selrange(void)
     range[0].wDay   = 1;
     range[1] = range[0];
 
-    ret = SendMessage(hwnd, MCM_SETSELRANGE, 0, (LPARAM)range);
+    ret = SendMessageA(hwnd, MCM_SETSELRANGE, 0, (LPARAM)range);
     expect(TRUE, ret);
 
     range[1] = range[0];
     /* default max. range is 7 days */
     range[1].wDay = 8;
 
-    ret = SendMessage(hwnd, MCM_SETSELRANGE, 0, (LPARAM)range);
+    ret = SendMessageA(hwnd, MCM_SETSELRANGE, 0, (LPARAM)range);
     expect(FALSE, ret);
 
-    ret = SendMessage(hwnd, MCM_GETSELRANGE, 0, (LPARAM)range2);
+    ret = SendMessageA(hwnd, MCM_GETSELRANGE, 0, (LPARAM)range2);
     expect(TRUE, ret);
 
     expect(range[0].wYear,  range2[0].wYear);
@@ -1700,16 +1703,16 @@ static void test_killfocus(void)
     hwnd = create_monthcal_control(0);
 
     /* make parent invisible */
-    style = GetWindowLong(parent_wnd, GWL_STYLE);
-    SetWindowLong(parent_wnd, GWL_STYLE, style &~ WS_VISIBLE);
+    style = GetWindowLongA(parent_wnd, GWL_STYLE);
+    SetWindowLongA(parent_wnd, GWL_STYLE, style & ~WS_VISIBLE);
 
-    SendMessage(hwnd, WM_KILLFOCUS, (WPARAM)GetDesktopWindow(), 0);
+    SendMessageA(hwnd, WM_KILLFOCUS, (WPARAM)GetDesktopWindow(), 0);
 
-    style = GetWindowLong(hwnd, GWL_STYLE);
+    style = GetWindowLongA(hwnd, GWL_STYLE);
     ok(style & WS_VISIBLE, "Expected WS_VISIBLE to be set\n");
 
-    style = GetWindowLong(parent_wnd, GWL_STYLE);
-    SetWindowLong(parent_wnd, GWL_STYLE, style | WS_VISIBLE);
+    style = GetWindowLongA(parent_wnd, GWL_STYLE);
+    SetWindowLongA(parent_wnd, GWL_STYLE, style | WS_VISIBLE);
 
     DestroyWindow(hwnd);
 }
@@ -1722,9 +1725,9 @@ static void test_hittest_v6(void)
     RECT r;
 
     hwnd = create_monthcal_control(0);
-    SendMessage(hwnd, MCM_SETCALENDARBORDER, TRUE, 0);
+    SendMessageA(hwnd, MCM_SETCALENDARBORDER, TRUE, 0);
 
-    SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
+    SendMessageA(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r);
     /* reserving some area around calendar */
     MoveWindow(hwnd, 0, 0, r.right * 3 / 2, r.bottom * 3 / 2, FALSE);
     mchit.cbSize = sizeof(MCHITTESTINFO);
@@ -1732,7 +1735,7 @@ static void test_hittest_v6(void)
     mchit.iOffset = -1;
     mchit.iRow = -1;
     mchit.iCol = -1;
-    ret = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
+    ret = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
     if (ret == ~0u)
     {
         win_skip("Only MCHITTESTINFO_V1 supported\n");
@@ -1748,7 +1751,7 @@ static void test_hittest_v6(void)
     mchit.pt.x = r.right / 2;
     mchit.pt.y = r.bottom / 2;
     mchit.iOffset = -1;
-    ret = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);
+    ret = SendMessageA(hwnd, MCM_HITTEST, 0, (LPARAM)&mchit);