user32/tests: Don't try to unpack or free invalid handles.
[wine/multimedia.git] / dlls / user32 / tests / dde.c
blob840406e0743cef21b175dfcf98e29dcbe7e2e145
1 /*
2 * Unit tests for DDE functions
4 * Copyright (c) 2004 Dmitry Timoshkov
5 * Copyright (c) 2007 James Hawkins
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.
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.
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
22 #include <assert.h>
23 #include <stdarg.h>
24 #include <stdio.h>
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "dde.h"
30 #include "ddeml.h"
31 #include "winerror.h"
33 #include "wine/test.h"
35 static const WCHAR TEST_DDE_SERVICE[] = {'T','e','s','t','D','D','E','S','e','r','v','i','c','e',0};
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};
40 static WNDPROC old_dde_client_wndproc;
42 static const DWORD default_timeout = 200;
44 static void flush_events(void)
46 MSG msg;
47 int diff = default_timeout;
48 int min_timeout = 50;
49 DWORD time = GetTickCount() + diff;
51 while (diff > 0)
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;
60 static void create_dde_window(HWND *hwnd, LPCSTR name, WNDPROC wndproc)
62 WNDCLASSA wcA;
64 memset(&wcA, 0, sizeof(wcA));
65 wcA.lpfnWndProc = wndproc;
66 wcA.lpszClassName = name;
67 wcA.hInstance = GetModuleHandleA(0);
68 assert(RegisterClassA(&wcA));
70 *hwnd = CreateWindowExA(0, name, NULL, WS_POPUP,
71 500, 500, CW_USEDEFAULT, CW_USEDEFAULT,
72 GetDesktopWindow(), 0, GetModuleHandleA(0), NULL);
73 assert(*hwnd);
76 static void destroy_dde_window(HWND *hwnd, LPCSTR name)
78 DestroyWindow(*hwnd);
79 UnregisterClass(name, GetModuleHandleA(0));
82 static LRESULT WINAPI dde_server_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
84 UINT_PTR lo, hi;
85 char str[MAX_PATH], *ptr;
86 HGLOBAL hglobal;
87 DDEDATA *data;
88 DDEPOKE *poke;
89 DWORD size;
91 static int msg_index = 0;
92 static HWND client = 0;
93 static BOOL executed = FALSE;
95 if (msg < WM_DDE_FIRST || msg > WM_DDE_LAST)
96 return DefWindowProcA(hwnd, msg, wparam, lparam);
98 msg_index++;
100 switch (msg)
102 case WM_DDE_INITIATE:
104 client = (HWND)wparam;
105 ok(msg_index == 1, "Expected 1, got %d\n", msg_index);
107 GlobalGetAtomNameA(LOWORD(lparam), str, MAX_PATH);
108 ok(!lstrcmpA(str, "TestDDEService"), "Expected TestDDEService, got %s\n", str);
110 GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
111 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
113 SendMessageA(client, WM_DDE_ACK, (WPARAM)hwnd, lparam);
115 break;
118 case WM_DDE_REQUEST:
120 ok((msg_index >= 2 && msg_index <= 4) ||
121 (msg_index >= 7 && msg_index <= 8),
122 "Expected 2, 3, 4, 7 or 8, got %d\n", msg_index);
123 ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
124 ok(LOWORD(lparam) == CF_TEXT, "Expected CF_TEXT, got %d\n", LOWORD(lparam));
126 GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
127 if (msg_index < 8)
128 ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
129 else
130 ok(!lstrcmpA(str, "executed"), "Expected executed, got %s\n", str);
132 if (msg_index == 8)
134 if (executed)
135 lstrcpyA(str, "command executed\r\n");
136 else
137 lstrcpyA(str, "command not executed\r\n");
139 else
140 lstrcpyA(str, "requested data\r\n");
142 size = sizeof(DDEDATA) + lstrlenA(str) + 1;
143 hglobal = GlobalAlloc(GMEM_MOVEABLE, size);
144 ok(hglobal != NULL, "Expected non-NULL hglobal\n");
146 data = GlobalLock(hglobal);
147 ZeroMemory(data, size);
149 /* setting fResponse to FALSE at this point destroys
150 * the internal messaging state of native dde
152 data->fResponse = TRUE;
154 if (msg_index == 2)
155 data->fRelease = TRUE;
156 else if (msg_index == 3)
157 data->fAckReq = TRUE;
159 data->cfFormat = CF_TEXT;
160 lstrcpyA((LPSTR)data->Value, str);
161 GlobalUnlock(hglobal);
163 lparam = PackDDElParam(WM_DDE_ACK, (UINT_PTR)hglobal, HIWORD(lparam));
164 PostMessageA(client, WM_DDE_DATA, (WPARAM)hwnd, lparam);
166 break;
169 case WM_DDE_POKE:
171 ok(msg_index == 5 || msg_index == 6, "Expected 5 or 6, got %d\n", msg_index);
172 ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
174 UnpackDDElParam(WM_DDE_POKE, lparam, &lo, &hi);
176 GlobalGetAtomNameA(hi, str, MAX_PATH);
177 ok(!lstrcmpA(str, "poker"), "Expected poker, got %s\n", str);
179 poke = GlobalLock((HGLOBAL)lo);
180 ok(poke != NULL, "Expected non-NULL poke\n");
181 ok(poke->fReserved == 0, "Expected 0, got %d\n", poke->fReserved);
182 ok(poke->unused == 0, "Expected 0, got %d\n", poke->unused);
183 ok(poke->fRelease == TRUE, "Expected TRUE, got %d\n", poke->fRelease);
184 ok(poke->cfFormat == CF_TEXT, "Expected CF_TEXT, got %d\n", poke->cfFormat);
186 if (msg_index == 5)
188 size = GlobalSize((HGLOBAL)lo);
189 ok(size == 4, "got %d\n", size);
191 else
192 ok(!lstrcmpA((LPSTR)poke->Value, "poke data\r\n"),
193 "Expected 'poke data\\r\\n', got %s\n", poke->Value);
195 GlobalUnlock((HGLOBAL)lo);
197 lparam = PackDDElParam(WM_DDE_ACK, DDE_FACK, hi);
198 PostMessageA(client, WM_DDE_ACK, (WPARAM)hwnd, lparam);
200 break;
203 case WM_DDE_EXECUTE:
205 ok(msg_index == 7, "Expected 7, got %d\n", msg_index);
206 ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
208 ptr = GlobalLock((HGLOBAL)lparam);
209 ok(!lstrcmpA(ptr, "[Command(Var)]"), "Expected [Command(Var)], got %s\n", ptr);
210 GlobalUnlock((HGLOBAL)lparam);
212 executed = TRUE;
214 lparam = ReuseDDElParam(lparam, WM_DDE_EXECUTE, WM_DDE_ACK, DDE_FACK, HIWORD(lparam));
215 PostMessageA(client, WM_DDE_ACK, (WPARAM)hwnd, lparam);
217 break;
220 case WM_DDE_TERMINATE:
222 ok(msg_index == 9, "Expected 9, got %d\n", msg_index);
223 ok(wparam == (WPARAM)client, "Expected client hwnd, got %08lx\n", wparam);
224 ok(lparam == 0, "Expected 0, got %08lx\n", lparam);
226 PostMessageA(client, WM_DDE_TERMINATE, (WPARAM)hwnd, 0);
228 break;
231 default:
232 ok(FALSE, "Unhandled msg: %08x\n", msg);
235 return DefWindowProcA(hwnd, msg, wparam, lparam);
238 static void test_msg_server(HANDLE hproc, HANDLE hthread)
240 MSG msg;
241 HWND hwnd;
242 DWORD res;
244 create_dde_window(&hwnd, "dde_server", dde_server_wndproc);
245 ResumeThread( hthread );
247 while (MsgWaitForMultipleObjects( 1, &hproc, FALSE, INFINITE, QS_ALLINPUT ) != 0)
249 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
252 destroy_dde_window(&hwnd, "dde_server");
253 GetExitCodeProcess( hproc, &res );
254 ok( !res, "client failed with %u error(s)\n", res );
257 static HDDEDATA CALLBACK client_ddeml_callback(UINT uType, UINT uFmt, HCONV hconv,
258 HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
259 ULONG_PTR dwData1, ULONG_PTR dwData2)
261 ok(FALSE, "Unhandled msg: %08x\n", uType);
262 return 0;
265 static void test_ddeml_client(void)
267 UINT ret;
268 char buffer[32];
269 LPSTR str;
270 DWORD size, res;
271 HDDEDATA hdata, op;
272 HSZ server, topic, item;
273 DWORD client_pid;
274 HCONV conversation;
276 client_pid = 0;
277 ret = DdeInitializeA(&client_pid, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
278 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
280 /* FIXME: make these atoms global and check them in the server */
282 server = DdeCreateStringHandleA(client_pid, "TestDDEService", CP_WINANSI);
283 topic = DdeCreateStringHandleA(client_pid, "TestDDETopic", CP_WINANSI);
285 DdeGetLastError(client_pid);
286 conversation = DdeConnect(client_pid, server, topic, NULL);
287 ok(conversation != NULL, "Expected non-NULL conversation\n");
288 ret = DdeGetLastError(client_pid);
289 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
291 DdeFreeStringHandle(client_pid, server);
293 item = DdeCreateStringHandleA(client_pid, "request", CP_WINANSI);
295 /* XTYP_REQUEST, fRelease = TRUE */
296 res = 0xdeadbeef;
297 DdeGetLastError(client_pid);
298 hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
299 ret = DdeGetLastError(client_pid);
300 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
301 ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %08x\n", res);
302 if (hdata == NULL)
303 ok(FALSE, "hdata is NULL\n");
304 else
306 str = (LPSTR)DdeAccessData(hdata, &size);
307 ok(!lstrcmpA(str, "requested data\r\n"), "Expected 'requested data\\r\\n', got %s\n", str);
308 ok(size == 19, "Expected 19, got %d\n", size);
310 ret = DdeUnaccessData(hdata);
311 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
314 /* XTYP_REQUEST, fAckReq = TRUE */
315 res = 0xdeadbeef;
316 DdeGetLastError(client_pid);
317 hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
318 ret = DdeGetLastError(client_pid);
319 ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %d\n", res);
320 todo_wine
321 ok(ret == DMLERR_MEMORY_ERROR, "Expected DMLERR_MEMORY_ERROR, got %d\n", ret);
322 if (hdata == NULL)
323 ok(FALSE, "hdata is NULL\n");
324 else
326 str = (LPSTR)DdeAccessData(hdata, &size);
327 ok(!lstrcmpA(str, "requested data\r\n"), "Expected 'requested data\\r\\n', got %s\n", str);
328 ok(size == 19, "Expected 19, got %d\n", size);
330 ret = DdeUnaccessData(hdata);
331 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
334 /* XTYP_REQUEST, all params normal */
335 res = 0xdeadbeef;
336 DdeGetLastError(client_pid);
337 hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
338 ret = DdeGetLastError(client_pid);
339 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
340 ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %d\n", res);
341 if (hdata == NULL)
342 ok(FALSE, "hdata is NULL\n");
343 else
345 str = (LPSTR)DdeAccessData(hdata, &size);
346 ok(!lstrcmpA(str, "requested data\r\n"), "Expected 'requested data\\r\\n', got %s\n", str);
347 ok(size == 19, "Expected 19, got %d\n", size);
349 ret = DdeUnaccessData(hdata);
350 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
353 /* XTYP_REQUEST, no item */
354 res = 0xdeadbeef;
355 DdeGetLastError(client_pid);
356 hdata = DdeClientTransaction(NULL, 0, conversation, 0, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
357 ret = DdeGetLastError(client_pid);
358 ok(hdata == NULL, "Expected NULL hdata, got %p\n", hdata);
359 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %08x\n", res);
360 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
362 DdeFreeStringHandle(client_pid, item);
364 item = DdeCreateStringHandleA(client_pid, "poker", CP_WINANSI);
366 lstrcpyA(buffer, "poke data\r\n");
367 hdata = DdeCreateDataHandle(client_pid, (LPBYTE)buffer, lstrlenA(buffer) + 1,
368 0, item, CF_TEXT, 0);
369 ok(hdata != NULL, "Expected non-NULL hdata\n");
371 /* XTYP_POKE, no item */
372 res = 0xdeadbeef;
373 DdeGetLastError(client_pid);
374 op = DdeClientTransaction((LPBYTE)hdata, -1, conversation, 0, CF_TEXT, XTYP_POKE, default_timeout, &res);
375 ret = DdeGetLastError(client_pid);
376 ok(op == NULL, "Expected NULL, got %p\n", op);
377 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
378 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
380 /* XTYP_POKE, no data */
381 res = 0xdeadbeef;
382 DdeGetLastError(client_pid);
383 op = DdeClientTransaction(NULL, 0, conversation, 0, CF_TEXT, XTYP_POKE, default_timeout, &res);
384 ret = DdeGetLastError(client_pid);
385 ok(op == NULL, "Expected NULL, got %p\n", op);
386 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
387 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
389 /* XTYP_POKE, wrong size */
390 res = 0xdeadbeef;
391 DdeGetLastError(client_pid);
392 op = DdeClientTransaction((LPBYTE)hdata, 0, conversation, item, CF_TEXT, XTYP_POKE, default_timeout, &res);
393 ret = DdeGetLastError(client_pid);
394 ok(op == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", op);
395 ok(res == DDE_FACK, "Expected DDE_FACK, got %d\n", res);
396 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
398 /* XTYP_POKE, correct params */
399 res = 0xdeadbeef;
400 DdeGetLastError(client_pid);
401 op = DdeClientTransaction((LPBYTE)hdata, -1, conversation, item, CF_TEXT, XTYP_POKE, default_timeout, &res);
402 ret = DdeGetLastError(client_pid);
403 ok(op == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", op);
404 ok(res == DDE_FACK, "Expected DDE_FACK, got %d\n", res);
405 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
407 DdeFreeDataHandle(hdata);
409 lstrcpyA(buffer, "[Command(Var)]");
410 hdata = DdeCreateDataHandle(client_pid, (LPBYTE)buffer, lstrlenA(buffer) + 1,
411 0, NULL, CF_TEXT, 0);
412 ok(hdata != NULL, "Expected non-NULL hdata\n");
414 /* XTYP_EXECUTE, correct params */
415 res = 0xdeadbeef;
416 DdeGetLastError(client_pid);
417 op = DdeClientTransaction((LPBYTE)hdata, -1, conversation, NULL, 0, XTYP_EXECUTE, default_timeout, &res);
418 ret = DdeGetLastError(client_pid);
419 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
420 ok(op == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", op);
421 ok(res == DDE_FACK, "Expected DDE_FACK, got %d\n", res);
423 /* XTYP_EXECUTE, no data */
424 res = 0xdeadbeef;
425 DdeGetLastError(client_pid);
426 op = DdeClientTransaction(NULL, 0, conversation, NULL, 0, XTYP_EXECUTE, default_timeout, &res);
427 ret = DdeGetLastError(client_pid);
428 ok(op == NULL, "Expected NULL, got %p\n", op);
429 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
430 ok(ret == DMLERR_MEMORY_ERROR, "Expected DMLERR_MEMORY_ERROR, got %d\n", ret);
432 /* XTYP_EXECUTE, no data, -1 size */
433 res = 0xdeadbeef;
434 DdeGetLastError(client_pid);
435 op = DdeClientTransaction(NULL, -1, conversation, NULL, 0, XTYP_EXECUTE, default_timeout, &res);
436 ret = DdeGetLastError(client_pid);
437 ok(op == NULL, "Expected NULL, got %p\n", op);
438 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
439 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
441 DdeFreeStringHandle(client_pid, topic);
442 DdeFreeDataHandle(hdata);
444 item = DdeCreateStringHandleA(client_pid, "executed", CP_WINANSI);
446 /* verify the execute */
447 res = 0xdeadbeef;
448 DdeGetLastError(client_pid);
449 hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
450 ret = DdeGetLastError(client_pid);
451 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
452 ok(res == DDE_FNOTPROCESSED, "Expected DDE_FNOTPROCESSED, got %d\n", res);
453 if (hdata == NULL)
454 ok(FALSE, "hdata is NULL\n");
455 else
457 str = (LPSTR)DdeAccessData(hdata, &size);
458 ok(!lstrcmpA(str, "command executed\r\n"), "Expected 'command executed\\r\\n', got %s\n", str);
459 ok(size == 21, "Expected 21, got %d\n", size);
461 ret = DdeUnaccessData(hdata);
462 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
465 /* invalid transactions */
466 res = 0xdeadbeef;
467 DdeGetLastError(client_pid);
468 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_ADVREQ, default_timeout, &res);
469 ret = DdeGetLastError(client_pid);
470 ok(op == NULL, "Expected NULL, got %p\n", op);
471 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
472 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
474 res = 0xdeadbeef;
475 DdeGetLastError(client_pid);
476 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_CONNECT, default_timeout, &res);
477 ret = DdeGetLastError(client_pid);
478 ok(op == NULL, "Expected NULL, got %p\n", op);
479 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
480 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
482 res = 0xdeadbeef;
483 DdeGetLastError(client_pid);
484 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_CONNECT_CONFIRM, default_timeout, &res);
485 ret = DdeGetLastError(client_pid);
486 ok(op == NULL, "Expected NULL, got %p\n", op);
487 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
488 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
490 res = 0xdeadbeef;
491 DdeGetLastError(client_pid);
492 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_DISCONNECT, default_timeout, &res);
493 ret = DdeGetLastError(client_pid);
494 ok(op == NULL, "Expected NULL, got %p\n", op);
495 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
496 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
498 res = 0xdeadbeef;
499 DdeGetLastError(client_pid);
500 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_ERROR, default_timeout, &res);
501 ret = DdeGetLastError(client_pid);
502 ok(op == NULL, "Expected NULL, got %p\n", op);
503 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
504 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
506 res = 0xdeadbeef;
507 DdeGetLastError(client_pid);
508 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_MONITOR, default_timeout, &res);
509 ret = DdeGetLastError(client_pid);
510 ok(op == NULL, "Expected NULL, got %p\n", op);
511 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
512 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
514 res = 0xdeadbeef;
515 DdeGetLastError(client_pid);
516 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REGISTER, default_timeout, &res);
517 ret = DdeGetLastError(client_pid);
518 ok(op == NULL, "Expected NULL, got %p\n", op);
519 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
520 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
522 res = 0xdeadbeef;
523 DdeGetLastError(client_pid);
524 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_UNREGISTER, default_timeout, &res);
525 ret = DdeGetLastError(client_pid);
526 ok(op == NULL, "Expected NULL, got %p\n", op);
527 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
528 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
530 res = 0xdeadbeef;
531 DdeGetLastError(client_pid);
532 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_WILDCONNECT, default_timeout, &res);
533 ret = DdeGetLastError(client_pid);
534 ok(op == NULL, "Expected NULL, got %p\n", op);
535 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
536 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
538 res = 0xdeadbeef;
539 DdeGetLastError(client_pid);
540 op = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_XACT_COMPLETE, default_timeout, &res);
541 ret = DdeGetLastError(client_pid);
542 ok(op == NULL, "Expected NULL, got %p\n", op);
543 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", res);
544 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
546 DdeFreeStringHandle(client_pid, item);
548 ret = DdeDisconnect(conversation);
549 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
551 ret = DdeUninitialize(client_pid);
552 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
555 static DWORD server_pid;
557 static HDDEDATA CALLBACK server_ddeml_callback(UINT uType, UINT uFmt, HCONV hconv,
558 HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
559 ULONG_PTR dwData1, ULONG_PTR dwData2)
561 char str[MAX_PATH], *ptr;
562 HDDEDATA ret = NULL;
563 DWORD size;
565 static int msg_index = 0;
566 static HCONV conversation = 0;
568 msg_index++;
570 switch (uType)
572 case XTYP_REGISTER:
574 ok(msg_index == 1, "Expected 1, got %d\n", msg_index);
575 ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
576 ok(hconv == 0, "Expected 0, got %p\n", hconv);
577 ok(hdata == 0, "Expected 0, got %p\n", hdata);
578 ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
579 ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
581 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
582 ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
583 ok(size == 13, "Expected 13, got %d\n", size);
585 size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
586 ok(!strncmp(str, "TestDDEServer(", 14), "Expected TestDDEServer(, got %s\n", str);
587 ok(str[size - 1] == ')', "Expected ')', got %c\n", str[size - 1]);
588 ok(size == 17 + 2*sizeof(ULONG_PTR), "Got size %d for %s\n", size, str);
590 return (HDDEDATA)TRUE;
593 case XTYP_CONNECT:
595 ok(msg_index == 2, "Expected 2, got %d\n", msg_index);
596 ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
597 ok(hconv == 0, "Expected 0, got %p\n", hconv);
598 ok(hdata == 0, "Expected 0, got %p\n", hdata);
599 ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
600 ok(dwData2 == FALSE, "Expected FALSE, got %08lx\n", dwData2);
602 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
603 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
604 ok(size == 12, "Expected 12, got %d\n", size);
606 size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
607 ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
608 ok(size == 13, "Expected 13, got %d\n", size);
610 return (HDDEDATA)TRUE;
613 case XTYP_CONNECT_CONFIRM:
615 conversation = hconv;
617 ok(msg_index == 3, "Expected 3, got %d\n", msg_index);
618 ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
619 ok(hconv != NULL, "Expected non-NULL hconv\n");
620 ok(hdata == 0, "Expected 0, got %p\n", hdata);
621 ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
622 ok(dwData2 == FALSE, "Expected FALSE, got %08lx\n", dwData2);
624 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
625 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
626 ok(size == 12, "Expected 12, got %d\n", size);
628 size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
629 ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
630 ok(size == 13, "Expected 13, got %d\n", size);
632 return (HDDEDATA)TRUE;
635 case XTYP_REQUEST:
637 ok(msg_index == 4 || msg_index == 5 || msg_index == 6,
638 "Expected 4, 5 or 6, got %d\n", msg_index);
639 ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
640 ok(hdata == 0, "Expected 0, got %p\n", hdata);
641 ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
642 ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
644 if (msg_index == 4)
645 ok(uFmt == 0xbeef, "Expected 0xbeef, got %08x\n", uFmt);
646 else
647 ok(uFmt == CF_TEXT, "Expected CF_TEXT, got %08x\n", uFmt);
649 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
650 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
651 ok(size == 12, "Expected 12, got %d\n", size);
653 size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
655 if (msg_index == 5)
658 ok(!lstrcmpA(str, ""), "Expected empty string, got %s\n", str);
659 ok(size == 1, "Expected 1, got %d\n", size);
662 else if (msg_index == 6)
664 ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
665 ok(size == 7, "Expected 7, got %d\n", size);
668 if (msg_index == 6)
670 lstrcpyA(str, "requested data\r\n");
671 return DdeCreateDataHandle(server_pid, (LPBYTE)str, lstrlenA(str) + 1,
672 0, hsz2, CF_TEXT, 0);
675 return NULL;
678 case XTYP_POKE:
680 ok(msg_index == 7 || msg_index == 8, "Expected 7 or 8, got %d\n", msg_index);
681 ok(uFmt == CF_TEXT, "Expected CF_TEXT, got %d\n", uFmt);
682 ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
683 ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
684 ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
686 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
687 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
688 ok(size == 12, "Expected 12, got %d\n", size);
690 ptr = (LPSTR)DdeAccessData(hdata, &size);
691 ok(!lstrcmpA(ptr, "poke data\r\n"), "Expected 'poke data\\r\\n', got %s\n", ptr);
692 ok(size == 12, "Expected 12, got %d\n", size);
693 DdeUnaccessData(hdata);
695 size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
696 if (msg_index == 7)
699 ok(!lstrcmpA(str, ""), "Expected empty string, got %s\n", str);
700 ok(size == 1, "Expected 1, got %d\n", size);
703 else
705 ok(!lstrcmpA(str, "poke"), "Expected poke, got %s\n", str);
706 ok(size == 4, "Expected 4, got %d\n", size);
709 return (HDDEDATA)DDE_FACK;
712 case XTYP_EXECUTE:
714 ok(msg_index >= 9 && msg_index <= 11, "Expected 9 or 11, got %d\n", msg_index);
715 ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
716 ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
717 ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
718 ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
719 ok(hsz2 == 0, "Expected 0, got %p\n", hsz2);
721 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
722 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
723 ok(size == 12, "Expected 12, got %d\n", size);
725 if (msg_index == 9 || msg_index == 11)
727 ptr = (LPSTR)DdeAccessData(hdata, &size);
729 if (msg_index == 9)
731 ok(!lstrcmpA(ptr, "[Command(Var)]"), "Expected '[Command(Var)]', got %s\n", ptr);
732 ok(size == 15, "Expected 15, got %d\n", size);
733 ret = (HDDEDATA)DDE_FACK;
735 else
737 ok(!lstrcmpA(ptr, "[BadCommand(Var)]"), "Expected '[BadCommand(Var)]', got %s\n", ptr);
738 ok(size == 18, "Expected 18, got %d\n", size);
739 ret = DDE_FNOTPROCESSED;
742 DdeUnaccessData(hdata);
744 else if (msg_index == 10)
746 DWORD rsize = 0;
747 size = 0;
749 size = DdeGetData(hdata, NULL, 0, 0);
750 ok(size == 17, "DdeGetData should have returned 17 not %d\n", size);
751 ptr = HeapAlloc(GetProcessHeap(), 0, size);
752 ok(ptr != NULL,"HeapAlloc should have returned ptr not NULL\n");
753 rsize = DdeGetData(hdata, (LPBYTE)ptr, size, 0);
754 ok(rsize == size, "DdeGetData did not return %d bytes but %d\n", size, rsize);
756 ok(!lstrcmpA(ptr, "[Command-2(Var)]"), "Expected '[Command-2(Var)]' got %s\n", ptr);
757 ok(size == 17, "Expected 17, got %d\n", size);
758 ret = (HDDEDATA)DDE_FACK;
760 HeapFree(GetProcessHeap(), 0, ptr);
763 return ret;
766 case XTYP_DISCONNECT:
768 ok(msg_index == 12, "Expected 12, got %d\n", msg_index);
769 ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
770 ok(hconv == conversation, "Expected conversation handle, got %p\n", hconv);
771 ok(dwData1 == 0, "Expected 0, got %08lx\n", dwData1);
772 ok(dwData2 == 0, "Expected 0, got %08lx\n", dwData2);
773 ok(hsz1 == 0, "Expected 0, got %p\n", hsz2);
774 ok(hsz2 == 0, "Expected 0, got %p\n", hsz2);
776 return 0;
779 default:
780 ok(FALSE, "Unhandled msg: %08x\n", uType);
783 return 0;
786 static void test_ddeml_server(HANDLE hproc)
788 MSG msg;
789 UINT res;
790 BOOL ret;
791 HSZ server;
792 HDDEDATA hdata;
794 /* set up DDE server */
795 server_pid = 0;
796 res = DdeInitialize(&server_pid, server_ddeml_callback, APPCLASS_STANDARD, 0);
797 ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
799 server = DdeCreateStringHandle(server_pid, "TestDDEServer", CP_WINANSI);
800 ok(server != NULL, "Expected non-NULL string handle\n");
802 hdata = DdeNameService(server_pid, server, 0, DNS_REGISTER);
803 ok(hdata == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", hdata);
805 while (MsgWaitForMultipleObjects( 1, &hproc, FALSE, INFINITE, QS_ALLINPUT ) != 0)
807 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
809 ret = DdeUninitialize(server_pid);
810 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
811 GetExitCodeProcess( hproc, &res );
812 ok( !res, "client failed with %u error(s)\n", res );
815 static HWND client_hwnd, server_hwnd;
816 static ATOM server, topic, item;
817 static HGLOBAL execute_hglobal;
819 static LRESULT WINAPI dde_msg_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
821 char str[MAX_PATH];
822 UINT_PTR lo, hi;
823 DDEDATA *data;
824 DDEACK *ack;
825 DWORD size;
826 LPSTR ptr;
828 static int msg_index = 0;
830 if (msg < WM_DDE_FIRST || msg > WM_DDE_LAST)
831 return DefWindowProcA(hwnd, msg, wparam, lparam);
833 msg_index++;
835 switch (msg)
837 case WM_DDE_INITIATE:
839 ok(msg_index == 1, "Expected 1, got %d\n", msg_index);
840 ok(wparam == (WPARAM)client_hwnd, "Expected client hwnd, got %08lx\n", wparam);
842 size = GlobalGetAtomNameA(LOWORD(lparam), str, MAX_PATH);
843 ok(LOWORD(lparam) == server, "Expected server atom, got %08x\n", LOWORD(lparam));
844 ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
845 ok(size == 13, "Expected 13, got %d\n", size);
847 size = GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
848 ok(HIWORD(lparam) == topic, "Expected topic atom, got %08x\n", HIWORD(lparam));
849 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
850 ok(size == 12, "Expected 12, got %d\n", size);
852 break;
855 case WM_DDE_ACK:
857 ok((msg_index >= 2 && msg_index <= 4) || (msg_index >= 6 && msg_index <= 11),
858 "Expected 2, 3, 4, 6, 7, 8, 9, 10 or 11, got %d\n", msg_index);
860 if (msg_index == 2)
862 server_hwnd = (HWND)wparam;
863 ok(wparam != 0, "Expected non-NULL wparam, got %08lx\n", wparam);
865 size = GlobalGetAtomNameA(LOWORD(lparam), str, MAX_PATH);
866 ok(LOWORD(lparam) == server, "Expected server atom, got %08x\n", LOWORD(lparam));
867 ok(!lstrcmpA(str, "TestDDEServer"), "Expected TestDDEServer, got %s\n", str);
868 ok(size == 13, "Expected 13, got %d\n", size);
870 size = GlobalGetAtomNameA(HIWORD(lparam), str, MAX_PATH);
871 ok(HIWORD(lparam) == topic, "Expected topic atom, got %08x\n", HIWORD(lparam));
872 ok(!lstrcmpA(str, "TestDDETopic"), "Expected TestDDETopic, got %s\n", str);
873 ok(size == 12, "Expected 12, got %d\n", size);
875 else if (msg_index >= 9 && msg_index <= 11)
877 ok(wparam == (WPARAM)server_hwnd, "Expected server hwnd, got %08lx\n", wparam);
879 UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
881 ack = (DDEACK *)&lo;
882 ok(ack->bAppReturnCode == 0, "Expected 0, got %d\n", ack->bAppReturnCode);
883 ok(ack->reserved == 0, "Expected 0, got %d\n", ack->reserved);
884 ok(ack->fBusy == FALSE, "Expected FALSE, got %d\n", ack->fBusy);
886 ok(hi == (UINT_PTR)execute_hglobal, "Execpted execute hglobal, got %08lx\n", hi);
887 ptr = GlobalLock((HGLOBAL)hi);
889 if (msg_index == 9)
891 ok(ack->fAck == TRUE, "Expected TRUE, got %d\n", ack->fAck);
892 ok(!lstrcmpA(ptr, "[Command(Var)]"), "Expected '[Command(Var)]', got %s\n", ptr);
893 } else if (msg_index == 10)
895 ok(ack->fAck == TRUE, "Expected TRUE, got %d\n", ack->fAck);
896 ok(!lstrcmpA(ptr, "[Command-2(Var)]"), "Expected '[Command-2(Var)]', got %s\n", ptr);
898 else
900 ok(ack->fAck == FALSE, "Expected FALSE, got %d\n", ack->fAck);
901 ok(!lstrcmpA(ptr, "[BadCommand(Var)]"), "Expected '[BadCommand(Var)]', got %s\n", ptr);
904 GlobalUnlock((HGLOBAL)hi);
906 else
908 ok(wparam == (WPARAM)server_hwnd, "Expected server hwnd, got %08lx\n", wparam);
910 UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
912 ack = (DDEACK *)&lo;
913 ok(ack->bAppReturnCode == 0, "Expected 0, got %d\n", ack->bAppReturnCode);
914 ok(ack->reserved == 0, "Expected 0, got %d\n", ack->reserved);
915 ok(ack->fBusy == FALSE, "Expected FALSE, got %d\n", ack->fBusy);
917 if (msg_index >= 7)
918 ok(ack->fAck == TRUE, "Expected TRUE, got %d\n", ack->fAck);
919 else
921 if (msg_index == 6) todo_wine
922 ok(ack->fAck == FALSE, "Expected FALSE, got %d\n", ack->fAck);
925 size = GlobalGetAtomNameA(hi, str, MAX_PATH);
926 if (msg_index == 3)
928 ok(hi == item, "Expected item atom, got %08lx\n", hi);
929 ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
930 ok(size == 7, "Expected 7, got %d\n", size);
932 else if (msg_index == 4 || msg_index == 7)
934 ok(hi == 0, "Expected 0, got %08lx\n", hi);
935 ok(size == 0, "Expected empty string, got %d\n", size);
937 else
939 ok(hi == item, "Expected item atom, got %08lx\n", hi);
940 if (msg_index == 6) todo_wine
942 ok(!lstrcmpA(str, "poke"), "Expected poke, got %s\n", str);
943 ok(size == 4, "Expected 4, got %d\n", size);
948 break;
951 case WM_DDE_DATA:
953 ok(msg_index == 5, "Expected 5, got %d\n", msg_index);
954 ok(wparam == (WPARAM)server_hwnd, "Expected server hwnd, got %08lx\n", wparam);
956 UnpackDDElParam(WM_DDE_DATA, lparam, &lo, &hi);
958 data = GlobalLock((HGLOBAL)lo);
959 ok(data->unused == 0, "Expected 0, got %d\n", data->unused);
960 ok(data->fResponse == TRUE, "Expected TRUE, got %d\n", data->fResponse);
961 todo_wine
963 ok(data->fRelease == TRUE, "Expected TRUE, got %d\n", data->fRelease);
965 ok(data->fAckReq == 0, "Expected 0, got %d\n", data->fAckReq);
966 ok(data->cfFormat == CF_TEXT, "Expected CF_TEXT, got %d\n", data->cfFormat);
967 ok(!lstrcmpA((LPSTR)data->Value, "requested data\r\n"),
968 "Expeted 'requested data\\r\\n', got %s\n", data->Value);
969 GlobalUnlock((HGLOBAL)lo);
971 size = GlobalGetAtomNameA(hi, str, MAX_PATH);
972 ok(hi == item, "Expected item atom, got %08x\n", HIWORD(lparam));
973 ok(!lstrcmpA(str, "request"), "Expected request, got %s\n", str);
974 ok(size == 7, "Expected 7, got %d\n", size);
976 GlobalFree((HGLOBAL)lo);
977 GlobalDeleteAtom(hi);
979 break;
982 default:
983 ok(FALSE, "Unhandled msg: %08x\n", msg);
986 return DefWindowProcA(hwnd, msg, wparam, lparam);
989 static HGLOBAL create_poke(void)
991 HGLOBAL hglobal;
992 DDEPOKE *poke;
993 DWORD size;
995 size = FIELD_OFFSET(DDEPOKE, Value[sizeof("poke data\r\n")]);
996 hglobal = GlobalAlloc(GMEM_DDESHARE, size);
997 ok(hglobal != 0, "Expected non-NULL hglobal\n");
999 poke = GlobalLock(hglobal);
1000 poke->unused = 0;
1001 poke->fRelease = TRUE;
1002 poke->fReserved = TRUE;
1003 poke->cfFormat = CF_TEXT;
1004 lstrcpyA((LPSTR)poke->Value, "poke data\r\n");
1005 GlobalUnlock(hglobal);
1007 return hglobal;
1010 static HGLOBAL create_execute(LPCSTR command)
1012 HGLOBAL hglobal;
1013 LPSTR ptr;
1015 hglobal = GlobalAlloc(GMEM_DDESHARE, lstrlenA(command) + 1);
1016 ok(hglobal != 0, "Expected non-NULL hglobal\n");
1018 ptr = GlobalLock(hglobal);
1019 lstrcpyA(ptr, command);
1020 GlobalUnlock(hglobal);
1022 return hglobal;
1025 static void test_msg_client(void)
1027 HGLOBAL hglobal;
1028 LPARAM lparam;
1030 create_dde_window(&client_hwnd, "dde_client", dde_msg_client_wndproc);
1032 server = GlobalAddAtomA("TestDDEServer");
1033 ok(server != 0, "Expected non-NULL server\n");
1035 topic = GlobalAddAtomA("TestDDETopic");
1036 ok(topic != 0, "Expected non-NULL topic\n");
1038 SendMessageA(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)client_hwnd, MAKELONG(server, topic));
1040 GlobalDeleteAtom(server);
1041 GlobalDeleteAtom(topic);
1043 flush_events();
1045 item = GlobalAddAtom("request");
1046 ok(item != 0, "Expected non-NULL item\n");
1048 /* WM_DDE_REQUEST, bad clipboard format */
1049 lparam = PackDDElParam(WM_DDE_REQUEST, 0xdeadbeef, item);
1050 PostMessageA(server_hwnd, WM_DDE_REQUEST, (WPARAM)client_hwnd, lparam);
1052 flush_events();
1054 /* WM_DDE_REQUEST, no item */
1055 lparam = PackDDElParam(WM_DDE_REQUEST, CF_TEXT, 0);
1056 PostMessageA(server_hwnd, WM_DDE_REQUEST, (WPARAM)client_hwnd, lparam);
1058 flush_events();
1060 /* WM_DDE_REQUEST, no client hwnd */
1061 lparam = PackDDElParam(WM_DDE_REQUEST, CF_TEXT, item);
1062 PostMessageA(server_hwnd, WM_DDE_REQUEST, 0, lparam);
1064 flush_events();
1066 /* WM_DDE_REQUEST, correct params */
1067 lparam = PackDDElParam(WM_DDE_REQUEST, CF_TEXT, item);
1068 PostMessageA(server_hwnd, WM_DDE_REQUEST, (WPARAM)client_hwnd, lparam);
1070 flush_events();
1072 GlobalDeleteAtom(item);
1073 item = GlobalAddAtomA("poke");
1074 ok(item != 0, "Expected non-NULL item\n");
1076 hglobal = create_poke();
1078 /* WM_DDE_POKE, no ddepoke */
1079 lparam = PackDDElParam(WM_DDE_POKE, 0, item);
1080 /* win9x returns 0 here and crashes in PostMessageA */
1081 if (lparam) {
1082 PostMessageA(server_hwnd, WM_DDE_POKE, (WPARAM)client_hwnd, lparam);
1083 flush_events();
1085 else
1086 win_skip("no lparam for WM_DDE_POKE\n");
1089 /* WM_DDE_POKE, no item */
1090 lparam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)hglobal, 0);
1091 PostMessageA(server_hwnd, WM_DDE_POKE, (WPARAM)client_hwnd, lparam);
1093 flush_events();
1095 hglobal = create_poke();
1097 /* WM_DDE_POKE, no client hwnd */
1098 lparam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)hglobal, item);
1099 PostMessageA(server_hwnd, WM_DDE_POKE, 0, lparam);
1101 flush_events();
1103 /* WM_DDE_POKE, all params correct */
1104 lparam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)hglobal, item);
1105 PostMessageA(server_hwnd, WM_DDE_POKE, (WPARAM)client_hwnd, lparam);
1107 flush_events();
1109 execute_hglobal = create_execute("[Command(Var)]");
1111 /* WM_DDE_EXECUTE, no lparam */
1112 PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, 0);
1114 flush_events();
1116 /* WM_DDE_EXECUTE, no hglobal */
1117 lparam = PackDDElParam(WM_DDE_EXECUTE, 0, 0);
1118 PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, lparam);
1120 flush_events();
1122 /* WM_DDE_EXECUTE, no client hwnd */
1123 lparam = PackDDElParam(WM_DDE_EXECUTE, 0, (UINT_PTR)execute_hglobal);
1124 PostMessageA(server_hwnd, WM_DDE_EXECUTE, 0, lparam);
1126 flush_events();
1128 /* WM_DDE_EXECUTE, all params correct */
1129 lparam = PackDDElParam(WM_DDE_EXECUTE, 0, (UINT_PTR)execute_hglobal);
1130 PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, lparam);
1132 flush_events();
1134 GlobalFree(execute_hglobal);
1135 execute_hglobal = create_execute("[Command-2(Var)]");
1137 /* WM_DDE_EXECUTE, all params correct */
1138 lparam = PackDDElParam(WM_DDE_EXECUTE, 0, (UINT_PTR)execute_hglobal);
1139 PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, lparam);
1141 flush_events();
1143 GlobalFree(execute_hglobal);
1144 execute_hglobal = create_execute("[BadCommand(Var)]");
1146 /* WM_DDE_EXECUTE that will get rejected */
1147 lparam = PackDDElParam(WM_DDE_EXECUTE, 0, (UINT_PTR)execute_hglobal);
1148 PostMessageA(server_hwnd, WM_DDE_EXECUTE, (WPARAM)client_hwnd, lparam);
1150 flush_events();
1152 destroy_dde_window(&client_hwnd, "dde_client");
1155 static LRESULT WINAPI hook_dde_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1157 UINT_PTR lo, hi;
1159 trace("hook_dde_client_wndproc: %p %04x %08lx %08lx\n", hwnd, msg, wparam, lparam);
1161 switch (msg)
1163 case WM_DDE_ACK:
1164 UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
1165 trace("WM_DDE_ACK: status %04lx hglobal %p\n", lo, (HGLOBAL)hi);
1166 break;
1168 default:
1169 break;
1171 return CallWindowProcA(old_dde_client_wndproc, hwnd, msg, wparam, lparam);
1174 static LRESULT WINAPI dde_server_wndprocW(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1176 trace("dde_server_wndprocW: %p %04x %08lx %08lx\n", hwnd, msg, wparam, lparam);
1178 switch (msg)
1180 case WM_DDE_INITIATE:
1182 ATOM aService = GlobalAddAtomW(TEST_DDE_SERVICE);
1184 trace("server: got WM_DDE_INITIATE from %p with %08lx\n", (HWND)wparam, lparam);
1186 if (LOWORD(lparam) == aService)
1188 ok(!IsWindowUnicode((HWND)wparam), "client should be an ANSI window\n");
1189 old_dde_client_wndproc = (WNDPROC)SetWindowLongPtrA((HWND)wparam, GWLP_WNDPROC, (ULONG_PTR)hook_dde_client_wndproc);
1190 trace("server: sending WM_DDE_ACK to %p\n", (HWND)wparam);
1191 SendMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, PackDDElParam(WM_DDE_ACK, aService, 0));
1193 else
1194 GlobalDeleteAtom(aService);
1195 return 0;
1198 case WM_DDE_EXECUTE:
1200 DDEACK ack;
1201 WORD status;
1202 LPCSTR cmd;
1203 UINT_PTR lo, hi;
1205 trace("server: got WM_DDE_EXECUTE from %p with %08lx\n", (HWND)wparam, lparam);
1207 UnpackDDElParam(WM_DDE_EXECUTE, lparam, &lo, &hi);
1208 trace("%08lx => lo %04lx hi %04lx\n", lparam, lo, hi);
1210 ack.bAppReturnCode = 0;
1211 ack.reserved = 0;
1212 ack.fBusy = 0;
1214 cmd = GlobalLock((HGLOBAL)hi);
1215 if (!cmd || (lstrcmpA(cmd, exec_cmdA) && lstrcmpW((LPCWSTR)cmd, exec_cmdW)))
1217 trace("ignoring unknown WM_DDE_EXECUTE command\n");
1218 /* We have to send a negative acknowledge even if we don't
1219 * accept the command, otherwise Windows goes mad and next time
1220 * we send an acknowledge DDEML drops the connection.
1221 * Not sure how to call it: a bug or a feature.
1223 ack.fAck = 0;
1225 else
1226 ack.fAck = 1;
1227 GlobalUnlock((HGLOBAL)hi);
1229 trace("server: posting %s WM_DDE_ACK to %p\n", ack.fAck ? "POSITIVE" : "NEGATIVE", (HWND)wparam);
1231 status = *((WORD *)&ack);
1232 lparam = ReuseDDElParam(lparam, WM_DDE_EXECUTE, WM_DDE_ACK, status, hi);
1234 PostMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, lparam);
1235 return 0;
1238 case WM_DDE_TERMINATE:
1240 DDEACK ack;
1241 WORD status;
1243 trace("server: got WM_DDE_TERMINATE from %p with %08lx\n", (HWND)wparam, lparam);
1245 ack.bAppReturnCode = 0;
1246 ack.reserved = 0;
1247 ack.fBusy = 0;
1248 ack.fAck = 1;
1250 trace("server: posting %s WM_DDE_ACK to %p\n", ack.fAck ? "POSITIVE" : "NEGATIVE", (HWND)wparam);
1252 status = *((WORD *)&ack);
1253 lparam = PackDDElParam(WM_DDE_ACK, status, 0);
1255 PostMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, lparam);
1256 return 0;
1259 default:
1260 break;
1263 return DefWindowProcW(hwnd, msg, wparam, lparam);
1266 static LRESULT WINAPI dde_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
1268 return DefWindowProcA(hwnd, msg, wparam, lparam);
1271 static BOOL create_dde_windows(HWND *client, HWND *server)
1273 WNDCLASSA wcA;
1274 WNDCLASSW wcW;
1275 static const WCHAR server_class_name[] = {'d','d','e','_','s','e','r','v','e','r','_','w','i','n','d','o','w',0};
1276 static const char client_class_name[] = "dde_client_window";
1278 memset(&wcW, 0, sizeof(wcW));
1279 wcW.lpfnWndProc = dde_server_wndprocW;
1280 wcW.lpszClassName = server_class_name;
1281 wcW.hInstance = GetModuleHandleA(0);
1282 if (!RegisterClassW(&wcW)) return FALSE;
1284 memset(&wcA, 0, sizeof(wcA));
1285 wcA.lpfnWndProc = dde_client_wndproc;
1286 wcA.lpszClassName = client_class_name;
1287 wcA.hInstance = GetModuleHandleA(0);
1288 assert(RegisterClassA(&wcA));
1290 *server = CreateWindowExW(0, server_class_name, NULL,
1291 WS_POPUP,
1292 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
1293 GetDesktopWindow(), 0,
1294 GetModuleHandleA(0), NULL);
1295 assert(*server);
1297 *client = CreateWindowExA(0, client_class_name, NULL,
1298 WS_POPUP,
1299 100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
1300 GetDesktopWindow(), 0,
1301 GetModuleHandleA(0), NULL);
1302 assert(*client);
1304 trace("server hwnd %p, client hwnd %p\n", *server, *client);
1306 ok(IsWindowUnicode(*server), "server has to be a unicode window\n");
1307 ok(!IsWindowUnicode(*client), "client has to be an ANSI window\n");
1309 return TRUE;
1312 static HDDEDATA CALLBACK client_dde_callback(UINT uType, UINT uFmt, HCONV hconv,
1313 HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
1314 ULONG_PTR dwData1, ULONG_PTR dwData2)
1316 static const char * const cmd_type[15] = {
1317 "XTYP_ERROR", "XTYP_ADVDATA", "XTYP_ADVREQ", "XTYP_ADVSTART",
1318 "XTYP_ADVSTOP", "XTYP_EXECUTE", "XTYP_CONNECT", "XTYP_CONNECT_CONFIRM",
1319 "XTYP_XACT_COMPLETE", "XTYP_POKE", "XTYP_REGISTER", "XTYP_REQUEST",
1320 "XTYP_DISCONNECT", "XTYP_UNREGISTER", "XTYP_WILDCONNECT" };
1321 UINT type;
1322 const char *cmd_name;
1324 type = (uType & XTYP_MASK) >> XTYP_SHIFT;
1325 cmd_name = (type <= 14) ? cmd_type[type] : "unknown";
1327 trace("client_dde_callback: %04x (%s) %d %p %p %p %p %08lx %08lx\n",
1328 uType, cmd_name, uFmt, hconv, hsz1, hsz2, hdata, dwData1, dwData2);
1329 return 0;
1332 static void test_dde_aw_transaction(void)
1334 HSZ hsz_server;
1335 DWORD dde_inst, ret, err;
1336 HCONV hconv;
1337 HWND hwnd_client, hwnd_server;
1338 CONVINFO info;
1339 HDDEDATA hdata;
1340 static char test_cmd[] = "test dde command";
1342 /* server: unicode, client: ansi */
1343 if (!create_dde_windows(&hwnd_client, &hwnd_server)) return;
1345 dde_inst = 0;
1346 ret = DdeInitializeA(&dde_inst, client_dde_callback, APPCMD_CLIENTONLY, 0);
1347 ok(ret == DMLERR_NO_ERROR, "DdeInitializeA failed with error %04x (%x)\n",
1348 ret, DdeGetLastError(dde_inst));
1350 hsz_server = DdeCreateStringHandleW(dde_inst, TEST_DDE_SERVICE, CP_WINUNICODE);
1352 hconv = DdeConnect(dde_inst, hsz_server, 0, NULL);
1353 ok(hconv != 0, "DdeConnect error %x\n", DdeGetLastError(dde_inst));
1354 err = DdeGetLastError(dde_inst);
1355 ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
1357 info.cb = sizeof(info);
1358 ret = DdeQueryConvInfo(hconv, QID_SYNC, &info);
1359 ok(ret, "wrong info size %d, DdeQueryConvInfo error %x\n", ret, DdeGetLastError(dde_inst));
1360 /* should be CP_WINANSI since we used DdeInitializeA */
1361 ok(info.ConvCtxt.iCodePage == CP_WINANSI, "wrong iCodePage %d\n", info.ConvCtxt.iCodePage);
1362 ok(!info.hConvPartner, "unexpected info.hConvPartner: %p\n", info.hConvPartner);
1363 todo_wine {
1364 ok((info.wStatus & DDE_FACK), "unexpected info.wStatus: %04x\n", info.wStatus);
1366 ok((info.wStatus & (ST_CONNECTED | ST_CLIENT)) == (ST_CONNECTED | ST_CLIENT), "unexpected info.wStatus: %04x\n", info.wStatus);
1367 ok(info.wConvst == XST_CONNECTED, "unexpected info.wConvst: %04x\n", info.wConvst);
1368 ok(info.wType == 0, "unexpected info.wType: %04x\n", info.wType);
1370 trace("hwnd %p, hwndPartner %p\n", info.hwnd, info.hwndPartner);
1372 trace("sending test client transaction command\n");
1373 ret = 0xdeadbeef;
1374 hdata = DdeClientTransaction((LPBYTE)test_cmd, strlen(test_cmd) + 1, hconv, (HSZ)0xdead, 0xbeef, XTYP_EXECUTE, 1000, &ret);
1375 ok(!hdata, "DdeClientTransaction succeeded\n");
1376 ok(ret == DDE_FNOTPROCESSED, "wrong status code %04x\n", ret);
1377 err = DdeGetLastError(dde_inst);
1378 ok(err == DMLERR_NOTPROCESSED, "wrong dde error %x\n", err);
1380 trace("sending ANSI client transaction command\n");
1381 ret = 0xdeadbeef;
1382 hdata = DdeClientTransaction((LPBYTE)exec_cmdA, lstrlenA(exec_cmdA) + 1, hconv, 0, 0, XTYP_EXECUTE, 1000, &ret);
1383 ok(hdata != 0, "DdeClientTransaction returned %p, error %x\n", hdata, DdeGetLastError(dde_inst));
1384 ok(ret == DDE_FACK, "wrong status code %04x\n", ret);
1386 err = DdeGetLastError(dde_inst);
1387 ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
1389 trace("sending unicode client transaction command\n");
1390 ret = 0xdeadbeef;
1391 hdata = DdeClientTransaction((LPBYTE)exec_cmdW, (lstrlenW(exec_cmdW) + 1) * sizeof(WCHAR), hconv, 0, 0, XTYP_EXECUTE, 1000, &ret);
1392 ok(hdata != 0, "DdeClientTransaction returned %p, error %x\n", hdata, DdeGetLastError(dde_inst));
1393 ok(ret == DDE_FACK, "wrong status code %04x\n", ret);
1394 err = DdeGetLastError(dde_inst);
1395 ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
1397 ok(DdeDisconnect(hconv), "DdeDisconnect error %x\n", DdeGetLastError(dde_inst));
1399 info.cb = sizeof(info);
1400 ret = DdeQueryConvInfo(hconv, QID_SYNC, &info);
1401 ok(!ret, "DdeQueryConvInfo should fail\n");
1402 err = DdeGetLastError(dde_inst);
1403 todo_wine {
1404 ok(err == DMLERR_INVALIDPARAMETER, "wrong dde error %x\n", err);
1407 ok(DdeFreeStringHandle(dde_inst, hsz_server), "DdeFreeStringHandle error %x\n", DdeGetLastError(dde_inst));
1409 /* This call hangs on win2k SP4 and XP SP1.
1410 DdeUninitialize(dde_inst);*/
1412 DestroyWindow(hwnd_client);
1413 DestroyWindow(hwnd_server);
1416 static void test_initialisation(void)
1418 UINT ret;
1419 DWORD res;
1420 HDDEDATA hdata;
1421 HSZ server, topic, item;
1422 DWORD client_pid;
1423 HCONV conversation;
1425 /* Initialise without a valid server window. */
1426 client_pid = 0;
1427 ret = DdeInitializeA(&client_pid, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1428 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", ret);
1431 server = DdeCreateStringHandleA(client_pid, "TestDDEService", CP_WINANSI);
1432 topic = DdeCreateStringHandleA(client_pid, "TestDDETopic", CP_WINANSI);
1434 DdeGetLastError(client_pid);
1436 /* There is no server window so no conversation can be extracted */
1437 conversation = DdeConnect(client_pid, server, topic, NULL);
1438 ok(conversation == NULL, "Expected NULL conversation, %p\n", conversation);
1439 ret = DdeGetLastError(client_pid);
1440 ok(ret == DMLERR_NO_CONV_ESTABLISHED, "Expected DMLERR_NO_CONV_ESTABLISHED, got %d\n", ret);
1442 DdeFreeStringHandle(client_pid, server);
1444 item = DdeCreateStringHandleA(client_pid, "request", CP_WINANSI);
1446 /* There is no converstation so an invalild parameter results */
1447 res = 0xdeadbeef;
1448 DdeGetLastError(client_pid);
1449 hdata = DdeClientTransaction(NULL, 0, conversation, item, CF_TEXT, XTYP_REQUEST, default_timeout, &res);
1450 ret = DdeGetLastError(client_pid);
1451 todo_wine
1452 ok(ret == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", ret);
1453 ok(res == 0xdeadbeef, "Expected 0xdeadbeef, got %08x\n", res);
1455 DdeFreeStringHandle(client_pid, server);
1456 ret = DdeDisconnect(conversation);
1457 ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
1459 ret = DdeUninitialize(client_pid);
1460 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1463 static void test_DdeCreateStringHandleW(DWORD dde_inst, int codepage)
1465 static const WCHAR dde_string[] = {'D','D','E',' ','S','t','r','i','n','g',0};
1466 HSZ str_handle;
1467 WCHAR bufW[256];
1468 char buf[256];
1469 ATOM atom;
1470 int ret;
1472 str_handle = DdeCreateStringHandleW(dde_inst, dde_string, codepage);
1473 ok(str_handle != 0, "DdeCreateStringHandleW failed with error %08x\n",
1474 DdeGetLastError(dde_inst));
1476 ret = DdeQueryStringW(dde_inst, str_handle, NULL, 0, codepage);
1477 if (codepage == CP_WINANSI)
1478 ok(ret == 1, "DdeQueryStringW returned wrong length %d\n", ret);
1479 else
1480 ok(ret == lstrlenW(dde_string), "DdeQueryStringW returned wrong length %d\n", ret);
1482 ret = DdeQueryStringW(dde_inst, str_handle, bufW, 256, codepage);
1483 if (codepage == CP_WINANSI)
1485 ok(ret == 1, "DdeQueryStringW returned wrong length %d\n", ret);
1486 ok(!lstrcmpA("D", (LPCSTR)bufW), "DdeQueryStringW returned wrong string\n");
1488 else
1490 ok(ret == lstrlenW(dde_string), "DdeQueryStringW returned wrong length %d\n", ret);
1491 ok(!lstrcmpW(dde_string, bufW), "DdeQueryStringW returned wrong string\n");
1494 ret = DdeQueryStringA(dde_inst, str_handle, buf, 256, CP_WINANSI);
1495 if (codepage == CP_WINANSI)
1497 ok(ret == 1, "DdeQueryStringA returned wrong length %d\n", ret);
1498 ok(!lstrcmpA("D", buf), "DdeQueryStringW returned wrong string\n");
1500 else
1502 ok(ret == lstrlenA("DDE String"), "DdeQueryStringA returned wrong length %d\n", ret);
1503 ok(!lstrcmpA("DDE String", buf), "DdeQueryStringA returned wrong string %s\n", buf);
1506 ret = DdeQueryStringA(dde_inst, str_handle, buf, 256, CP_WINUNICODE);
1507 if (codepage == CP_WINANSI)
1509 ok(ret == 1, "DdeQueryStringA returned wrong length %d\n", ret);
1510 ok(!lstrcmpA("D", buf), "DdeQueryStringA returned wrong string %s\n", buf);
1512 else
1514 ok(ret == lstrlenA("DDE String"), "DdeQueryStringA returned wrong length %d\n", ret);
1515 ok(!lstrcmpW(dde_string, (LPCWSTR)buf), "DdeQueryStringW returned wrong string\n");
1518 if (codepage == CP_WINANSI)
1520 atom = FindAtomA((LPSTR)dde_string);
1521 ok(atom != 0, "Expected a valid atom\n");
1523 SetLastError(0xdeadbeef);
1524 atom = GlobalFindAtomA((LPSTR)dde_string);
1525 ok(atom == 0, "Expected 0, got %d\n", atom);
1526 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
1527 "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
1529 else
1531 atom = FindAtomW(dde_string);
1532 ok(atom != 0, "Expected a valid atom\n");
1534 SetLastError(0xdeadbeef);
1535 atom = GlobalFindAtomW(dde_string);
1536 ok(atom == 0, "Expected 0, got %d\n", atom);
1537 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
1538 "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
1541 ok(DdeFreeStringHandle(dde_inst, str_handle), "DdeFreeStringHandle failed\n");
1544 static void test_DdeCreateDataHandle(void)
1546 HDDEDATA hdata;
1547 DWORD dde_inst, dde_inst2;
1548 DWORD size;
1549 UINT res, err;
1550 BOOL ret;
1551 HSZ item;
1552 LPBYTE ptr;
1553 WCHAR item_str[] = {'i','t','e','m',0};
1555 dde_inst = 0;
1556 dde_inst2 = 0;
1557 res = DdeInitializeA(&dde_inst, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1558 ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
1560 res = DdeInitializeA(&dde_inst2, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1561 ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
1563 /* 0 instance id
1564 * This block tests an invalid instance Id. The correct behaviour is that if the instance Id
1565 * is invalid then the lastError of all instances is set to the error. There are two instances
1566 * created, lastError is cleared, an error is generated and then both instances are checked to
1567 * ensure that they both have the same error set
1569 item = DdeCreateStringHandleA(0, "item", CP_WINANSI);
1570 ok(item == NULL, "Expected NULL hsz got %p\n", item);
1571 err = DdeGetLastError(dde_inst);
1572 ok(err == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1573 err = DdeGetLastError(dde_inst2);
1574 ok(err == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1575 item = DdeCreateStringHandleW(0, item_str, CP_WINUNICODE);
1576 ok(item == NULL, "Expected NULL hsz got %p\n", item);
1577 err = DdeGetLastError(dde_inst);
1578 ok(err == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1579 err = DdeGetLastError(dde_inst2);
1580 ok(err == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1582 item = DdeCreateStringHandleA(dde_inst, "item", CP_WINANSI);
1583 ok(item != NULL, "Expected non-NULL hsz\n");
1584 item = DdeCreateStringHandleA(dde_inst2, "item", CP_WINANSI);
1585 ok(item != NULL, "Expected non-NULL hsz\n");
1587 if (0) {
1588 /* do not test with an invalid instance id: that crashes on win9x */
1589 hdata = DdeCreateDataHandle(0xdeadbeef, (LPBYTE)"data", MAX_PATH, 0, item, CF_TEXT, 0);
1592 /* 0 instance id
1593 * This block tests an invalid instance Id. The correct behaviour is that if the instance Id
1594 * is invalid then the lastError of all instances is set to the error. There are two instances
1595 * created, lastError is cleared, an error is generated and then both instances are checked to
1596 * ensure that they both have the same error set
1598 DdeGetLastError(dde_inst);
1599 DdeGetLastError(dde_inst2);
1600 hdata = DdeCreateDataHandle(0, (LPBYTE)"data", MAX_PATH, 0, item, CF_TEXT, 0);
1601 err = DdeGetLastError(dde_inst);
1602 ok(hdata == NULL, "Expected NULL, got %p\n", hdata);
1603 ok(err == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1604 err = DdeGetLastError(dde_inst2);
1605 ok(err == DMLERR_INVALIDPARAMETER, "Expected DMLERR_INVALIDPARAMETER, got %d\n", err);
1607 ret = DdeUninitialize(dde_inst2);
1608 ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
1611 /* NULL pSrc */
1612 DdeGetLastError(dde_inst);
1613 hdata = DdeCreateDataHandle(dde_inst, NULL, MAX_PATH, 0, item, CF_TEXT, 0);
1614 err = DdeGetLastError(dde_inst);
1615 ok(hdata != NULL, "Expected non-NULL hdata\n");
1616 ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1618 ptr = GlobalLock(hdata);
1619 todo_wine
1621 ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1624 ptr = DdeAccessData(hdata, &size);
1625 ok(ptr != NULL, "Expected non-NULL ptr\n");
1626 ok(size == 260, "Expected 260, got %d\n", size);
1628 ret = DdeUnaccessData(hdata);
1629 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1631 ret = DdeFreeDataHandle(hdata);
1632 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1634 /* cb is zero */
1635 DdeGetLastError(dde_inst);
1636 hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", 0, 0, item, CF_TEXT, 0);
1637 err = DdeGetLastError(dde_inst);
1638 ok(hdata != NULL, "Expected non-NULL hdata\n");
1639 ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1641 ptr = GlobalLock(hdata);
1642 todo_wine
1644 ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1647 ptr = DdeAccessData(hdata, &size);
1648 ok(ptr != NULL, "Expected non-NULL ptr\n");
1649 ok(size == 0, "Expected 0, got %d\n", size);
1651 ret = DdeUnaccessData(hdata);
1652 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1654 ret = DdeFreeDataHandle(hdata);
1655 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1657 /* cbOff is non-zero */
1658 DdeGetLastError(dde_inst);
1659 hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 2, item, CF_TEXT, 0);
1660 err = DdeGetLastError(dde_inst);
1661 ok(hdata != NULL, "Expected non-NULL hdata\n");
1662 ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1664 ptr = GlobalLock(hdata);
1665 todo_wine
1667 ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1670 ptr = DdeAccessData(hdata, &size);
1671 ok(ptr != NULL, "Expected non-NULL ptr\n");
1672 ok(size == 262, "Expected 262, got %d\n", size);
1673 todo_wine
1675 ok(lstrlenA((LPSTR)ptr) == 0, "Expected 0, got %d\n", lstrlenA((LPSTR)ptr));
1678 ret = DdeUnaccessData(hdata);
1679 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1681 ret = DdeFreeDataHandle(hdata);
1682 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1684 /* NULL item */
1685 DdeGetLastError(dde_inst);
1686 hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 0, 0, CF_TEXT, 0);
1687 err = DdeGetLastError(dde_inst);
1688 ok(hdata != NULL, "Expected non-NULL hdata\n");
1689 ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1691 ptr = GlobalLock(hdata);
1692 todo_wine
1694 ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1697 ptr = DdeAccessData(hdata, &size);
1698 ok(ptr != NULL, "Expected non-NULL ptr\n");
1699 ok(!lstrcmpA((LPSTR)ptr, "data"), "Expected data, got %s\n", ptr);
1700 ok(size == 260, "Expected 260, got %d\n", size);
1702 ret = DdeUnaccessData(hdata);
1703 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1705 ret = DdeFreeDataHandle(hdata);
1706 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1708 /* NULL item */
1709 DdeGetLastError(dde_inst);
1710 hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 0, (HSZ)0xdeadbeef, CF_TEXT, 0);
1711 err = DdeGetLastError(dde_inst);
1712 ok(hdata != NULL, "Expected non-NULL hdata\n");
1713 ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1715 ptr = GlobalLock(hdata);
1716 todo_wine
1718 ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1721 ptr = DdeAccessData(hdata, &size);
1722 ok(ptr != NULL, "Expected non-NULL ptr\n");
1723 ok(!lstrcmpA((LPSTR)ptr, "data"), "Expected data, got %s\n", ptr);
1724 ok(size == 260, "Expected 260, got %d\n", size);
1726 ret = DdeUnaccessData(hdata);
1727 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1729 ret = DdeFreeDataHandle(hdata);
1730 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1732 /* invalid clipboard format */
1733 DdeGetLastError(dde_inst);
1734 hdata = DdeCreateDataHandle(dde_inst, (LPBYTE)"data", MAX_PATH, 0, item, 0xdeadbeef, 0);
1735 err = DdeGetLastError(dde_inst);
1736 ok(hdata != NULL, "Expected non-NULL hdata\n");
1737 ok(err == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", err);
1739 ptr = GlobalLock(hdata);
1740 todo_wine
1742 ok(ptr == NULL, "Expected NULL, got %p\n", ptr);
1745 ptr = DdeAccessData(hdata, &size);
1746 ok(ptr != NULL, "Expected non-NULL ptr\n");
1747 ok(!lstrcmpA((LPSTR)ptr, "data"), "Expected data, got %s\n", ptr);
1748 ok(size == 260, "Expected 260, got %d\n", size);
1750 ret = DdeUnaccessData(hdata);
1751 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1753 ret = DdeFreeDataHandle(hdata);
1754 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1756 ret = DdeUninitialize(dde_inst);
1757 ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
1760 static void test_DdeCreateStringHandle(void)
1762 DWORD dde_inst, ret;
1764 dde_inst = 0xdeadbeef;
1765 SetLastError(0xdeadbeef);
1766 ret = DdeInitializeW(&dde_inst, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1767 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1769 win_skip("DdeInitializeW is unimplemented\n");
1770 return;
1773 ok(ret == DMLERR_INVALIDPARAMETER, "DdeInitializeW should fail, but got %04x instead\n", ret);
1774 ok(DdeGetLastError(dde_inst) == DMLERR_INVALIDPARAMETER, "expected DMLERR_INVALIDPARAMETER\n");
1776 dde_inst = 0;
1777 ret = DdeInitializeW(&dde_inst, client_ddeml_callback, APPCMD_CLIENTONLY, 0);
1778 ok(ret == DMLERR_NO_ERROR, "DdeInitializeW failed with error %04x (%08x)\n",
1779 ret, DdeGetLastError(dde_inst));
1781 test_DdeCreateStringHandleW(dde_inst, 0);
1782 test_DdeCreateStringHandleW(dde_inst, CP_WINUNICODE);
1783 test_DdeCreateStringHandleW(dde_inst, CP_WINANSI);
1785 ok(DdeUninitialize(dde_inst), "DdeUninitialize failed\n");
1788 static void test_FreeDDElParam(void)
1790 HGLOBAL val, hglobal;
1791 BOOL ret;
1793 ret = FreeDDElParam(WM_DDE_INITIATE, 0);
1794 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1796 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1797 ret = FreeDDElParam(WM_DDE_INITIATE, (LPARAM)hglobal);
1798 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1799 val = GlobalFree(hglobal);
1800 ok(val == NULL, "Expected NULL, got %p\n", val);
1802 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1803 ret = FreeDDElParam(WM_DDE_ADVISE, (LPARAM)hglobal);
1804 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1806 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1807 ret = FreeDDElParam(WM_DDE_UNADVISE, (LPARAM)hglobal);
1808 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1809 val = GlobalFree(hglobal);
1810 ok(val == NULL, "Expected NULL, got %p\n", val);
1812 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1813 ret = FreeDDElParam(WM_DDE_ACK, (LPARAM)hglobal);
1814 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1816 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1817 ret = FreeDDElParam(WM_DDE_DATA, (LPARAM)hglobal);
1818 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1820 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1821 ret = FreeDDElParam(WM_DDE_REQUEST, (LPARAM)hglobal);
1822 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1823 val = GlobalFree(hglobal);
1824 ok(val == NULL, "Expected NULL, got %p\n", val);
1826 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1827 ret = FreeDDElParam(WM_DDE_POKE, (LPARAM)hglobal);
1828 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1830 hglobal = GlobalAlloc(GMEM_DDESHARE, 100);
1831 ret = FreeDDElParam(WM_DDE_EXECUTE, (LPARAM)hglobal);
1832 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1833 val = GlobalFree(hglobal);
1834 ok(val == NULL, "Expected NULL, got %p\n", val);
1837 static void test_PackDDElParam(void)
1839 UINT_PTR lo, hi, *ptr;
1840 LPARAM lparam;
1841 BOOL ret;
1843 lparam = PackDDElParam(WM_DDE_INITIATE, 0xcafe, 0xbeef);
1844 /* value gets sign-extended despite being an LPARAM */
1845 ok(lparam == (int)0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1847 lo = hi = 0;
1848 ret = UnpackDDElParam(WM_DDE_INITIATE, lparam, &lo, &hi);
1849 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1850 ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1851 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1853 ret = FreeDDElParam(WM_DDE_INITIATE, lparam);
1854 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1856 lparam = PackDDElParam(WM_DDE_TERMINATE, 0xcafe, 0xbeef);
1857 ok(lparam == (int)0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1859 lo = hi = 0;
1860 ret = UnpackDDElParam(WM_DDE_TERMINATE, lparam, &lo, &hi);
1861 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1862 ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1863 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1865 ret = FreeDDElParam(WM_DDE_TERMINATE, lparam);
1866 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1868 lparam = PackDDElParam(WM_DDE_ADVISE, 0xcafe, 0xbeef);
1869 /* win9x returns 0 here */
1870 if (lparam) {
1871 ptr = GlobalLock((HGLOBAL)lparam);
1872 ok(ptr != NULL, "Expected non-NULL ptr\n");
1873 ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1874 ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1876 ret = GlobalUnlock((HGLOBAL)lparam);
1877 ok(ret == 1, "Expected 1, got %d\n", ret);
1879 lo = hi = 0;
1880 ret = UnpackDDElParam(WM_DDE_ADVISE, lparam, &lo, &hi);
1881 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1882 ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1883 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1885 else
1886 win_skip("no lparam for WM_DDE_ADVISE\n");
1888 ret = FreeDDElParam(WM_DDE_ADVISE, lparam);
1889 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1891 lparam = PackDDElParam(WM_DDE_UNADVISE, 0xcafe, 0xbeef);
1892 ok(lparam == (int)0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1894 lo = hi = 0;
1895 ret = UnpackDDElParam(WM_DDE_UNADVISE, 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);
1900 ret = FreeDDElParam(WM_DDE_UNADVISE, lparam);
1901 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1903 lparam = PackDDElParam(WM_DDE_ACK, 0xcafe, 0xbeef);
1904 /* win9x returns the input (0xbeef<<16 | 0xcafe) here */
1905 if (lparam != (int)0xbeefcafe) {
1906 ptr = GlobalLock((HGLOBAL)lparam);
1907 ok(ptr != NULL, "Expected non-NULL ptr\n");
1908 ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1909 ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1911 ret = GlobalUnlock((HGLOBAL)lparam);
1912 ok(ret == 1, "Expected 1, got %d\n", ret);
1914 lo = hi = 0;
1915 ret = UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
1916 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1917 ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1918 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1920 ret = FreeDDElParam(WM_DDE_ACK, lparam);
1921 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1923 else
1924 win_skip("got lparam 0x%lx for WM_DDE_ACK\n", lparam);
1926 lparam = PackDDElParam(WM_DDE_DATA, 0xcafe, 0xbeef);
1927 /* win9x returns 0 here */
1928 if (lparam) {
1929 ptr = GlobalLock((HGLOBAL)lparam);
1930 ok(ptr != NULL, "Expected non-NULL ptr\n");
1931 ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1932 ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1934 ret = GlobalUnlock((HGLOBAL)lparam);
1935 ok(ret == 1, "Expected 1, got %d\n", ret);
1937 lo = hi = 0;
1938 ret = UnpackDDElParam(WM_DDE_DATA, lparam, &lo, &hi);
1939 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1940 ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1941 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1943 else
1944 win_skip("no lparam for WM_DDE_DATA\n");
1946 ret = FreeDDElParam(WM_DDE_DATA, lparam);
1947 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1949 lparam = PackDDElParam(WM_DDE_REQUEST, 0xcafe, 0xbeef);
1950 ok(lparam == (int)0xbeefcafe, "Expected 0xbeefcafe, got %08lx\n", lparam);
1952 lo = hi = 0;
1953 ret = UnpackDDElParam(WM_DDE_REQUEST, lparam, &lo, &hi);
1954 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1955 ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1956 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1958 ret = FreeDDElParam(WM_DDE_REQUEST, lparam);
1959 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1961 lparam = PackDDElParam(WM_DDE_POKE, 0xcafe, 0xbeef);
1962 /* win9x returns 0 here */
1963 if (lparam) {
1964 ptr = GlobalLock((HGLOBAL)lparam);
1965 ok(ptr != NULL, "Expected non-NULL ptr\n");
1966 ok(ptr[0] == 0xcafe, "Expected 0xcafe, got %08lx\n", ptr[0]);
1967 ok(ptr[1] == 0xbeef, "Expected 0xbeef, got %08lx\n", ptr[1]);
1969 ret = GlobalUnlock((HGLOBAL)lparam);
1970 ok(ret == 1, "Expected 1, got %d\n", ret);
1972 lo = hi = 0;
1973 ret = UnpackDDElParam(WM_DDE_POKE, lparam, &lo, &hi);
1974 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1975 ok(lo == 0xcafe, "Expected 0xcafe, got %08lx\n", lo);
1976 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1978 else
1979 win_skip("no lparam for WM_DDE_POKE\n");
1981 ret = FreeDDElParam(WM_DDE_POKE, lparam);
1982 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1984 lparam = PackDDElParam(WM_DDE_EXECUTE, 0xcafe, 0xbeef);
1985 ok(lparam == 0xbeef, "Expected 0xbeef, got %08lx\n", lparam);
1987 lo = hi = 0;
1988 ret = UnpackDDElParam(WM_DDE_EXECUTE, lparam, &lo, &hi);
1989 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1990 ok(lo == 0, "Expected 0, got %08lx\n", lo);
1991 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
1993 ret = FreeDDElParam(WM_DDE_EXECUTE, lparam);
1994 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
1997 static void test_UnpackDDElParam(void)
1999 UINT_PTR lo, hi, *ptr;
2000 HGLOBAL hglobal;
2001 BOOL ret;
2003 /* NULL lParam */
2004 lo = 0xdead;
2005 hi = 0xbeef;
2006 ret = UnpackDDElParam(WM_DDE_INITIATE, 0, &lo, &hi);
2007 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2008 ok(lo == 0, "Expected 0, got %08lx\n", lo);
2009 ok(hi == 0, "Expected 0, got %08lx\n", hi);
2011 /* NULL lo */
2012 lo = 0xdead;
2013 hi = 0xbeef;
2014 ret = UnpackDDElParam(WM_DDE_INITIATE, 0xcafebabe, NULL, &hi);
2015 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2016 ok(lo == 0xdead, "Expected 0xdead, got %08lx\n", lo);
2017 ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2019 /* NULL hi */
2020 lo = 0xdead;
2021 hi = 0xbeef;
2022 ret = UnpackDDElParam(WM_DDE_INITIATE, 0xcafebabe, &lo, NULL);
2023 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2024 ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
2025 ok(hi == 0xbeef, "Expected 0xbeef, got %08lx\n", hi);
2027 lo = 0xdead;
2028 hi = 0xbeef;
2029 ret = UnpackDDElParam(WM_DDE_INITIATE, 0xcafebabe, &lo, &hi);
2030 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2031 ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
2032 ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2034 lo = 0xdead;
2035 hi = 0xbeef;
2036 ret = UnpackDDElParam(WM_DDE_TERMINATE, 0xcafebabe, &lo, &hi);
2037 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2038 ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
2039 ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2041 lo = 0xdead;
2042 hi = 0xbeef;
2043 ret = UnpackDDElParam(WM_DDE_ADVISE, 0, &lo, &hi);
2044 ok(ret == FALSE, "Expected FALSE, got %d\n", ret);
2045 ok(lo == 0 ||
2046 broken(lo == 0xdead), /* win2k */
2047 "Expected 0, got %08lx\n", lo);
2048 ok(hi == 0 ||
2049 broken(hi == 0xbeef), /* win2k */
2050 "Expected 0, got %08lx\n", hi);
2052 hglobal = GlobalAlloc(GMEM_DDESHARE, 2);
2053 ptr = GlobalLock(hglobal);
2054 ptr[0] = 0xcafebabe;
2055 ptr[1] = 0xdeadbeef;
2056 GlobalUnlock(hglobal);
2058 lo = 0xdead;
2059 hi = 0xbeef;
2060 ret = UnpackDDElParam(WM_DDE_ADVISE, (LPARAM)hglobal, &lo, &hi);
2061 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2062 ok(lo == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", lo);
2063 ok(hi == 0xdeadbeef, "Expected 0xdeadbeef, got %08lx\n", hi);
2065 lo = 0xdead;
2066 hi = 0xbeef;
2067 ret = UnpackDDElParam(WM_DDE_UNADVISE, 0xcafebabe, &lo, &hi);
2068 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2069 ok(lo == 0xbabe, "Expected 0xbabe, got %08lx\n", lo);
2070 ok(hi == 0xcafe, "Expected 0xcafe, got %08lx\n", hi);
2072 lo = 0xdead;
2073 hi = 0xbeef;
2074 ret = UnpackDDElParam(WM_DDE_ACK, (LPARAM)hglobal, &lo, &hi);
2075 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2076 ok(lo == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", lo);
2077 ok(hi == 0xdeadbeef, "Expected 0xdeadbeef, got %08lx\n", hi);
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);
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);
2093 lo = 0xdead;
2094 hi = 0xbeef;
2095 ret = UnpackDDElParam(WM_DDE_POKE, (LPARAM)hglobal, &lo, &hi);
2096 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2097 ok(lo == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", lo);
2098 ok(hi == 0xdeadbeef, "Expected 0xdeadbeef, got %08lx\n", hi);
2100 lo = 0xdead;
2101 hi = 0xbeef;
2102 ret = UnpackDDElParam(WM_DDE_EXECUTE, 0xcafebabe, &lo, &hi);
2103 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2104 ok(lo == 0, "Expected 0, got %08lx\n", lo);
2105 ok(hi == 0xcafebabe, "Expected 0xcafebabe, got %08lx\n", hi);
2108 static HDDEDATA CALLBACK server_end_to_end_callback(UINT uType, UINT uFmt, HCONV hconv,
2109 HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
2110 ULONG_PTR dwData1, ULONG_PTR dwData2)
2112 DWORD size, rsize;
2113 char str[MAX_PATH];
2114 static int msg_index = 0;
2115 static HCONV conversation = 0;
2116 static char test_cmd_w_to_a[] = "test dde command";
2117 static char test_cmd_a_to_a[] = "Test dde command";
2118 static WCHAR test_cmd_w_to_w[] = {'t','e','s','t',' ','d','d','e',' ','c','o','m','m','a','n','d',0};
2119 static WCHAR test_cmd_a_to_w[] = {'T','e','s','t',' ','d','d','e',' ','c','o','m','m','a','n','d',0};
2120 static char test_service [] = "TestDDEService";
2121 static char test_topic [] = "TestDDETopic";
2123 msg_index++;
2125 switch (uType)
2127 case XTYP_REGISTER:
2129 ok(msg_index == 1 || msg_index == 7 || msg_index == 13 || msg_index == 19,
2130 "Expected 1, 7, 13 or 19, got %d\n", msg_index);
2131 return (HDDEDATA)TRUE;
2134 case XTYP_CONNECT:
2136 ok(msg_index == 2 || msg_index == 8 || msg_index == 14 || msg_index == 20,
2137 "Expected 2, 8, 14 or 20, got %d\n", msg_index);
2138 ok(uFmt == 0, "Expected 0, got %d, msg_index=%d\n", uFmt, msg_index);
2139 ok(hconv == 0, "Expected 0, got %p, msg_index=%d\n", hconv, msg_index);
2140 ok(hdata == 0, "Expected 0, got %p, msg_index=%d\n", hdata, msg_index);
2141 ok(dwData1 != 0, "Expected not 0, got %08lx, msg_index=%d\n", dwData1, msg_index);
2142 ok(dwData2 == FALSE, "Expected FALSE, got %08lx, msg_index=%d\n", dwData2, msg_index);
2144 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
2145 ok(!lstrcmpA(str, test_topic), "Expected %s, got %s, msg_index=%d\n",
2146 test_topic, str, msg_index);
2147 ok(size == 12, "Expected 12, got %d, msg_index=%d\n", size, msg_index);
2149 size = DdeQueryStringA(server_pid, hsz2, str, MAX_PATH, CP_WINANSI);
2150 ok(!lstrcmpA(str, test_service), "Expected %s, got %s, msg_index=%d\n",
2151 test_service, str, msg_index);
2152 ok(size == 14, "Expected 14, got %d, msg_index=%d\n", size, msg_index);
2154 return (HDDEDATA) TRUE;
2156 case XTYP_CONNECT_CONFIRM:
2158 ok(msg_index == 3 || msg_index == 9 || msg_index == 15 || msg_index == 21,
2159 "Expected 3, 9, 15 or 21 got %d\n", msg_index);
2160 conversation = hconv;
2161 return (HDDEDATA) TRUE;
2163 case XTYP_EXECUTE:
2165 BYTE *buffer = NULL;
2167 ok(msg_index == 4 || msg_index == 5 || msg_index == 10 || msg_index == 11 ||
2168 msg_index == 16 || msg_index == 17 || msg_index == 22 || msg_index == 23,
2169 "Expected 4, 5, 10, 11, 16, 17, 22 or 23, got %d\n", msg_index);
2170 ok(uFmt == 0, "Expected 0, got %d\n", uFmt);
2171 ok(hconv == conversation, "Expected conversation handle, got %p, msg_index=%d\n",
2172 hconv, msg_index);
2173 ok(dwData1 == 0, "Expected 0, got %08lx, msg_index=%d\n", dwData1, msg_index);
2174 ok(dwData2 == 0, "Expected 0, got %08lx, msg_index=%d\n", dwData2, msg_index);
2175 ok(hsz2 == 0, "Expected 0, got %p, msg_index=%d\n", hsz2, msg_index);
2176 size = DdeQueryStringA(server_pid, hsz1, str, MAX_PATH, CP_WINANSI);
2177 ok(!lstrcmpA(str, test_topic), "Expected %s, got %s, msg_index=%d\n",
2178 test_topic, str, msg_index);
2179 ok(size == 12, "Expected 12, got %d, msg_index=%d\n", size, msg_index);
2180 ok(size == 12, "Expected 12, got %d, msg_index=%d\n", size, msg_index);
2182 size = DdeGetData(hdata, NULL, 0, 0);
2183 if (msg_index == 10 || msg_index ==11 || msg_index == 16 || msg_index ==17)
2184 if (msg_index == 10 || msg_index == 16)
2185 todo_wine
2186 ok(size == 34, "Expected that size should be 34 not %d, msg_index=%d\n",
2187 size, msg_index);
2188 else
2189 ok(size == 34, "Expected that size should be 34 not %d, msg_index=%d\n",
2190 size, msg_index);
2191 else
2192 if (msg_index ==22)
2193 ok(size == 8 || size == 9, "Expected that size should be 8 or 9 not %d, msg_index=%d\n",
2194 size, msg_index);
2195 else
2196 if (msg_index == 5)
2197 todo_wine
2198 ok(size == 17, "Expected that size should be 17 not %d, msg_index=%d\n",
2199 size, msg_index);
2200 else
2201 ok(size == 17, "Expected that size should be 17 not %d, msg_index=%d\n",
2202 size, msg_index);
2203 ok((buffer = HeapAlloc(GetProcessHeap(), 0, size)) != NULL, "should not be null\n");
2204 rsize = DdeGetData(hdata, buffer, size, 0);
2205 if (msg_index == 10 || msg_index == 11 || msg_index == 16 || msg_index ==17)
2207 ok(rsize == size, "Incorrect size returned, expected %d got %d, msg_index=%d\n",
2208 size, rsize, msg_index);
2209 if (msg_index == 10 || msg_index == 16)
2210 todo_wine {
2211 ok(!lstrcmpW((WCHAR*)buffer, test_cmd_a_to_w),
2212 "Expected \"Test dde command\", msg_index=%d\n",
2213 msg_index);
2214 ok(size == 34, "Expected 34, got %d, msg_index=%d\n", size, msg_index);
2215 } else
2217 ok(!lstrcmpW((WCHAR*)buffer, test_cmd_w_to_w),
2218 "Expected \"test dde command\", msg_index=%d\n",
2219 msg_index);
2220 ok(size == 34, "Expected 34, got %d, msg_index=%d\n", size, msg_index);
2222 }else if (msg_index == 22)
2224 ok(rsize == size, "Incorrect size returned, expected %d got %d, msg_index=%d\n",
2225 size, rsize, msg_index);
2226 } else
2228 ok(rsize == size, "Incorrect size returned, expected %d got %d, msg_index=%d\n",
2229 size, rsize, msg_index);
2230 if (msg_index == 5)
2231 todo_wine {
2232 ok(!lstrcmpA((CHAR*)buffer, test_cmd_w_to_a), "Expected %s, got %s, msg_index=%d\n",
2233 test_cmd_w_to_a, buffer, msg_index);
2234 ok(size == 17, "Expected size should be 17, got %d, msg_index=%d\n", size, msg_index);
2236 else if (msg_index == 23)
2238 ok(!lstrcmpA((CHAR*)buffer, test_cmd_w_to_a), "Expected %s, got %s, msg_index=%d\n",
2239 test_cmd_w_to_a, buffer, msg_index);
2240 ok(size == 17, "Expected size should be 17, got %d, msg_index=%d\n", size, msg_index);
2242 else
2244 ok(!lstrcmpA((CHAR*)buffer, test_cmd_a_to_a), "Expected %s, got %s, msg_index=%d\n",
2245 test_cmd_a_to_a, buffer, msg_index);
2246 ok(size == 17, "Expected size should be 17, got %d, msg_index=%d\n", size, msg_index);
2251 return (HDDEDATA) DDE_FACK;
2253 case XTYP_DISCONNECT:
2254 return (HDDEDATA) TRUE;
2256 default:
2257 ok(FALSE, "Unhandled msg: %08x, msg_index=%d\n", uType, msg_index);
2260 return NULL;
2263 static HDDEDATA CALLBACK client_end_to_end_callback(UINT uType, UINT uFmt, HCONV hconv,
2264 HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
2265 ULONG_PTR dwData1, ULONG_PTR dwData2)
2267 switch (uType)
2269 case XTYP_DISCONNECT:
2270 return (HDDEDATA) TRUE;
2272 default:
2273 ok(FALSE, "Unhandled msg: %08x\n", uType);
2276 return NULL;
2279 static void test_end_to_end_client(BOOL type_a)
2281 DWORD ret, err;
2282 DWORD client_pid = 0;
2283 HSZ server, topic;
2284 HCONV hconv;
2285 HDDEDATA hdata;
2286 static char test_cmd[] = "Test dde command";
2287 static WCHAR test_cmd_w[] = {'t','e','s','t',' ','d','d','e',' ','c','o','m','m','a','n','d',0};
2288 static char test_service[] = "TestDDEService";
2289 static WCHAR test_service_w[] = {'T','e','s','t','D','D','E','S','e','r','v','i','c','e',0};
2290 static char test_topic[] = "TestDDETopic";
2291 static WCHAR test_topic_w[] = {'T','e','s','t','D','D','E','T','o','p','i','c',0};
2293 trace("Start end to end client %s\n", type_a ? "ASCII" : "UNICODE");
2295 if (type_a)
2296 ret = DdeInitializeA(&client_pid, client_end_to_end_callback, APPCMD_CLIENTONLY, 0);
2297 else
2298 ret = DdeInitializeW(&client_pid, client_end_to_end_callback, APPCMD_CLIENTONLY, 0);
2299 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %x\n", ret);
2301 if (type_a)
2303 server = DdeCreateStringHandleA(client_pid, test_service, CP_WINANSI);
2304 topic = DdeCreateStringHandleA(client_pid, test_topic, CP_WINANSI);
2306 else {
2307 server = DdeCreateStringHandleW(client_pid, test_service_w, CP_WINUNICODE);
2308 topic = DdeCreateStringHandleW(client_pid, test_topic_w, CP_WINUNICODE);
2311 DdeGetLastError(client_pid);
2312 hconv = DdeConnect(client_pid, server, topic, NULL);
2313 ok(hconv != NULL, "Expected non-NULL conversation\n");
2314 ret = DdeGetLastError(client_pid);
2315 ok(ret == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %x\n", ret);
2316 DdeFreeStringHandle(client_pid, server);
2318 /* Test both A and W data being passed to DdeClientTransaction */
2319 hdata = DdeClientTransaction((LPBYTE)test_cmd, strlen(test_cmd) + 1,
2320 hconv, (HSZ)0xdead, 0xbeef, XTYP_EXECUTE, 1000, &ret);
2321 ok(hdata != NULL, "DdeClientTransaction failed\n");
2322 ok(ret == DDE_FACK, "wrong status code %x\n", ret);
2323 err = DdeGetLastError(client_pid);
2324 ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
2326 hdata = DdeClientTransaction((LPBYTE)test_cmd_w, lstrlenW(test_cmd_w) * sizeof(WCHAR) + 2,
2327 hconv, (HSZ)0xdead, 0xbeef, XTYP_EXECUTE, 1000, &ret);
2328 ok(hdata != NULL, "DdeClientTransaction failed\n");
2329 ok(ret == DDE_FACK, "wrong status code %x\n", ret);
2330 err = DdeGetLastError(client_pid);
2331 ok(err == DMLERR_NO_ERROR, "wrong dde error %x\n", err);
2333 DdeFreeStringHandle(client_pid, topic);
2334 ret = DdeDisconnect(hconv);
2335 ok(ret == TRUE, "Expected TRUE, got %x\n", ret);
2337 ret = DdeUninitialize(client_pid);
2338 ok(ret == TRUE, "Expected TRUE, got %x\n", ret);
2342 static void test_end_to_end_server(HANDLE hproc, HANDLE hthread, BOOL type_a)
2344 MSG msg;
2345 HSZ server;
2346 BOOL ret;
2347 DWORD res;
2348 HDDEDATA hdata;
2349 static CHAR test_service[] = "TestDDEService";
2351 trace("start end to end server %s\n", type_a ? "ASCII" : "UNICODE");
2352 server_pid = 0;
2354 if (type_a)
2355 res = DdeInitializeA(&server_pid, server_end_to_end_callback, APPCLASS_STANDARD, 0);
2356 else
2357 res = DdeInitializeW(&server_pid, server_end_to_end_callback, APPCLASS_STANDARD, 0);
2358 ok(res == DMLERR_NO_ERROR, "Expected DMLERR_NO_ERROR, got %d\n", res);
2360 server = DdeCreateStringHandleA(server_pid, test_service, CP_WINANSI);
2361 ok(server != NULL, "Expected non-NULL string handle\n");
2363 hdata = DdeNameService(server_pid, server, 0, DNS_REGISTER);
2364 ok(hdata == (HDDEDATA)TRUE, "Expected TRUE, got %p\n", hdata);
2365 ResumeThread( hthread );
2368 while (MsgWaitForMultipleObjects( 1, &hproc, FALSE, INFINITE, QS_ALLINPUT ) != 0)
2370 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
2373 ret = DdeUninitialize(server_pid);
2374 ok(ret == TRUE, "Expected TRUE, got %d\n", ret);
2375 GetExitCodeProcess( hproc, &res );
2376 ok( !res, "client failed with %u error(s)\n", res );
2379 START_TEST(dde)
2381 int argc;
2382 char **argv;
2383 char buffer[MAX_PATH];
2384 STARTUPINFO startup;
2385 PROCESS_INFORMATION proc;
2387 argc = winetest_get_mainargs(&argv);
2388 if (argc == 3)
2390 if (!lstrcmpA(argv[2], "ddeml"))
2391 test_ddeml_client();
2392 else if (!lstrcmpA(argv[2], "msg"))
2393 test_msg_client();
2394 else if (!lstrcmpA(argv[2], "enda"))
2395 test_end_to_end_client(TRUE);
2396 else if (!lstrcmpA(argv[2], "endw"))
2397 test_end_to_end_client(FALSE);
2399 return;
2402 test_initialisation();
2404 ZeroMemory(&startup, sizeof(STARTUPINFO));
2405 sprintf(buffer, "%s dde ddeml", argv[0]);
2406 startup.cb = sizeof(startup);
2407 startup.dwFlags = STARTF_USESHOWWINDOW;
2408 startup.wShowWindow = SW_SHOWNORMAL;
2410 CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2411 CREATE_SUSPENDED, NULL, NULL, &startup, &proc);
2413 test_msg_server(proc.hProcess, proc.hThread);
2415 sprintf(buffer, "%s dde msg", argv[0]);
2416 CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2417 0, NULL, NULL, &startup, &proc);
2419 test_ddeml_server(proc.hProcess);
2421 /* Test the combinations of A and W interfaces with A and W data
2422 end to end to ensure that data conversions are accurate */
2423 sprintf(buffer, "%s dde enda", argv[0]);
2424 CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2425 CREATE_SUSPENDED, NULL, NULL, &startup, &proc);
2427 test_end_to_end_server(proc.hProcess, proc.hThread, TRUE);
2429 sprintf(buffer, "%s dde endw", argv[0]);
2430 CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2431 CREATE_SUSPENDED, NULL, NULL, &startup, &proc);
2433 test_end_to_end_server(proc.hProcess, proc.hThread, FALSE);
2435 sprintf(buffer, "%s dde enda", argv[0]);
2436 CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2437 CREATE_SUSPENDED, NULL, NULL, &startup, &proc);
2439 test_end_to_end_server(proc.hProcess, proc.hThread, FALSE);
2441 sprintf(buffer, "%s dde endw", argv[0]);
2442 CreateProcessA(NULL, buffer, NULL, NULL, FALSE,
2443 CREATE_SUSPENDED, NULL, NULL, &startup, &proc);
2445 test_end_to_end_server(proc.hProcess, proc.hThread, TRUE);
2447 test_dde_aw_transaction();
2449 test_DdeCreateDataHandle();
2450 test_DdeCreateStringHandle();
2451 test_FreeDDElParam();
2452 test_PackDDElParam();
2453 test_UnpackDDElParam();