dlls/user32/tests/dde.c

   1 /*
   2  * Unit tests for DDE functions
   3  *
   4  * Copyright (c) 2004 Dmitry Timoshkov
   5  * Copyright (c) 2007 James Hawkins
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "dde.h"
  30 #include "ddeml.h"
  31 #include "winerror.h"
  32
  33 #include "wine/test.h"
  34
  35 static const WCHAR TEST_DDE_SERVICE[] = {'T','e','s','t','D','D','E','S','e','r','v','i','c','e',0};
  36
  37 static char exec_cmdA[] = "ANSI dde command";
  38 static WCHAR exec_cmdW[] = {'u','n','i','c','o','d','e',' ','d','d','e',' ','c','o','m','m','a','n','d',0};
  39
  40 static WNDPROC old_dde_client_wndproc;
  41
  42 static const DWORD default_timeout = 200;
  43
  44 static void flush_events(void)
  45 {
  46     MSG msg;
  47     int diff = default_timeout;
  48     int min_timeout = 50;
  49     DWORD time = GetTickCount() + diff;
  50
  51     while (diff > 0)
  52     {
  53         if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
  54         while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessage( &msg );
  55         diff = time - GetTickCount();
  56         min_timeout = 10;
  57     }
  58 }
  59
  60 static void create_dde_window(HWND *hwnd, LPCSTR name, WNDPROC wndproc)
  61 {
  62     WNDCLASSA wcA;
  63
  64     memset(&wcA, 0, sizeof(wcA));
  65     wcA.lpfnWndProc = wndproc;
  66     wcA.lpszClassName = name;
  67     wcA.hInstance = GetModuleHandleA(0);
  68     assert(RegisterClassA(&wcA));
  69
  70     *hwnd = CreateWindowExA(0, name, NULL, WS_POPUP,
  71                             500, 500, CW_USEDEFAULT, CW_USEDEFAULT,
  72                             GetDesktopWindow(), 0, GetModuleHandleA(0), NULL);
  73     assert(*hwnd);
  74 }
  75
  76 static LRESULT WINAPI dde_server_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
  77 {
  78     UINT_PTR lo, hi;
  79     char str[MAX_PATH], *ptr;
  80     HGLOBAL hglobal;
  81     DDEDATA *data;
  82     DDEPOKE *poke;
  83     DWORD size;
  84
  85     static int msg_index = 0;
  86     static HWND client = 0;
  87     static BOOL executed = FALSE;
  88
  89     if (msg < WM_DDE_FIRST || msg > WM_DDE_LAST)
  90         return DefWindowProcA(hwnd, msg, wparam, lparam);
  91
  92     msg_index++;
  93
  94     switch (msg)
  95     {
  96     case WM_DDE_INITIATE:
  97     {
  98         client = (HWND)wparam;
  99         ok(msg_index == 1, "Expected 1, got %d\n", msg_index);
 100
 101         GlobalGetAtomNameA(LOWORD(lparam), str, MAX_PATH);
 102         ok(!lstrcmpA(str, "TestDDEService"), "Expected TestDDEService, got %s\n", str);
 103
 104         GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
 105         ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 106
 107         SendMessageA(client, WM_DDE_ACK, (WPARAM)hwnd, lparam);
 108
 109         break;
 110     }
 111
 112     case WM_DDE_REQUEST:
 113     {
 114         ok((msg_index >= 2 && msg_index <= 4) ||
 115            (msg_index >= 7 && msg_index <= 8),
 116            "Expected 2, 3, 4, 7 or 8, got %d\n", msg_index);
 117         ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
 118         ok(LOWORD(lparam) == CF_TEXT, "Expected CF_TEXT, got %d\n", LOWORD(lparam));
 119
 120         GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
 121         if (msg_index < 8)
 122             ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
 123         else
 124             ok(!lstrcmpA(str, "executed"), "Expected executed, got %s\n", str);
 125
 126         if (msg_index == 8)
 127         {
 128             if (executed)
 129                 lstrcpyA(str, "command executed\r\n");
 130             else
 131                 lstrcpyA(str, "command not executed\r\n");
 132         }
 133         else
 134             lstrcpyA(str, "requested data\r\n");
 135
 136         size = sizeof(DDEDATA) + lstrlenA(str) + 1;
 137         hglobal = GlobalAlloc(GMEM_MOVEABLE, size);
 138         ok(hglobal != NULL, "Expected non-NULL hglobal\n");
 139
 140         data = GlobalLock(hglobal);
 141         ZeroMemory(data, size);
 142
 143         /* setting fResponse to FALSE at this point destroys
 144          * the internal messaging state of native dde
 145          */
 146         data->fResponse = TRUE;
 147
 148         if (msg_index == 2)
 149             data->fRelease = TRUE;
 150         else if (msg_index == 3)
 151             data->fAckReq = TRUE;
 152
 153         data->cfFormat = CF_TEXT;
 154         lstrcpyA((LPSTR)data->Value, str);
 155         GlobalUnlock(hglobal);
 156
 157         lparam = PackDDElParam(WM_DDE_ACK, (UINT)hglobal, HIWORD(lparam));
 158         PostMessageA(client, WM_DDE_DATA, (WPARAM)hwnd, lparam);
 159
 160         break;
 161     }
 162
 163     case WM_DDE_POKE:
 164     {
 165         ok(msg_index == 5 || msg_index == 6, "Expected 5 or 6, got %d\n", msg_index);
 166         ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
 167
 168         UnpackDDElParam(WM_DDE_POKE, lparam, &lo, &hi);
 169
 170         GlobalGetAtomNameA(hi, str, MAX_PATH);
 171         ok(!lstrcmpA(str, "poker"), "Expected poker, got %s\n", str);
 172
 173         poke = GlobalLock((HGLOBAL)lo);
 174         ok(poke != NULL, "Expected non-NULL poke\n");
 175         ok(poke->fReserved == 0, "Expected 0, got %d\n", poke->fReserved);
 176         ok(poke->unused == 0, "Expected 0, got %d\n", poke->unused);
 177         ok(poke->fRelease == TRUE, "Expected TRUE, got %d\n", poke->fRelease);
 178         ok(poke->cfFormat == CF_TEXT, "Expected CF_TEXT, got %d\n", poke->cfFormat);
 179
 180         if (msg_index == 5)
 181         {
 182             size = GlobalSize((HGLOBAL)lo);
 183             ok(size == 4, "got %d\n", size);
 184         }
 185         else
 186             ok(!lstrcmpA((LPSTR)poke->Value, "poke data\r\n"),
 187                "Expected 'poke data\\r\\n', got %s\n", poke->Value);
 188
 189         GlobalUnlock((HGLOBAL)lo);
 190
 191         lparam = PackDDElParam(WM_DDE_ACK, DDE_FACK, hi);
 192         PostMessageA(client, WM_DDE_ACK, (WPARAM)hwnd, lparam);
 193
 194         break;
 195     }
 196
 197     case WM_DDE_EXECUTE:
 198     {
 199         ok(msg_index == 7, "Expected 7, got %d\n", msg_index);
 200         ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
 201
 202         ptr = GlobalLock((HGLOBAL)lparam);
 203         ok(!lstrcmpA(ptr, "[Command(Var)]"), "Expected [Command(Var)], got %s\n", ptr);
 204         GlobalUnlock((HGLOBAL)lparam);
 205
 206         executed = TRUE;
 207
 208         lparam = ReuseDDElParam(lparam, WM_DDE_EXECUTE, WM_DDE_ACK, DDE_FACK, HIWORD(lparam));
 209         PostMessageA(client, WM_DDE_ACK, (WPARAM)hwnd, lparam);
 210
 211         break;
 212     }
 213
 214     case WM_DDE_TERMINATE:
 215     {
 216         ok(msg_index == 9, "Expected 9, got %d\n", msg_index);
 217         ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
 218         ok(lparam == 0, "Expected 0, got %08lx\n", lparam);
 219
 220         PostMessageA(client, WM_DDE_TERMINATE, (WPARAM)hwnd, 0);
 221
 222         break;
 223     }
 224
 225     default:
 226         ok(FALSE, "Unhandled msg: %08x\n", msg);
 227     }
 228
 229     return DefWindowProcA(hwnd, msg, wparam, lparam);
 230 }
 231
 232 static void test_msg_server(HANDLE hproc, HANDLE hthread)
 233 {
 234     MSG msg;
 235     HWND hwnd;
 236     DWORD res;
 237
 238     create_dde_window(&hwnd, "dde_server", dde_server_wndproc);
 239     ResumeThread( hthread );
 240
 241     while (MsgWaitForMultipleObjects( 1, &hproc, FALSE, INFINITE, QS_ALLINPUT ) != 0)
 242     {
 243         while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
 244     }
 245
 246     DestroyWindow(hwnd);
 247     GetExitCodeProcess( hproc, &res );
 248     ok( !res, "client failed with %u error(s)\n", res );
 249 }
 250
 251 static HDDEDATA CALLBACK client_ddeml_callback(UINT uType, UINT uFmt, HCONV hconv,
 252                                                HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
 253                                                ULONG_PTR dwData1, ULONG_PTR dwData2)
 254 {
 255     ok(FALSE, "Unhandled msg: %08x\n", uType);
 256     return 0;
 257 }
 258
 259 static void test_ddeml_client(void)
 260 {
 261     UINT ret;
 262     char buffer[32];
 263     LPSTR str;
 264     DWORD size, res;
 265     HDDEDATA hdata, op;
 266     HSZ server, topic, item;
 267     DWORD client_pid;
 268     HCONV conversation;
 269
 270     client_pid = 0;
 271     ret = DdeInitializeA(&client_pid, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
 272     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 273
 274     /* FIXME: make these atoms global and check them in the server */
 275
 276     server = DdeCreateStringHandleA(client_pid, "TestDDEService", CP_WINANSI);
 277     topic = DdeCreateStringHandleA(client_pid, "TestDDETopic", CP_WINANSI);
 278
 279     DdeGetLastError(client_pid);
 280     conversation = DdeConnect(client_pid, server, topic, NULL);
 281     ok(conversation != NULL, "Expected non-NULL conversation\n");
 282     ret = DdeGetLastError(client_pid);
 283     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 284
 285     DdeFreeStringHandle(client_pid, server);
 286
 287     item = DdeCreateStringHandleA(client_pid, "request", CP_WINANSI);
 288
 289     /* XTYP_REQUEST, fRelease = TRUE */
 290     res = 0xdeadbeef;
 291     DdeGetLastError(client_pid);
 292     hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
 293     ret = DdeGetLastError(client_pid);
 294     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 295     ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %08x\n", res);
 296     if (hdata == NULL)
 297         ok(FALSE, "hdata is NULL\n");
 298     else
 299     {
 300         str = (LPSTR)DdeAccessData(hdata, &size);
 301         ok(!lstrcmpA(str, "requested data\r\n"), "Expected 'requested data\\r\\n', got %s\n", str);
 302         ok(size == 19, "Expected 19, got %d\n", size);
 303
 304         ret = DdeUnaccessData(hdata);
 305         ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
 306     }
 307
 308     /* XTYP_REQUEST, fAckReq = TRUE */
 309     res = 0xdeadbeef;
 310     DdeGetLastError(client_pid);
 311     hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
 312     ret = DdeGetLastError(client_pid);
 313     ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %d\n", res);
 314 todo_wine
 315     ok(ret == DMLERR_MEMORY_ERROR, "Expected DMLERR_MEMORY_ERROR, got %d\n", ret);
 316     if (hdata == NULL)
 317         ok(FALSE, "hdata is NULL\n");
 318     else
 319     {
 320         str = (LPSTR)DdeAccessData(hdata, &size);
 321         ok(!lstrcmpA(str, "requested data\r\n"), "Expected 'requested data\\r\\n', got %s\n", str);
 322         ok(size == 19, "Expected 19, got %d\n", size);
 323
 324         ret = DdeUnaccessData(hdata);
 325         ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
 326     }
 327
 328     /* XTYP_REQUEST, all params normal */
 329     res = 0xdeadbeef;
 330     DdeGetLastError(client_pid);
 331     hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
 332     ret = DdeGetLastError(client_pid);
 333     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 334     ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %d\n", res);
 335     if (hdata == NULL)
 336         ok(FALSE, "hdata is NULL\n");
 337     else
 338     {
 339         str = (LPSTR)DdeAccessData(hdata, &size);
 340         ok(!lstrcmpA(str, "requested data\r\n"), "Expected 'requested data\\r\\n', got %s\n", str);
 341         ok(size == 19, "Expected 19, got %d\n", size);
 342
 343         ret = DdeUnaccessData(hdata);
 344         ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
 345     }
 346
 347     /* XTYP_REQUEST, no item */
 348     res = 0xdeadbeef;
 349     DdeGetLastError(client_pid);
 350     hdata = DdeClientTransaction(NULL, 0, conversation, 0, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
 351     ret = DdeGetLastError(client_pid);
 352     ok(hdata == NULL, "Expected NULL hdata, got %p\n", hdata);
 353     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %08x\n", res);
 354     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 355
 356     DdeFreeStringHandle(client_pid, item);
 357
 358     item = DdeCreateStringHandleA(client_pid, "poker", CP_WINANSI);
 359
 360     lstrcpyA(buffer, "poke data\r\n");
 361     hdata = DdeCreateDataHandle(client_pid, (LPBYTE)buffer, lstrlenA(buffer) + 1,
 362                                 0, item, CF_TEXT, 0);
 363     ok(hdata != NULL, "Expected non-NULL hdata\n");
 364
 365     /* XTYP_POKE, no item */
 366     res = 0xdeadbeef;
 367     DdeGetLastError(client_pid);
 368     op = DdeClientTransaction((LPBYTE)hdata, -1, conversation, 0, CF_TEXT, XTYP_POKE, default_timeout, &res);
 369     ret = DdeGetLastError(client_pid);
 370     ok(op == NULL, "Expected NULL, got %p\n", op);
 371     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 372     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 373
 374     /* XTYP_POKE, no data */
 375     res = 0xdeadbeef;
 376     DdeGetLastError(client_pid);
 377     op = DdeClientTransaction(NULL, 0, conversation, 0, CF_TEXT, XTYP_POKE, default_timeout, &res);
 378     ret = DdeGetLastError(client_pid);
 379     ok(op == NULL, "Expected NULL, got %p\n", op);
 380     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 381     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 382
 383     /* XTYP_POKE, wrong size */
 384     res = 0xdeadbeef;
 385     DdeGetLastError(client_pid);
 386     op = DdeClientTransaction((LPBYTE)hdata, 0, conversation, item, CF_TEXT, XTYP_POKE, default_timeout, &res);
 387     ret = DdeGetLastError(client_pid);
 388     ok(op == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", op);
 389     ok(res == DDE_FACK, "Expected DDE_FACK, got %d\n", res);
 390     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 391
 392     /* XTYP_POKE, correct params */
 393     res = 0xdeadbeef;
 394     DdeGetLastError(client_pid);
 395     op = DdeClientTransaction((LPBYTE)hdata, -1, conversation, item, CF_TEXT, XTYP_POKE, default_timeout, &res);
 396     ret = DdeGetLastError(client_pid);
 397     ok(op == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", op);
 398     ok(res == DDE_FACK, "Expected DDE_FACK, got %d\n", res);
 399     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 400
 401     DdeFreeDataHandle(hdata);
 402
 403     lstrcpyA(buffer, "[Command(Var)]");
 404     hdata = DdeCreateDataHandle(client_pid, (LPBYTE)buffer, lstrlenA(buffer) + 1,
 405                                 0, NULL, CF_TEXT, 0);
 406     ok(hdata != NULL, "Expected non-NULL hdata\n");
 407
 408     /* XTYP_EXECUTE, correct params */
 409     res = 0xdeadbeef;
 410     DdeGetLastError(client_pid);
 411     op = DdeClientTransaction((LPBYTE)hdata, -1, conversation, NULL, 0, XTYP_EXECUTE, default_timeout, &res);
 412     ret = DdeGetLastError(client_pid);
 413     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 414     ok(op == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", op);
 415     ok(res == DDE_FACK, "Expected DDE_FACK, got %d\n", res);
 416
 417     /* XTYP_EXECUTE, no data */
 418     res = 0xdeadbeef;
 419     DdeGetLastError(client_pid);
 420     op = DdeClientTransaction(NULL, 0, conversation, NULL, 0, XTYP_EXECUTE, default_timeout, &res);
 421     ret = DdeGetLastError(client_pid);
 422     ok(op == NULL, "Expected NULL, got %p\n", op);
 423     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 424     todo_wine
 425     {
 426         ok(ret == DMLERR_MEMORY_ERROR, "Expected DMLERR_MEMORY_ERROR, got %d\n", ret);
 427     }
 428
 429     /* XTYP_EXECUTE, no data, -1 size */
 430     res = 0xdeadbeef;
 431     DdeGetLastError(client_pid);
 432     op = DdeClientTransaction(NULL, -1, conversation, NULL, 0, XTYP_EXECUTE, default_timeout, &res);
 433     ret = DdeGetLastError(client_pid);
 434     ok(op == NULL, "Expected NULL, got %p\n", op);
 435     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 436     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 437
 438     DdeFreeStringHandle(client_pid, topic);
 439     DdeFreeDataHandle(hdata);
 440
 441     item = DdeCreateStringHandleA(client_pid, "executed", CP_WINANSI);
 442
 443     /* verify the execute */
 444     res = 0xdeadbeef;
 445     DdeGetLastError(client_pid);
 446     hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
 447     ret = DdeGetLastError(client_pid);
 448     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
 449     ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %d\n", res);
 450     if (hdata == NULL)
 451         ok(FALSE, "hdata is NULL\n");
 452     else
 453     {
 454         str = (LPSTR)DdeAccessData(hdata, &size);
 455         ok(!lstrcmpA(str, "command executed\r\n"), "Expected 'command executed\\r\\n', got %s\n", str);
 456         ok(size == 21, "Expected 21, got %d\n", size);
 457
 458         ret = DdeUnaccessData(hdata);
 459         ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
 460     }
 461
 462     /* invalid transactions */
 463     res = 0xdeadbeef;
 464     DdeGetLastError(client_pid);
 465     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_ADVREQ, default_timeout, &res);
 466     ret = DdeGetLastError(client_pid);
 467     ok(op == NULL, "Expected NULL, got %p\n", op);
 468     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 469     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 470
 471     res = 0xdeadbeef;
 472     DdeGetLastError(client_pid);
 473     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_CONNECT, default_timeout, &res);
 474     ret = DdeGetLastError(client_pid);
 475     ok(op == NULL, "Expected NULL, got %p\n", op);
 476     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 477     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 478
 479     res = 0xdeadbeef;
 480     DdeGetLastError(client_pid);
 481     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_CONNECT_CONFIRM, default_timeout, &res);
 482     ret = DdeGetLastError(client_pid);
 483     ok(op == NULL, "Expected NULL, got %p\n", op);
 484     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 485     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 486
 487     res = 0xdeadbeef;
 488     DdeGetLastError(client_pid);
 489     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_DISCONNECT, default_timeout, &res);
 490     ret = DdeGetLastError(client_pid);
 491     ok(op == NULL, "Expected NULL, got %p\n", op);
 492     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 493     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 494
 495     res = 0xdeadbeef;
 496     DdeGetLastError(client_pid);
 497     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_ERROR, default_timeout, &res);
 498     ret = DdeGetLastError(client_pid);
 499     ok(op == NULL, "Expected NULL, got %p\n", op);
 500     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 501     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 502
 503     res = 0xdeadbeef;
 504     DdeGetLastError(client_pid);
 505     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_MONITOR, default_timeout, &res);
 506     ret = DdeGetLastError(client_pid);
 507     ok(op == NULL, "Expected NULL, got %p\n", op);
 508     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 509     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 510
 511     res = 0xdeadbeef;
 512     DdeGetLastError(client_pid);
 513     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REGISTER, default_timeout, &res);
 514     ret = DdeGetLastError(client_pid);
 515     ok(op == NULL, "Expected NULL, got %p\n", op);
 516     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 517     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 518
 519     res = 0xdeadbeef;
 520     DdeGetLastError(client_pid);
 521     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_UNREGISTER, default_timeout, &res);
 522     ret = DdeGetLastError(client_pid);
 523     ok(op == NULL, "Expected NULL, got %p\n", op);
 524     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 525     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 526
 527     res = 0xdeadbeef;
 528     DdeGetLastError(client_pid);
 529     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_WILDCONNECT, default_timeout, &res);
 530     ret = DdeGetLastError(client_pid);
 531     ok(op == NULL, "Expected NULL, got %p\n", op);
 532     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 533     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 534
 535     res = 0xdeadbeef;
 536     DdeGetLastError(client_pid);
 537     op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_XACT_COMPLETE, default_timeout, &res);
 538     ret = DdeGetLastError(client_pid);
 539     ok(op == NULL, "Expected NULL, got %p\n", op);
 540     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
 541     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
 542
 543     DdeFreeStringHandle(client_pid, item);
 544
 545     ret = DdeDisconnect(conversation);
 546     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
 547
 548     ret = DdeUninitialize(client_pid);
 549     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
 550 }
 551
 552 static DWORD server_pid;
 553
 554 static HDDEDATA CALLBACK server_ddeml_callback(UINT uType, UINT uFmt, HCONV hconv,
 555                                                HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
 556                                                ULONG_PTR dwData1, ULONG_PTR dwData2)
 557 {
 558     char str[MAX_PATH], *ptr;
 559     HDDEDATA ret;
 560     DWORD size;
 561
 562     static int msg_index = 0;
 563     static HCONV conversation = 0;
 564
 565     msg_index++;
 566
 567     switch (uType)
 568     {
 569     case XTYP_REGISTER:
 570     {
 571         ok(msg_index == 1, "Expected 1, got %d\n", msg_index);
 572         ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
 573         ok(hconv == 0, "Expected 0, got %p\n", hconv);
 574         ok(hdata == 0, "Expected 0, got %p\n", hdata);
 575         ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
 576         ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
 577
 578         size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
 579         ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
 580         ok(size == 13, "Expected 13, got %d\n", size);
 581
 582         size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
 583         ok(!strncmp(str, "TestDDEServer(", 14), "Expected TestDDEServer(, got %s\n", str);
 584         ok(str[size - 1] == ')', "Expected ')', got %c\n", str[size - 1]);
 585         ok(size == 25, "Expected 25, got %d\n", size);
 586
 587         return (HDDEDATA)TRUE;
 588     }
 589
 590     case XTYP_CONNECT:
 591     {
 592         ok(msg_index == 2, "Expected 2, got %d\n", msg_index);
 593         ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
 594         ok(hconv == 0, "Expected 0, got %p\n", hconv);
 595         ok(hdata == 0, "Expected 0, got %p\n", hdata);
 596         ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
 597         ok(dwData2 == FALSE, "Expected FALSE, got %08lx\n", dwData2);
 598
 599         size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
 600         ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 601         ok(size == 12, "Expected 12, got %d\n", size);
 602
 603         size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
 604         ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
 605         ok(size == 13, "Expected 13, got %d\n", size);
 606
 607         return (HDDEDATA)TRUE;
 608     }
 609
 610     case XTYP_CONNECT_CONFIRM:
 611     {
 612         conversation = hconv;
 613
 614         ok(msg_index == 3, "Expected 3, got %d\n", msg_index);
 615         ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
 616         ok(hconv != NULL, "Expected non-NULL hconv\n");
 617         ok(hdata == 0, "Expected 0, got %p\n", hdata);
 618         ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
 619         ok(dwData2 == FALSE, "Expected FALSE, got %08lx\n", dwData2);
 620
 621         size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
 622         ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 623         ok(size == 12, "Expected 12, got %d\n", size);
 624
 625         size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
 626         ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
 627         ok(size == 13, "Expected 13, got %d\n", size);
 628
 629         return (HDDEDATA)TRUE;
 630     }
 631
 632     case XTYP_REQUEST:
 633     {
 634         ok(msg_index == 4 || msg_index == 5 || msg_index == 6,
 635            "Expected 4, 5 or 6, got %d\n", msg_index);
 636         ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
 637         ok(hdata == 0, "Expected 0, got %p\n", hdata);
 638         ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
 639         ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
 640
 641         if (msg_index == 4)
 642             ok(uFmt == 0xbeef, "Expected 0xbeef, got %08x\n", uFmt);
 643         else
 644             ok(uFmt == CF_TEXT, "Expected CF_TEXT, got %08x\n", uFmt);
 645
 646         size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
 647         ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 648         ok(size == 12, "Expected 12, got %d\n", size);
 649
 650         size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
 651
 652         if (msg_index == 5)
 653         {
 654             {
 655                 ok(!lstrcmpA(str, ""), "Expected empty string, got %s\n", str);
 656                 ok(size == 1, "Expected 1, got %d\n", size);
 657             }
 658         }
 659         else if (msg_index == 6)
 660         {
 661             ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
 662             ok(size == 7, "Expected 7, got %d\n", size);
 663         }
 664
 665         if (msg_index == 6)
 666         {
 667             lstrcpyA(str, "requested data\r\n");
 668             return DdeCreateDataHandle(server_pid, (LPBYTE)str, lstrlenA(str) + 1,
 669                                         0, hsz2, CF_TEXT, 0);
 670         }
 671
 672         return NULL;
 673     }
 674
 675     case XTYP_POKE:
 676     {
 677         ok(msg_index == 7 || msg_index == 8, "Expected 7 or 8, got %d\n", msg_index);
 678         ok(uFmt == CF_TEXT, "Expected CF_TEXT, got %d\n", uFmt);
 679         ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
 680         ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
 681         ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
 682
 683         size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
 684         ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 685         ok(size == 12, "Expected 12, got %d\n", size);
 686
 687         ptr = (LPSTR)DdeAccessData(hdata, &size);
 688         ok(!lstrcmpA(ptr, "poke data\r\n"), "Expected 'poke data\\r\\n', got %s\n", ptr);
 689         ok(size == 12, "Expected 12, got %d\n", size);
 690         DdeUnaccessData(hdata);
 691
 692         size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
 693         if (msg_index == 7)
 694         {
 695             {
 696                 ok(!lstrcmpA(str, ""), "Expected empty string, got %s\n", str);
 697                 ok(size == 1, "Expected 1, got %d\n", size);
 698             }
 699         }
 700         else
 701         {
 702             ok(!lstrcmpA(str, "poke"), "Expected poke, got %s\n", str);
 703             ok(size == 4, "Expected 4, got %d\n", size);
 704         }
 705
 706         return (HDDEDATA)DDE_FACK;
 707     }
 708
 709     case XTYP_EXECUTE:
 710     {
 711         ok(msg_index == 9 || msg_index == 10, "Expected 9 or 10, got %d\n", msg_index);
 712         ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
 713         ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
 714         ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
 715         ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
 716         ok(hsz2 == 0, "Expected 0, got %p\n", hsz2);
 717
 718         size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
 719         ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 720         ok(size == 12, "Expected 12, got %d\n", size);
 721
 722         ptr = (LPSTR)DdeAccessData(hdata, &size);
 723
 724         if (msg_index == 9)
 725         {
 726             ok(!lstrcmpA(ptr, "[Command(Var)]"), "Expected '[Command(Var)]', got %s\n", ptr);
 727             ok(size == 15, "Expected 15, got %d\n", size);
 728             ret = (HDDEDATA)DDE_FACK;
 729         }
 730         else
 731         {
 732             ok(!lstrcmpA(ptr, "[BadCommand(Var)]"), "Expected '[BadCommand(Var)]', got %s\n", ptr);
 733             ok(size == 18, "Expected 18, got %d\n", size);
 734             ret = (HDDEDATA)DDE_FNOTPROCESSED;
 735         }
 736
 737         DdeUnaccessData(hdata);
 738
 739         return ret;
 740     }
 741
 742     case XTYP_DISCONNECT:
 743     {
 744         ok(msg_index == 11, "Expected 11, got %d\n", msg_index);
 745         ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
 746         ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
 747         ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
 748         ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
 749         ok(hsz1 == 0, "Expected 0, got %p\n", hsz2);
 750         ok(hsz2 == 0, "Expected 0, got %p\n", hsz2);
 751
 752         return 0;
 753     }
 754
 755     default:
 756         ok(FALSE, "Unhandled msg: %08x\n", uType);
 757     }
 758
 759     return 0;
 760 }
 761
 762 static void test_ddeml_server(HANDLE hproc)
 763 {
 764     MSG msg;
 765     UINT res;
 766     BOOL ret;
 767     HSZ server;
 768     HDDEDATA hdata;
 769
 770     /* set up DDE server */
 771     server_pid = 0;
 772     res = DdeInitialize(&server_pid, server_ddeml_callback, APPCLASS_STANDARD, 0);
 773     ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
 774
 775     server = DdeCreateStringHandle(server_pid, "TestDDEServer", CP_WINANSI);
 776     ok(server != NULL, "Expected non-NULL string handle\n");
 777
 778     hdata = DdeNameService(server_pid, server, 0, DNS_REGISTER);
 779     ok(hdata == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", hdata);
 780
 781     while (MsgWaitForMultipleObjects( 1, &hproc, FALSE, INFINITE, QS_ALLINPUT ) != 0)
 782     {
 783         while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
 784     }
 785     ret = DdeUninitialize(server_pid);
 786     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
 787     GetExitCodeProcess( hproc, &res );
 788     ok( !res, "client failed with %u error(s)\n", res );
 789 }
 790
 791 static HWND client_hwnd, server_hwnd;
 792 static ATOM server, topic, item;
 793 static HGLOBAL execute_hglobal;
 794
 795 static LRESULT WINAPI dde_msg_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 796 {
 797     char str[MAX_PATH];
 798     UINT_PTR lo, hi;
 799     DDEDATA *data;
 800     DDEACK *ack;
 801     DWORD size;
 802     LPSTR ptr;
 803
 804     static int msg_index = 0;
 805
 806     if (msg < WM_DDE_FIRST || msg > WM_DDE_LAST)
 807         return DefWindowProcA(hwnd, msg, wparam, lparam);
 808
 809     msg_index++;
 810
 811     switch (msg)
 812     {
 813     case WM_DDE_INITIATE:
 814     {
 815         ok(msg_index == 1, "Expected 1, got %d\n", msg_index);
 816         ok(wparam == (WPARAM)client_hwnd, "Expected client hwnd, got %08lx\n", wparam);
 817
 818         size = GlobalGetAtomNameA(LOWORD(lparam), str, MAX_PATH);
 819         ok(LOWORD(lparam) == server, "Expected server atom, got %08x\n", LOWORD(lparam));
 820         ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
 821         ok(size == 13, "Expected 13, got %d\n", size);
 822
 823         size = GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
 824         ok(HIWORD(lparam) == topic, "Expected topic atom, got %08x\n", HIWORD(lparam));
 825         ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 826         ok(size == 12, "Expected 12, got %d\n", size);
 827
 828         break;
 829     }
 830
 831     case WM_DDE_ACK:
 832     {
 833         ok((msg_index >= 2 && msg_index <= 4) || (msg_index >= 6 && msg_index <= 10),
 834            "Expected 2, 3, 4, 6, 7, 8, 9 or 10, got %d\n", msg_index);
 835
 836         if (msg_index == 2)
 837         {
 838             server_hwnd = (HWND)wparam;
 839             ok(wparam != 0, "Expected non-NULL wparam, got %08lx\n", wparam);
 840
 841             size = GlobalGetAtomNameA(LOWORD(lparam), str, MAX_PATH);
 842             ok(LOWORD(lparam) == server, "Expected server atom, got %08x\n", LOWORD(lparam));
 843             ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
 844             ok(size == 13, "Expected 13, got %d\n", size);
 845
 846             size = GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
 847             ok(HIWORD(lparam) == topic, "Expected topic atom, got %08x\n", HIWORD(lparam));
 848             ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
 849             ok(size == 12, "Expected 12, got %d\n", size);
 850         }
 851         else if (msg_index == 9 || msg_index == 10)
 852         {
 853             ok(wparam == (WPARAM)server_hwnd, "Expected server hwnd, got %08lx\n", wparam);
 854
 855             UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
 856
 857             ack = (DDEACK *)&lo;
 858             ok(ack->bAppReturnCode == 0, "Expected 0, got %d\n", ack->bAppReturnCode);
 859             ok(ack->reserved == 0, "Expected 0, got %d\n", ack->reserved);
 860             ok(ack->fBusy == FALSE, "Expected FALSE, got %d\n", ack->fBusy);
 861
 862             ok(hi == (UINT_PTR)execute_hglobal, "Execpted execute hglobal, got %08lx\n", hi);
 863             ptr = GlobalLock((HGLOBAL)hi);
 864
 865             if (msg_index == 9)
 866             {
 867                 ok(ack->fAck == TRUE, "Expected TRUE, got %d\n", ack->fAck);
 868                 ok(!lstrcmpA(ptr, "[Command(Var)]"), "Expected '[Command(Var)]', got %s\n", ptr);
 869             }
 870             else
 871             {
 872                 ok(ack->fAck == FALSE, "Expected FALSE, got %d\n", ack->fAck);
 873                 ok(!lstrcmpA(ptr, "[BadCommand(Var)]"), "Expected '[BadCommand(Var)]', got %s\n", ptr);
 874             }
 875
 876             GlobalUnlock((HGLOBAL)hi);
 877         }
 878         else
 879         {
 880             ok(wparam == (WPARAM)server_hwnd, "Expected server hwnd, got %08lx\n", wparam);
 881
 882             UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
 883
 884             ack = (DDEACK *)&lo;
 885             ok(ack->bAppReturnCode == 0, "Expected 0, got %d\n", ack->bAppReturnCode);
 886             ok(ack->reserved == 0, "Expected 0, got %d\n", ack->reserved);
 887             ok(ack->fBusy == FALSE, "Expected FALSE, got %d\n", ack->fBusy);
 888
 889             if (msg_index >= 7)
 890                 ok(ack->fAck == TRUE, "Expected TRUE, got %d\n", ack->fAck);
 891             else
 892             {
 893                 if (msg_index == 6) todo_wine
 894                 ok(ack->fAck == FALSE, "Expected FALSE, got %d\n", ack->fAck);
 895             }
 896
 897             size = GlobalGetAtomNameA(hi, str, MAX_PATH);
 898             if (msg_index == 3)
 899             {
 900                 ok(hi == item, "Expected item atom, got %08lx\n", hi);
 901                 ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
 902                 ok(size == 7, "Expected 7, got %d\n", size);
 903             }
 904             else if (msg_index == 4 || msg_index == 7)
 905             {
 906                 ok(hi == 0, "Expected 0, got %08lx\n", hi);
 907                 ok(size == 0, "Expected empty string, got %d\n", size);
 908             }
 909             else
 910             {
 911                 ok(hi == item, "Expected item atom, got %08lx\n", hi);
 912                 if (msg_index == 6) todo_wine
 913                 {
 914                     ok(!lstrcmpA(str, "poke"), "Expected poke, got %s\n", str);
 915                     ok(size == 4, "Expected 4, got %d\n", size);
 916                 }
 917             }
 918         }
 919
 920         break;
 921     }
 922
 923     case WM_DDE_DATA:
 924     {
 925         ok(msg_index == 5, "Expected 5, got %d\n", msg_index);
 926         ok(wparam == (WPARAM)server_hwnd, "Expected server hwnd, got %08lx\n", wparam);
 927
 928         UnpackDDElParam(WM_DDE_DATA, lparam, &lo, &hi);
 929
 930         data = GlobalLock((HGLOBAL)lo);
 931         ok(data->unused == 0, "Expected 0, got %d\n", data->unused);
 932         ok(data->fResponse == TRUE, "Expected TRUE, got %d\n", data->fResponse);
 933         todo_wine
 934         {
 935             ok(data->fRelease == TRUE, "Expected TRUE, got %d\n", data->fRelease);
 936         }
 937         ok(data->fAckReq == 0, "Expected 0, got %d\n", data->fAckReq);
 938         ok(data->cfFormat == CF_TEXT, "Expected CF_TEXT, got %d\n", data->cfFormat);
 939         ok(!lstrcmpA((LPSTR)data->Value, "requested data\r\n"),
 940            "Expeted 'requested data\\r\\n', got %s\n", data->Value);
 941         GlobalUnlock((HGLOBAL)lo);
 942
 943         size = GlobalGetAtomNameA(hi, str, MAX_PATH);
 944         ok(hi == item, "Expected item atom, got %08x\n", HIWORD(lparam));
 945         ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
 946         ok(size == 7, "Expected 7, got %d\n", size);
 947
 948         GlobalFree((HGLOBAL)lo);
 949         GlobalDeleteAtom(hi);
 950
 951         break;
 952     }
 953
 954     default:
 955         ok(FALSE, "Unhandled msg: %08x\n", msg);
 956     }
 957
 958     return DefWindowProcA(hwnd, msg, wparam, lparam);
 959 }
 960
 961 static HGLOBAL create_poke()
 962 {
 963     HGLOBAL hglobal;
 964     DDEPOKE *poke;
 965     DWORD size;
 966
 967     size = FIELD_OFFSET(DDEPOKE, Value[sizeof("poke data\r\n")]);
 968     hglobal = GlobalAlloc(GMEM_DDESHARE, size);
 969     ok(hglobal != 0, "Expected non-NULL hglobal\n");
 970
 971     poke = GlobalLock(hglobal);
 972     poke->unused = 0;
 973     poke->fRelease = TRUE;
 974     poke->fReserved = TRUE;
 975     poke->cfFormat = CF_TEXT;
 976     lstrcpyA((LPSTR)poke->Value, "poke data\r\n");
 977     GlobalUnlock(hglobal);
 978
 979     return hglobal;
 980 }
 981
 982 static HGLOBAL create_execute(LPCSTR command)
 983 {
 984     HGLOBAL hglobal;
 985     LPSTR ptr;
 986
 987     hglobal = GlobalAlloc(GMEM_DDESHARE, lstrlenA(command) + 1);
 988     ok(hglobal != 0, "Expected non-NULL hglobal\n");
 989
 990     ptr = GlobalLock(hglobal);
 991     lstrcpyA(ptr, command);
 992     GlobalUnlock(hglobal);
 993
 994     return hglobal;
 995 }
 996
 997 static void test_msg_client()
 998 {
 999     HGLOBAL hglobal;
1000     LPARAM lparam;
1001
1002     create_dde_window(&client_hwnd, "dde_client", dde_msg_client_wndproc);
1003
1004     server = GlobalAddAtomA("TestDDEServer");
1005     ok(server != 0, "Expected non-NULL server\n");
1006
1007     topic = GlobalAddAtomA("TestDDETopic");
1008     ok(topic != 0, "Expected non-NULL topic\n");
1009
1010     SendMessageA(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)client_hwnd, MAKELONG(server, topic));
1011
1012     GlobalDeleteAtom(server);
1013     GlobalDeleteAtom(topic);
1014
1015     flush_events();
1016
1017     item = GlobalAddAtom("request");
1018     ok(item != 0, "Expected non-NULL item\n");
1019
1020     /* WM_DDE_REQUEST, bad clipboard format */
1021     lparam = PackDDElParam(WM_DDE_REQUEST, 0xdeadbeef, item);
1022     PostMessageA(server_hwnd, WM_DDE_REQUEST, (WPARAM)client_hwnd, lparam);
1023
1024     flush_events();
1025
1026     /* WM_DDE_REQUEST, no item */
1027     lparam = PackDDElParam(WM_DDE_REQUEST, CF_TEXT, 0);
1028     PostMessageA(server_hwnd, WM_DDE_REQUEST, (WPARAM)client_hwnd, lparam);
1029
1030     flush_events();
1031
1032     /* WM_DDE_REQUEST, no client hwnd */
1033     lparam = PackDDElParam(WM_DDE_REQUEST, CF_TEXT, item);
1034     PostMessageA(server_hwnd, WM_DDE_REQUEST, 0, lparam);
1035
1036     flush_events();
1037
1038     /* WM_DDE_REQUEST, correct params */
1039     lparam = PackDDElParam(WM_DDE_REQUEST, CF_TEXT, item);
1040     PostMessageA(server_hwnd, WM_DDE_REQUEST, (WPARAM)client_hwnd, lparam);
1041
1042     flush_events();
1043
1044     GlobalDeleteAtom(item);
1045     item = GlobalAddAtomA("poke");
1046     ok(item != 0, "Expected non-NULL item\n");
1047
1048     hglobal = create_poke();
1049
1050     /* WM_DDE_POKE, no ddepoke */
1051     lparam = PackDDElParam(WM_DDE_POKE, 0, item);
1052     PostMessageA(server_hwnd, WM_DDE_POKE, (WPARAM)client_hwnd, lparam);
1053
1054     flush_events();
1055
1056     /* WM_DDE_POKE, no item */
1057     lparam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)hglobal, 0);
1058     PostMessageA(server_hwnd, WM_DDE_POKE, (WPARAM)client_hwnd, lparam);
1059
1060     flush_events();
1061
1062     hglobal = create_poke();
1063
1064     /* WM_DDE_POKE, no client hwnd */
1065     lparam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)hglobal, item);
1066     PostMessageA(server_hwnd, WM_DDE_POKE, 0, lparam);
1067
1068     flush_events();
1069
1070     /* WM_DDE_POKE, all params correct */
1071     lparam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)hglobal, item);
1072     PostMessageA(server_hwnd, WM_DDE_POKE, (WPARAM)client_hwnd, lparam);
1073
1074     flush_events();
1075
1076     execute_hglobal = create_execute("[Command(Var)]");
1077
1078     /* WM_DDE_EXECUTE, no lparam */
1079     PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, 0);
1080
1081     flush_events();
1082
1083     /* WM_DDE_EXECUTE, no hglobal */
1084     lparam = PackDDElParam(WM_DDE_EXECUTE, 0, 0);
1085     PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, lparam);
1086
1087     flush_events();
1088
1089     /* WM_DDE_EXECUTE, no client hwnd */
1090     lparam = PackDDElParam(WM_DDE_EXECUTE, 0, (UINT_PTR)execute_hglobal);
1091     PostMessageA(server_hwnd, WM_DDE_EXECUTE, 0, lparam);
1092
1093     flush_events();
1094
1095     /* WM_DDE_EXECUTE, all params correct */
1096     lparam = PackDDElParam(WM_DDE_EXECUTE, 0, (UINT_PTR)execute_hglobal);
1097     PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, lparam);
1098
1099     flush_events();
1100
1101     GlobalFree(execute_hglobal);
1102     execute_hglobal = create_execute("[BadCommand(Var)]");
1103
1104     /* WM_DDE_EXECUTE that will get rejected */
1105     lparam = PackDDElParam(WM_DDE_EXECUTE, 0, (UINT_PTR)execute_hglobal);
1106     PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, lparam);
1107
1108     flush_events();
1109
1110     DestroyWindow(client_hwnd);
1111 }
1112
1113 static LRESULT WINAPI hook_dde_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1114 {
1115     UINT_PTR lo, hi;
1116
1117     trace("hook_dde_client_wndproc: %p %04x %08lx %08lx\n", hwnd, msg, wparam, lparam);
1118
1119     switch (msg)
1120     {
1121     case WM_DDE_ACK:
1122         UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
1123         trace("WM_DDE_ACK: status %04lx hglobal %p\n", lo, (HGLOBAL)hi);
1124         break;
1125
1126     default:
1127         break;
1128     }
1129     return CallWindowProcA(old_dde_client_wndproc, hwnd, msg, wparam, lparam);
1130 }
1131
1132 static LRESULT WINAPI dde_server_wndprocW(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1133 {
1134     trace("dde_server_wndprocW: %p %04x %08lx %08lx\n", hwnd, msg, wparam, lparam);
1135
1136     switch (msg)
1137     {
1138     case WM_DDE_INITIATE:
1139     {
1140         ATOM aService = GlobalAddAtomW(TEST_DDE_SERVICE);
1141
1142         trace("server: got WM_DDE_INITIATE from %p with %08lx\n", (HWND)wparam, lparam);
1143
1144         if (LOWORD(lparam) == aService)
1145         {
1146             ok(!IsWindowUnicode((HWND)wparam), "client should be an ANSI window\n");
1147             old_dde_client_wndproc = (WNDPROC)SetWindowLongPtrA((HWND)wparam, GWLP_WNDPROC, (ULONG_PTR)hook_dde_client_wndproc);
1148             trace("server: sending WM_DDE_ACK to %p\n", (HWND)wparam);
1149             SendMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, MAKELPARAM(aService, 0));
1150         }
1151         else
1152             GlobalDeleteAtom(aService);
1153         return 0;
1154     }
1155
1156     case WM_DDE_EXECUTE:
1157     {
1158         DDEACK ack;
1159         WORD status;
1160         LPCSTR cmd;
1161         UINT_PTR lo, hi;
1162
1163         trace("server: got WM_DDE_EXECUTE from %p with %08lx\n", (HWND)wparam, lparam);
1164
1165         UnpackDDElParam(WM_DDE_EXECUTE, lparam, &lo, &hi);
1166         trace("%08lx => lo %04lx hi %04lx\n", lparam, lo, hi);
1167
1168         ack.bAppReturnCode = 0;
1169         ack.reserved = 0;
1170         ack.fBusy = 0;
1171
1172         cmd = GlobalLock((HGLOBAL)hi);
1173
1174         if (!cmd || (lstrcmpA(cmd, exec_cmdA) && lstrcmpW((LPCWSTR)cmd, exec_cmdW)))
1175         {
1176             trace("ignoring unknown WM_DDE_EXECUTE command\n");
1177             /* We have to send a negative acknowledge even if we don't
1178              * accept the command, otherwise Windows goes mad and next time
1179              * we send an acknowledge DDEML drops the connection.
1180              * Not sure how to call it: a bug or a feature.
1181              */
1182             ack.fAck = 0;
1183         }
1184         else
1185             ack.fAck = 1;
1186         GlobalUnlock((HGLOBAL)hi);
1187
1188         trace("server: posting %s WM_DDE_ACK to %p\n", ack.fAck ? "POSITIVE" : "NEGATIVE", (HWND)wparam);
1189
1190         status = *((WORD *)&ack);
1191         lparam = ReuseDDElParam(lparam, WM_DDE_EXECUTE, WM_DDE_ACK, status, hi);
1192
1193         PostMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, lparam);
1194         return 0;
1195     }
1196
1197     case WM_DDE_TERMINATE:
1198     {
1199         DDEACK ack;
1200         WORD status;
1201
1202         trace("server: got WM_DDE_TERMINATE from %p with %08lx\n", (HWND)wparam, lparam);
1203
1204         ack.bAppReturnCode = 0;
1205         ack.reserved = 0;
1206         ack.fBusy = 0;
1207         ack.fAck = 1;
1208
1209         trace("server: posting %s WM_DDE_ACK to %p\n", ack.fAck ? "POSITIVE" : "NEGATIVE", (HWND)wparam);
1210
1211         status = *((WORD *)&ack);
1212         lparam = PackDDElParam(WM_DDE_ACK, status, 0);
1213
1214         PostMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, lparam);
1215         return 0;
1216     }
1217
1218     default:
1219         break;
1220     }
1221
1222     return DefWindowProcW(hwnd, msg, wparam, lparam);
1223 }
1224
1225 static LRESULT WINAPI dde_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1226 {
1227     return DefWindowProcA(hwnd, msg, wparam, lparam);
1228 }
1229
1230 static BOOL create_dde_windows(HWND *client, HWND *server)
1231 {
1232     WNDCLASSA wcA;
1233     WNDCLASSW wcW;
1234     static const WCHAR server_class_name[] = {'d','d','e','_','s','e','r','v','e','r','_','w','i','n','d','o','w',0};
1235     static const char client_class_name[] = "dde_client_window";
1236
1237     memset(&wcW, 0, sizeof(wcW));
1238     wcW.lpfnWndProc = dde_server_wndprocW;
1239     wcW.lpszClassName = server_class_name;
1240     wcW.hInstance = GetModuleHandleA(0);
1241     if (!RegisterClassW(&wcW)) return FALSE;
1242
1243     memset(&wcA, 0, sizeof(wcA));
1244     wcA.lpfnWndProc = dde_client_wndproc;
1245     wcA.lpszClassName = client_class_name;
1246     wcA.hInstance = GetModuleHandleA(0);
1247     assert(RegisterClassA(&wcA));
1248
1249     *server = CreateWindowExW(0, server_class_name, NULL,
1250                               WS_POPUP,
1251                               100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
1252                               GetDesktopWindow(), 0,
1253                               GetModuleHandleA(0), NULL);
1254     assert(*server);
1255
1256     *client = CreateWindowExA(0, client_class_name, NULL,
1257                               WS_POPUP,
1258                               100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
1259                               GetDesktopWindow(), 0,
1260                               GetModuleHandleA(0), NULL);
1261     assert(*client);
1262
1263     trace("server hwnd %p, client hwnd %p\n", *server, *client);
1264
1265     ok(IsWindowUnicode(*server), "server has to be a unicode window\n");
1266     ok(!IsWindowUnicode(*client), "client has to be an ANSI window\n");
1267
1268     return TRUE;
1269 }
1270
1271 static HDDEDATA CALLBACK client_dde_callback(UINT uType, UINT uFmt, HCONV hconv,
1272                                      HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
1273                                      ULONG_PTR dwData1, ULONG_PTR dwData2)
1274 {
1275     static const char * const cmd_type[15] = {
1276         "XTYP_ERROR", "XTYP_ADVDATA", "XTYP_ADVREQ", "XTYP_ADVSTART",
1277         "XTYP_ADVSTOP", "XTYP_EXECUTE", "XTYP_CONNECT", "XTYP_CONNECT_CONFIRM",
1278         "XTYP_XACT_COMPLETE", "XTYP_POKE", "XTYP_REGISTER", "XTYP_REQUEST",
1279         "XTYP_DISCONNECT", "XTYP_UNREGISTER", "XTYP_WILDCONNECT" };
1280     UINT type;
1281     const char *cmd_name;
1282
1283     type = (uType & XTYP_MASK) >> XTYP_SHIFT;
1284     cmd_name = (type <= 14) ? cmd_type[type] : "unknown";
1285
1286     trace("client_dde_callback: %04x (%s) %d %p %p %p %p %08lx %08lx\n",
1287           uType, cmd_name, uFmt, hconv, hsz1, hsz2, hdata, dwData1, dwData2);
1288     return 0;
1289 }
1290
1291 static void test_dde_aw_transaction(void)
1292 {
1293     HSZ hsz_server;
1294     DWORD dde_inst, ret, err;
1295     HCONV hconv;
1296     HWND hwnd_client, hwnd_server;
1297     CONVINFO info;
1298     HDDEDATA hdata;
1299     static char test_cmd[] = "test dde command";
1300
1301     /* server: unicode, client: ansi */
1302     if (!create_dde_windows(&hwnd_client, &hwnd_server)) return;
1303
1304     dde_inst = 0;
1305     ret = DdeInitializeA(&dde_inst, client_dde_callback, APPCMD_CLIENTONLY, 0);
1306     ok(ret == DMLERR_NO_ERROR, "DdeInitializeW failed with error %04x (%x)\n",
1307        ret, DdeGetLastError(dde_inst));
1308
1309     hsz_server = DdeCreateStringHandleW(dde_inst, TEST_DDE_SERVICE, CP_WINUNICODE);
1310
1311     hconv = DdeConnect(dde_inst, hsz_server, 0, NULL);
1312     ok(hconv != 0, "DdeConnect error %x\n", DdeGetLastError(dde_inst));
1313     err = DdeGetLastError(dde_inst);
1314     ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
1315
1316     info.cb = sizeof(info);
1317     ret = DdeQueryConvInfo(hconv, QID_SYNC, &info);
1318     ok(ret, "wrong info size %d, DdeQueryConvInfo error %x\n", ret, DdeGetLastError(dde_inst));
1319     /* should be CP_WINANSI since we used DdeInitializeA */
1320     ok(info.ConvCtxt.iCodePage == CP_WINANSI, "wrong iCodePage %d\n", info.ConvCtxt.iCodePage);
1321     ok(!info.hConvPartner, "unexpected info.hConvPartner: %p\n", info.hConvPartner);
1322 todo_wine {
1323     ok((info.wStatus & DDE_FACK), "unexpected info.wStatus: %04x\n", info.wStatus);
1324 }
1325     ok((info.wStatus & (ST_CONNECTED | ST_CLIENT)) == (ST_CONNECTED | ST_CLIENT), "unexpected info.wStatus: %04x\n", info.wStatus);
1326     ok(info.wConvst == XST_CONNECTED, "unexpected info.wConvst: %04x\n", info.wConvst);
1327     ok(info.wType == 0, "unexpected info.wType: %04x\n", info.wType);
1328
1329     trace("hwnd %p, hwndPartner %p\n", info.hwnd, info.hwndPartner);
1330
1331     trace("sending test client transaction command\n");
1332     ret = 0xdeadbeef;
1333     hdata = DdeClientTransaction((LPBYTE)test_cmd, strlen(test_cmd) + 1, hconv, (HSZ)0xdead, 0xbeef, XTYP_EXECUTE, 1000, &ret);
1334     ok(!hdata, "DdeClientTransaction succeeded\n");
1335     ok(ret == DDE_FNOTPROCESSED, "wrong status code %04x\n", ret);
1336     err = DdeGetLastError(dde_inst);
1337     ok(err == DMLERR_NOTPROCESSED, "wrong dde error %x\n", err);
1338
1339     trace("sending ANSI client transaction command\n");
1340     ret = 0xdeadbeef;
1341     hdata = DdeClientTransaction((LPBYTE)exec_cmdA, lstrlenA(exec_cmdA) + 1, hconv, 0, 0, XTYP_EXECUTE, 1000, &ret);
1342     ok(hdata != 0, "DdeClientTransaction returned %p, error %x\n", hdata, DdeGetLastError(dde_inst));
1343     ok(ret == DDE_FACK, "wrong status code %04x\n", ret);
1344
1345     err = DdeGetLastError(dde_inst);
1346     ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
1347
1348     trace("sending unicode client transaction command\n");
1349     ret = 0xdeadbeef;
1350     hdata = DdeClientTransaction((LPBYTE)exec_cmdW, (lstrlenW(exec_cmdW) + 1) * sizeof(WCHAR), hconv, 0, 0, XTYP_EXECUTE, 1000, &ret);
1351     ok(hdata != 0, "DdeClientTransaction returned %p, error %x\n", hdata, DdeGetLastError(dde_inst));
1352     ok(ret == DDE_FACK, "wrong status code %04x\n", ret);
1353     err = DdeGetLastError(dde_inst);
1354     ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
1355
1356     ok(DdeDisconnect(hconv), "DdeDisconnect error %x\n", DdeGetLastError(dde_inst));
1357
1358     info.cb = sizeof(info);
1359     ret = DdeQueryConvInfo(hconv, QID_SYNC, &info);
1360     ok(!ret, "DdeQueryConvInfo should fail\n");
1361     err = DdeGetLastError(dde_inst);
1362 todo_wine {
1363     ok(err == DMLERR_INVALIDPARAMETER, "wrong dde error %x\n", err);
1364 }
1365
1366     ok(DdeFreeStringHandle(dde_inst, hsz_server), "DdeFreeStringHandle error %x\n", DdeGetLastError(dde_inst));
1367
1368     /* This call hangs on win2k SP4 and XP SP1.
1369     DdeUninitialize(dde_inst);*/
1370
1371     DestroyWindow(hwnd_client);
1372     DestroyWindow(hwnd_server);
1373 }
1374
1375 static void test_initialisation(void)
1376 {
1377     UINT ret;
1378     DWORD res;
1379     HDDEDATA hdata;
1380     HSZ server, topic, item;
1381     DWORD client_pid;
1382     HCONV conversation;
1383
1384     /* Initialise without a valid server window. */
1385     client_pid = 0;
1386     ret = DdeInitializeA(&client_pid, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1387     ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
1388
1389
1390     server = DdeCreateStringHandleA(client_pid, "TestDDEService", CP_WINANSI);
1391     topic = DdeCreateStringHandleA(client_pid, "TestDDETopic", CP_WINANSI);
1392
1393     DdeGetLastError(client_pid);
1394
1395     /* There is no server window so no conversation can be extracted */
1396     conversation = DdeConnect(client_pid, server, topic, NULL);
1397     ok(conversation == NULL, "Expected NULL conversation, %p\n", conversation);
1398     ret = DdeGetLastError(client_pid);
1399     ok(ret == DMLERR_NO_CONV_ESTABLISHED, "Expected DMLERR_NO_CONV_ESTABLISHED, got %d\n", ret);
1400
1401     DdeFreeStringHandle(client_pid, server);
1402
1403     item = DdeCreateStringHandleA(client_pid, "request", CP_WINANSI);
1404
1405     /* There is no converstation so an invalild parameter results */
1406     res = 0xdeadbeef;
1407     DdeGetLastError(client_pid);
1408     hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
1409     ret = DdeGetLastError(client_pid);
1410 todo_wine
1411     ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
1412     ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %08x\n", res);
1413
1414     DdeFreeStringHandle(client_pid, server);
1415     ret = DdeDisconnect(conversation);
1416     ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
1417
1418     ret = DdeUninitialize(client_pid);
1419     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1420 }
1421
1422 static void test_DdeCreateStringHandleW(DWORD dde_inst, int codepage)
1423 {
1424     static const WCHAR dde_string[] = {'D','D','E',' ','S','t','r','i','n','g',0};
1425     HSZ str_handle;
1426     WCHAR bufW[256];
1427     char buf[256];
1428     ATOM atom;
1429     int ret;
1430
1431     str_handle = DdeCreateStringHandleW(dde_inst, dde_string, codepage);
1432     ok(str_handle != 0, "DdeCreateStringHandleW failed with error %08x\n",
1433        DdeGetLastError(dde_inst));
1434
1435     ret = DdeQueryStringW(dde_inst, str_handle, NULL, 0, codepage);
1436     if (codepage == CP_WINANSI)
1437         ok(ret == 1, "DdeQueryStringW returned wrong length %d\n", ret);
1438     else
1439         ok(ret == lstrlenW(dde_string), "DdeQueryStringW returned wrong length %d\n", ret);
1440
1441     ret = DdeQueryStringW(dde_inst, str_handle, bufW, 256, codepage);
1442     if (codepage == CP_WINANSI)
1443     {
1444         ok(ret == 1, "DdeQueryStringW returned wrong length %d\n", ret);
1445         ok(!lstrcmpA("D", (LPCSTR)bufW), "DdeQueryStringW returned wrong string\n");
1446     }
1447     else
1448     {
1449         ok(ret == lstrlenW(dde_string), "DdeQueryStringW returned wrong length %d\n", ret);
1450         ok(!lstrcmpW(dde_string, bufW), "DdeQueryStringW returned wrong string\n");
1451     }
1452
1453     ret = DdeQueryStringA(dde_inst, str_handle, buf, 256, CP_WINANSI);
1454     if (codepage == CP_WINANSI)
1455     {
1456         ok(ret == 1, "DdeQueryStringA returned wrong length %d\n", ret);
1457         ok(!lstrcmpA("D", buf), "DdeQueryStringW returned wrong string\n");
1458     }
1459     else
1460     {
1461         ok(ret == lstrlenA("DDE String"), "DdeQueryStringA returned wrong length %d\n", ret);
1462         ok(!lstrcmpA("DDE String", buf), "DdeQueryStringA returned wrong string %s\n", buf);
1463     }
1464
1465     ret = DdeQueryStringA(dde_inst, str_handle, buf, 256, CP_WINUNICODE);
1466     if (codepage == CP_WINANSI)
1467     {
1468         ok(ret == 1, "DdeQueryStringA returned wrong length %d\n", ret);
1469         ok(!lstrcmpA("D", buf), "DdeQueryStringA returned wrong string %s\n", buf);
1470     }
1471     else
1472     {
1473         ok(ret == lstrlenA("DDE String"), "DdeQueryStringA returned wrong length %d\n", ret);
1474         ok(!lstrcmpW(dde_string, (LPCWSTR)buf), "DdeQueryStringW returned wrong string\n");
1475     }
1476
1477     if (codepage == CP_WINANSI)
1478     {
1479         atom = FindAtomA((LPSTR)dde_string);
1480         ok(atom != 0, "Expected a valid atom\n");
1481
1482         SetLastError(0xdeadbeef);
1483         atom = GlobalFindAtomA((LPSTR)dde_string);
1484         ok(atom == 0, "Expected 0, got %d\n", atom);
1485         ok(GetLastError() == ERROR_FILE_NOT_FOUND,
1486            "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
1487     }
1488     else
1489     {
1490         atom = FindAtomW(dde_string);
1491         ok(atom != 0, "Expected a valid atom\n");
1492
1493         SetLastError(0xdeadbeef);
1494         atom = GlobalFindAtomW(dde_string);
1495         ok(atom == 0, "Expected 0, got %d\n", atom);
1496         ok(GetLastError() == ERROR_FILE_NOT_FOUND,
1497            "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
1498     }
1499
1500     ok(DdeFreeStringHandle(dde_inst, str_handle), "DdeFreeStringHandle failed\n");
1501 }
1502
1503 static void test_DdeCreateDataHandle(void)
1504 {
1505     HDDEDATA hdata;
1506     DWORD dde_inst;
1507     DWORD size;
1508     UINT res, err;
1509     BOOL ret;
1510     HSZ item;
1511     LPBYTE ptr;
1512
1513     dde_inst = 0;
1514     res = DdeInitializeA(&dde_inst, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1515     ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
1516
1517     item = DdeCreateStringHandleA(dde_inst, "item", CP_WINANSI);
1518     ok(item != NULL, "Expected non-NULL hsz\n");
1519
1520     /* invalid instance id */
1521     DdeGetLastError(dde_inst);
1522     hdata = DdeCreateDataHandle(0xdeadbeef, (LPBYTE)"data", MAX_PATH, 0, item, CF_TEXT, 0);
1523     err = DdeGetLastError(dde_inst);
1524     todo_wine
1525     {
1526         ok(hdata == NULL, "Expected NULL, got %p\n", hdata);
1527         ok(err == DMLERR_INVALIDPARAMETER,
1528            "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1529     }
1530
1531     /* 0 instance id */
1532     DdeGetLastError(dde_inst);
1533     hdata = DdeCreateDataHandle(0, (LPBYTE)"data", MAX_PATH, 0, item, CF_TEXT, 0);
1534     err = DdeGetLastError(dde_inst);
1535     todo_wine
1536     {
1537         ok(hdata == NULL, "Expected NULL, got %p\n", hdata);
1538         ok(err == DMLERR_INVALIDPARAMETER,
1539            "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1540     }
1541
1542     /* NULL pSrc */
1543     DdeGetLastError(dde_inst);
1544     hdata = DdeCreateDataHandle(dde_inst, NULL, MAX_PATH, 0, item, CF_TEXT, 0);
1545     err = DdeGetLastError(dde_inst);
1546     ok(hdata != NULL, "Expected non-NULL hdata\n");
1547     ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1548
1549     ptr = GlobalLock(hdata);
1550     todo_wine
1551     {
1552         ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1553     }
1554
1555     ptr = DdeAccessData(hdata, &size);
1556     ok(ptr != NULL, "Expected non-NULL ptr\n");
1557     ok(size == 260, "Expected 260, got %d\n", size);
1558
1559     ret = DdeUnaccessData(hdata);
1560     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1561
1562     ret = DdeFreeDataHandle(hdata);
1563     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1564
1565     /* cb is zero */
1566     DdeGetLastError(dde_inst);
1567     hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", 0, 0, item, CF_TEXT, 0);
1568     err = DdeGetLastError(dde_inst);
1569     ok(hdata != NULL, "Expected non-NULL hdata\n");
1570     ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1571
1572     ptr = GlobalLock(hdata);
1573     todo_wine
1574     {
1575         ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1576     }
1577
1578     ptr = DdeAccessData(hdata, &size);
1579     ok(ptr != NULL, "Expected non-NULL ptr\n");
1580     ok(size == 0, "Expected 0, got %d\n", size);
1581
1582     ret = DdeUnaccessData(hdata);
1583     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1584
1585     ret = DdeFreeDataHandle(hdata);
1586     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1587
1588     /* cbOff is non-zero */
1589     DdeGetLastError(dde_inst);
1590     hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 2, item, CF_TEXT, 0);
1591     err = DdeGetLastError(dde_inst);
1592     ok(hdata != NULL, "Expected non-NULL hdata\n");
1593     ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1594
1595     ptr = GlobalLock(hdata);
1596     todo_wine
1597     {
1598         ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1599     }
1600
1601     ptr = DdeAccessData(hdata, &size);
1602     ok(ptr != NULL, "Expected non-NULL ptr\n");
1603     ok(size == 262, "Expected 262, got %d\n", size);
1604     todo_wine
1605     {
1606         ok(lstrlenA((LPSTR)ptr) == 0, "Expected 0, got %d\n", lstrlenA((LPSTR)ptr));
1607     }
1608
1609     ret = DdeUnaccessData(hdata);
1610     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1611
1612     ret = DdeFreeDataHandle(hdata);
1613     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1614
1615     /* NULL item */
1616     DdeGetLastError(dde_inst);
1617     hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 0, 0, CF_TEXT, 0);
1618     err = DdeGetLastError(dde_inst);
1619     ok(hdata != NULL, "Expected non-NULL hdata\n");
1620     ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1621
1622     ptr = GlobalLock(hdata);
1623     todo_wine
1624     {
1625         ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1626     }
1627
1628     ptr = DdeAccessData(hdata, &size);
1629     ok(ptr != NULL, "Expected non-NULL ptr\n");
1630     ok(!lstrcmpA((LPSTR)ptr, "data"), "Expected data, got %s\n", ptr);
1631     ok(size == 260, "Expected 260, got %d\n", size);
1632
1633     ret = DdeUnaccessData(hdata);
1634     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1635
1636     ret = DdeFreeDataHandle(hdata);
1637     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1638
1639     /* NULL item */
1640     DdeGetLastError(dde_inst);
1641     hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 0, (HSZ)0xdeadbeef, CF_TEXT, 0);
1642     err = DdeGetLastError(dde_inst);
1643     ok(hdata != NULL, "Expected non-NULL hdata\n");
1644     ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1645
1646     ptr = GlobalLock(hdata);
1647     todo_wine
1648     {
1649         ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1650     }
1651
1652     ptr = DdeAccessData(hdata, &size);
1653     ok(ptr != NULL, "Expected non-NULL ptr\n");
1654     ok(!lstrcmpA((LPSTR)ptr, "data"), "Expected data, got %s\n", ptr);
1655     ok(size == 260, "Expected 260, got %d\n", size);
1656
1657     ret = DdeUnaccessData(hdata);
1658     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1659
1660     ret = DdeFreeDataHandle(hdata);
1661     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1662
1663     /* invalid clipboard format */
1664     DdeGetLastError(dde_inst);
1665     hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 0, item, 0xdeadbeef, 0);
1666     err = DdeGetLastError(dde_inst);
1667     ok(hdata != NULL, "Expected non-NULL hdata\n");
1668     ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1669
1670     ptr = GlobalLock(hdata);
1671     todo_wine
1672     {
1673         ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1674     }
1675
1676     ptr = DdeAccessData(hdata, &size);
1677     ok(ptr != NULL, "Expected non-NULL ptr\n");
1678     ok(!lstrcmpA((LPSTR)ptr, "data"), "Expected data, got %s\n", ptr);
1679     ok(size == 260, "Expected 260, got %d\n", size);
1680
1681     ret = DdeUnaccessData(hdata);
1682     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1683
1684     ret = DdeFreeDataHandle(hdata);
1685     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1686
1687     ret = DdeUninitialize(dde_inst);
1688     ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
1689 }
1690
1691 static void test_DdeCreateStringHandle(void)
1692 {
1693     DWORD dde_inst, ret;
1694
1695     dde_inst = 0xdeadbeef;
1696     SetLastError(0xdeadbeef);
1697     ret = DdeInitializeW(&dde_inst, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1698     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1699     {
1700         skip("DdeInitialize is unimplemented\n");
1701         return;
1702     }
1703
1704     ok(ret == DMLERR_INVALIDPARAMETER, "DdeInitializeW should fail, but got %04x instead\n", ret);
1705     ok(DdeGetLastError(dde_inst) == DMLERR_INVALIDPARAMETER, "expected DMLERR_INVALIDPARAMETER\n");
1706
1707     dde_inst = 0;
1708     ret = DdeInitializeW(&dde_inst, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1709     ok(ret == DMLERR_NO_ERROR, "DdeInitializeW failed with error %04x (%08x)\n",
1710        ret, DdeGetLastError(dde_inst));
1711
1712     test_DdeCreateStringHandleW(dde_inst, 0);
1713     test_DdeCreateStringHandleW(dde_inst, CP_WINUNICODE);
1714     test_DdeCreateStringHandleW(dde_inst, CP_WINANSI);
1715
1716     ok(DdeUninitialize(dde_inst), "DdeUninitialize failed\n");
1717 }
1718
1719 static void test_FreeDDElParam(void)
1720 {
1721     HGLOBAL val, hglobal;
1722     BOOL ret;
1723
1724     ret = FreeDDElParam(WM_DDE_INITIATE, (LPARAM)NULL);
1725     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1726
1727     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1728     ret = FreeDDElParam(WM_DDE_INITIATE, (LPARAM)hglobal);
1729     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1730     val = GlobalFree(hglobal);
1731     ok(val == NULL, "Expected NULL, got %p\n", val);
1732
1733     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1734     ret = FreeDDElParam(WM_DDE_ADVISE, (LPARAM)hglobal);
1735     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1736     val = GlobalFree(hglobal);
1737     ok(val == hglobal, "Expected hglobal, got %p\n", val);
1738     ok(GetLastError() == ERROR_INVALID_HANDLE,
1739        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1740
1741     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1742     ret = FreeDDElParam(WM_DDE_UNADVISE, (LPARAM)hglobal);
1743     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1744     val = GlobalFree(hglobal);
1745     ok(val == NULL, "Expected NULL, got %p\n", val);
1746
1747     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1748     ret = FreeDDElParam(WM_DDE_ACK, (LPARAM)hglobal);
1749     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1750     val = GlobalFree(hglobal);
1751     ok(val == hglobal, "Expected hglobal, got %p\n", val);
1752     ok(GetLastError() == ERROR_INVALID_HANDLE,
1753        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1754
1755     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1756     ret = FreeDDElParam(WM_DDE_DATA, (LPARAM)hglobal);
1757     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1758     val = GlobalFree(hglobal);
1759     ok(val == hglobal, "Expected hglobal, got %p\n", val);
1760     ok(GetLastError() == ERROR_INVALID_HANDLE,
1761        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1762
1763     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1764     ret = FreeDDElParam(WM_DDE_REQUEST, (LPARAM)hglobal);
1765     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1766     val = GlobalFree(hglobal);
1767     ok(val == NULL, "Expected NULL, got %p\n", val);
1768
1769     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1770     ret = FreeDDElParam(WM_DDE_POKE, (LPARAM)hglobal);
1771     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1772     val = GlobalFree(hglobal);
1773     ok(val == hglobal, "Expected hglobal, got %p\n", val);
1774     ok(GetLastError() == ERROR_INVALID_HANDLE,
1775        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1776
1777     hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1778     ret = FreeDDElParam(WM_DDE_EXECUTE, (LPARAM)hglobal);
1779     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1780     val = GlobalFree(hglobal);
1781     ok(val == NULL, "Expected NULL, got %p\n", val);
1782 }
1783
1784 static void test_PackDDElParam(void)
1785 {
1786     UINT_PTR lo, hi, *ptr;
1787     HGLOBAL hglobal;
1788     LPARAM lparam;
1789     BOOL ret;
1790
1791     lparam = PackDDElParam(WM_DDE_INITIATE, 0xcafe, 0xbeef);
1792     ok(lparam == 0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1793     ok(GlobalLock((HGLOBAL)lparam) == NULL,
1794        "Expected NULL, got %p\n", GlobalLock((HGLOBAL)lparam));
1795     ok(GetLastError() == ERROR_INVALID_HANDLE,
1796        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1797
1798     lo = hi = 0;
1799     ret = UnpackDDElParam(WM_DDE_INITIATE, lparam, &lo, &hi);
1800     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1801     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1802     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1803
1804     ret = FreeDDElParam(WM_DDE_INITIATE, lparam);
1805     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1806
1807     lparam = PackDDElParam(WM_DDE_TERMINATE, 0xcafe, 0xbeef);
1808     ok(lparam == 0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1809     ok(GlobalLock((HGLOBAL)lparam) == NULL,
1810        "Expected NULL, got %p\n", GlobalLock((HGLOBAL)lparam));
1811     ok(GetLastError() == ERROR_INVALID_HANDLE,
1812        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1813
1814     lo = hi = 0;
1815     ret = UnpackDDElParam(WM_DDE_TERMINATE, lparam, &lo, &hi);
1816     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1817     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1818     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1819
1820     ret = FreeDDElParam(WM_DDE_TERMINATE, lparam);
1821     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1822
1823     lparam = PackDDElParam(WM_DDE_ADVISE, 0xcafe, 0xbeef);
1824     ptr = GlobalLock((HGLOBAL)lparam);
1825     ok(ptr != NULL, "Expected non-NULL ptr\n");
1826     ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1827     ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1828
1829     ret = GlobalUnlock((HGLOBAL)lparam);
1830     ok(ret == 1, "Expected 1, got %d\n", ret);
1831
1832     lo = hi = 0;
1833     ret = UnpackDDElParam(WM_DDE_ADVISE, lparam, &lo, &hi);
1834     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1835     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1836     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1837
1838     ret = FreeDDElParam(WM_DDE_ADVISE, lparam);
1839     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1840
1841     hglobal = GlobalFree((HGLOBAL)lparam);
1842     ok(hglobal == (HGLOBAL)lparam, "Expected lparam, got %d\n", ret);
1843     ok(GetLastError() == ERROR_INVALID_HANDLE,
1844        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1845
1846     lparam = PackDDElParam(WM_DDE_UNADVISE, 0xcafe, 0xbeef);
1847     ok(lparam == 0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1848     ok(GlobalLock((HGLOBAL)lparam) == NULL,
1849        "Expected NULL, got %p\n", GlobalLock((HGLOBAL)lparam));
1850     ok(GetLastError() == ERROR_INVALID_HANDLE,
1851        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1852
1853     lo = hi = 0;
1854     ret = UnpackDDElParam(WM_DDE_UNADVISE, lparam, &lo, &hi);
1855     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1856     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1857     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1858
1859     ret = FreeDDElParam(WM_DDE_UNADVISE, lparam);
1860     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1861
1862     lparam = PackDDElParam(WM_DDE_ACK, 0xcafe, 0xbeef);
1863     ptr = GlobalLock((HGLOBAL)lparam);
1864     ok(ptr != NULL, "Expected non-NULL ptr\n");
1865     ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1866     ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1867
1868     ret = GlobalUnlock((HGLOBAL)lparam);
1869     ok(ret == 1, "Expected 1, got %d\n", ret);
1870
1871     lo = hi = 0;
1872     ret = UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
1873     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1874     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1875     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1876
1877     ret = FreeDDElParam(WM_DDE_ACK, lparam);
1878     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1879
1880     hglobal = GlobalFree((HGLOBAL)lparam);
1881     ok(hglobal == (HGLOBAL)lparam, "Expected lparam, got %d\n", ret);
1882     ok(GetLastError() == ERROR_INVALID_HANDLE,
1883        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1884
1885     lparam = PackDDElParam(WM_DDE_DATA, 0xcafe, 0xbeef);
1886     ptr = GlobalLock((HGLOBAL)lparam);
1887     ok(ptr != NULL, "Expected non-NULL ptr\n");
1888     ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1889     ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1890
1891     ret = GlobalUnlock((HGLOBAL)lparam);
1892     ok(ret == 1, "Expected 1, got %d\n", ret);
1893
1894     lo = hi = 0;
1895     ret = UnpackDDElParam(WM_DDE_DATA, lparam, &lo, &hi);
1896     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1897     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1898     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1899
1900     ret = FreeDDElParam(WM_DDE_DATA, lparam);
1901     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1902
1903     hglobal = GlobalFree((HGLOBAL)lparam);
1904     ok(hglobal == (HGLOBAL)lparam, "Expected lparam, got %d\n", ret);
1905     ok(GetLastError() == ERROR_INVALID_HANDLE,
1906        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1907
1908     lparam = PackDDElParam(WM_DDE_REQUEST, 0xcafe, 0xbeef);
1909     ok(lparam == 0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1910     ok(GlobalLock((HGLOBAL)lparam) == NULL,
1911        "Expected NULL, got %p\n", GlobalLock((HGLOBAL)lparam));
1912     ok(GetLastError() == ERROR_INVALID_HANDLE,
1913        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1914
1915     lo = hi = 0;
1916     ret = UnpackDDElParam(WM_DDE_REQUEST, lparam, &lo, &hi);
1917     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1918     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1919     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1920
1921     ret = FreeDDElParam(WM_DDE_REQUEST, lparam);
1922     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1923
1924     lparam = PackDDElParam(WM_DDE_POKE, 0xcafe, 0xbeef);
1925     ptr = GlobalLock((HGLOBAL)lparam);
1926     ok(ptr != NULL, "Expected non-NULL ptr\n");
1927     ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1928     ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1929
1930     ret = GlobalUnlock((HGLOBAL)lparam);
1931     ok(ret == 1, "Expected 1, got %d\n", ret);
1932
1933     lo = hi = 0;
1934     ret = UnpackDDElParam(WM_DDE_POKE, lparam, &lo, &hi);
1935     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1936     ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1937     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1938
1939     ret = FreeDDElParam(WM_DDE_POKE, lparam);
1940     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1941
1942     hglobal = GlobalFree((HGLOBAL)lparam);
1943     ok(hglobal == (HGLOBAL)lparam, "Expected lparam, got %d\n", ret);
1944     ok(GetLastError() == ERROR_INVALID_HANDLE,
1945        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1946
1947     lparam = PackDDElParam(WM_DDE_EXECUTE, 0xcafe, 0xbeef);
1948     ok(lparam == 0xbeef, "Expected 0xbeef, got %08lx\n", lparam);
1949     ok(GlobalLock((HGLOBAL)lparam) == NULL,
1950        "Expected NULL, got %p\n", GlobalLock((HGLOBAL)lparam));
1951     ok(GetLastError() == ERROR_INVALID_HANDLE,
1952        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1953
1954     lo = hi = 0;
1955     ret = UnpackDDElParam(WM_DDE_EXECUTE, lparam, &lo, &hi);
1956     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1957     ok(lo == 0, "Expected 0, got %08lx\n", lo);
1958     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1959
1960     ret = FreeDDElParam(WM_DDE_EXECUTE, lparam);
1961     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1962 }
1963
1964 static void test_UnpackDDElParam(void)
1965 {
1966     UINT_PTR lo, hi, *ptr;
1967     HGLOBAL hglobal;
1968     BOOL ret;
1969
1970     /* NULL lParam */
1971     lo = 0xdead;
1972     hi = 0xbeef;
1973     ret = UnpackDDElParam(WM_DDE_INITIATE, (LPARAM)NULL, &lo, &hi);
1974     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1975     ok(lo == 0, "Expected 0, got %08lx\n", lo);
1976     ok(hi == 0, "Expected 0, got %08lx\n", hi);
1977
1978     /* NULL lo */
1979     lo = 0xdead;
1980     hi = 0xbeef;
1981     ret = UnpackDDElParam(WM_DDE_INITIATE, 0xcafebabe, NULL, &hi);
1982     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1983     ok(lo == 0xdead, "Expected 0xdead, got %08lx\n", lo);
1984     ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
1985
1986     /* NULL hi */
1987     lo = 0xdead;
1988     hi = 0xbeef;
1989     ret = UnpackDDElParam(WM_DDE_INITIATE, 0xcafebabe, &lo, NULL);
1990     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1991     ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
1992     ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1993
1994     lo = 0xdead;
1995     hi = 0xbeef;
1996     ret = UnpackDDElParam(WM_DDE_INITIATE, 0xcafebabe, &lo, &hi);
1997     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1998     ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
1999     ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2000
2001     lo = 0xdead;
2002     hi = 0xbeef;
2003     ret = UnpackDDElParam(WM_DDE_TERMINATE, 0xcafebabe, &lo, &hi);
2004     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2005     ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
2006     ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2007
2008     lo = 0xdead;
2009     hi = 0xbeef;
2010     ret = UnpackDDElParam(WM_DDE_ADVISE, (LPARAM)NULL, &lo, &hi);
2011     ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
2012     ok(lo == 0 ||
2013        broken(lo == 0xdead), /* win2k */
2014        "Expected 0, got %08lx\n", lo);
2015     ok(hi == 0 ||
2016        broken(hi == 0xbeef), /* win2k */
2017        "Expected 0, got %08lx\n", hi);
2018
2019     lo = 0xdead;
2020     hi = 0xbeef;
2021     ret = UnpackDDElParam(WM_DDE_ADVISE, 0xcafebabe, &lo, &hi);
2022     ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
2023     ok(lo == 0 ||
2024        broken(lo == 0xdead), /* win2k */
2025        "Expected 0, got %08lx\n", lo);
2026     ok(hi == 0 ||
2027        broken(hi == 0xbeef), /* win2k */
2028        "Expected 0, got %08lx\n", hi);
2029
2030     hglobal = GlobalAlloc(GMEM_DDESHARE, 2);
2031     ptr = GlobalLock(hglobal);
2032     ptr[0] = 0xcafebabe;
2033     ptr[1] = 0xdeadbeef;
2034     GlobalUnlock(hglobal);
2035
2036     lo = 0xdead;
2037     hi = 0xbeef;
2038     ret = UnpackDDElParam(WM_DDE_ADVISE, (LPARAM)hglobal, &lo, &hi);
2039     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2040     ok(lo == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", lo);
2041     ok(hi == 0xdeadbeef, "Expected 0xdeadbeef, got %08lx\n", hi);
2042
2043     lo = 0xdead;
2044     hi = 0xbeef;
2045     ret = UnpackDDElParam(WM_DDE_UNADVISE, 0xcafebabe, &lo, &hi);
2046     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2047     ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
2048     ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2049
2050     lo = 0xdead;
2051     hi = 0xbeef;
2052     ret = UnpackDDElParam(WM_DDE_ACK, 0xcafebabe, &lo, &hi);
2053     ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
2054     ok(lo == 0 ||
2055        broken(lo == 0xdead), /* win2k */
2056        "Expected 0, got %08lx\n", lo);
2057     ok(hi == 0 ||
2058        broken(hi == 0xbeef), /* win2k */
2059        "Expected 0, got %08lx\n", hi);
2060
2061     lo = 0xdead;
2062     hi = 0xbeef;
2063     ret = UnpackDDElParam(WM_DDE_ACK, (LPARAM)hglobal, &lo, &hi);
2064     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2065     ok(lo == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", lo);
2066     ok(hi == 0xdeadbeef, "Expected 0xdeadbeef, got %08lx\n", hi);
2067
2068     lo = 0xdead;
2069     hi = 0xbeef;
2070     ret = UnpackDDElParam(WM_DDE_DATA, 0xcafebabe, &lo, &hi);
2071     ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
2072     ok(lo == 0 ||
2073        broken(lo == 0xdead), /* win2k */
2074        "Expected 0, got %08lx\n", lo);
2075     ok(hi == 0 ||
2076        broken(hi == 0xbeef), /* win2k */
2077        "Expected 0, got %08lx\n", hi);
2078
2079     lo = 0xdead;
2080     hi = 0xbeef;
2081     ret = UnpackDDElParam(WM_DDE_DATA, (LPARAM)hglobal, &lo, &hi);
2082     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2083     ok(lo == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", lo);
2084     ok(hi == 0xdeadbeef, "Expected 0xdeadbeef, got %08lx\n", hi);
2085
2086     lo = 0xdead;
2087     hi = 0xbeef;
2088     ret = UnpackDDElParam(WM_DDE_REQUEST, 0xcafebabe, &lo, &hi);
2089     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2090     ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
2091     ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2092
2093     lo = 0xdead;
2094     hi = 0xbeef;
2095     ret = UnpackDDElParam(WM_DDE_POKE, 0xcafebabe, &lo, &hi);
2096     ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
2097     ok(lo == 0 ||
2098        broken(lo == 0xdead), /* win2k */
2099        "Expected 0, got %08lx\n", lo);
2100     ok(hi == 0 ||
2101        broken(hi == 0xbeef), /* win2k */
2102        "Expected 0, got %08lx\n", hi);
2103
2104     lo = 0xdead;
2105     hi = 0xbeef;
2106     ret = UnpackDDElParam(WM_DDE_POKE, (LPARAM)hglobal, &lo, &hi);
2107     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2108     ok(lo == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", lo);
2109     ok(hi == 0xdeadbeef, "Expected 0xdeadbeef, got %08lx\n", hi);
2110
2111     lo = 0xdead;
2112     hi = 0xbeef;
2113     ret = UnpackDDElParam(WM_DDE_EXECUTE, 0xcafebabe, &lo, &hi);
2114     ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2115     ok(lo == 0, "Expected 0, got %08lx\n", lo);
2116     ok(hi == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", hi);
2117 }
2118
2119 START_TEST(dde)
2120 {
2121     int argc;
2122     char **argv;
2123     char buffer[MAX_PATH];
2124     STARTUPINFO startup;
2125     PROCESS_INFORMATION proc;
2126
2127     argc = winetest_get_mainargs(&argv);
2128     if (argc == 3)
2129     {
2130         if (!lstrcmpA(argv[2], "ddeml"))
2131             test_ddeml_client();
2132         else if (!lstrcmpA(argv[2], "msg"))
2133             test_msg_client();
2134
2135         return;
2136     }
2137
2138     test_initialisation();
2139
2140     ZeroMemory(&startup, sizeof(STARTUPINFO));
2141     sprintf(buffer, "%s dde ddeml", argv[0]);
2142     startup.cb = sizeof(startup);
2143     startup.dwFlags = STARTF_USESHOWWINDOW;
2144     startup.wShowWindow = SW_SHOWNORMAL;
2145
2146     CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2147                    CREATE_SUSPENDED, NULL, NULL, &startup, &proc);
2148
2149     test_msg_server(proc.hProcess, proc.hThread);
2150
2151     sprintf(buffer, "%s dde msg", argv[0]);
2152     CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2153                    0, NULL, NULL, &startup, &proc);
2154
2155     test_ddeml_server(proc.hProcess);
2156
2157     test_dde_aw_transaction();
2158
2159     test_DdeCreateDataHandle();
2160     test_DdeCreateStringHandle();
2161     test_FreeDDElParam();
2162     test_PackDDElParam();
2163     test_UnpackDDElParam();
2164 }