user: Simplify 16-bit mappings of the WM_GETDLGCODE message.
[wine] / dlls / user / tests / dde.c
1 /*
2  * Unit tests for DDE functions
3  *
4  * Copyright (c) 2004 Dmitry Timoshkov
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include <assert.h>
22
23 #include "wine/test.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "dde.h"
27 #include "ddeml.h"
28 #include "winerror.h"
29
30 static const WCHAR TEST_DDE_SERVICE[] = {'T','e','s','t','D','D','E','S','e','r','v','i','c','e',0};
31
32 static const char exec_cmdA[] = "ANSI dde command";
33 static const WCHAR exec_cmdW[] = {'u','n','i','c','o','d','e',' ','d','d','e',' ','c','o','m','m','a','n','d',0};
34
35 static WNDPROC old_dde_client_wndproc;
36
37 LRESULT WINAPI hook_dde_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
38 {
39     UINT_PTR lo, hi;
40
41     trace("hook_dde_client_wndproc: %p %04x %08x %08lx\n", hwnd, msg, wparam, lparam);
42
43     switch (msg)
44     {
45     case WM_DDE_ACK:
46         UnpackDDElParam(WM_DDE_ACK, lparam, &lo, &hi);
47         trace("WM_DDE_ACK: status %04x hglobal %p\n", lo, (HGLOBAL)hi);
48         break;
49
50     default:
51         break;
52     }
53     return CallWindowProcA(old_dde_client_wndproc, hwnd, msg, wparam, lparam);
54 }
55
56 static LRESULT WINAPI dde_server_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
57 {
58     trace("dde_server_wndproc: %p %04x %08x %08lx\n", hwnd, msg, wparam, lparam);
59
60     switch (msg)
61     {
62     case WM_DDE_INITIATE:
63     {
64         ATOM aService = GlobalAddAtomW(TEST_DDE_SERVICE);
65
66         trace("server: got WM_DDE_INITIATE from %p with %08lx\n", (HWND)wparam, lparam);
67
68         if (LOWORD(lparam) == aService)
69         {
70             ok(!IsWindowUnicode((HWND)wparam), "client should be an ANSI window\n");
71             old_dde_client_wndproc = (WNDPROC)SetWindowLongPtrA((HWND)wparam, GWLP_WNDPROC, (ULONG_PTR)hook_dde_client_wndproc);
72             trace("server: sending WM_DDE_ACK to %p\n", (HWND)wparam);
73             SendMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, MAKELPARAM(aService, 0));
74         }
75         else
76             GlobalDeleteAtom(aService);
77         return 0;
78     }
79
80     case WM_DDE_EXECUTE:
81     {
82         DDEACK ack;
83         WORD status;
84         LPCSTR cmd;
85         UINT_PTR lo, hi;
86
87         trace("server: got WM_DDE_EXECUTE from %p with %08lx\n", (HWND)wparam, lparam);
88
89         UnpackDDElParam(WM_DDE_EXECUTE, lparam, &lo, &hi);
90         trace("%08lx => lo %04x hi %04x\n", lparam, lo, hi);
91
92         ack.bAppReturnCode = 0;
93         ack.reserved = 0;
94         ack.fBusy = 0;
95
96         cmd = GlobalLock((HGLOBAL)hi);
97
98         if (!cmd || (lstrcmpW((LPCWSTR)cmd, exec_cmdW) && lstrcmpA(cmd, exec_cmdA)))
99         {
100             trace("ignoring unknown WM_DDE_EXECUTE command\n");
101             /* We have to send a negative acknowledge even if we don't
102              * accept the command, otherwise Windows goes mad and next time
103              * we send an acknowledge DDEML drops the connection.
104              * Not sure how to call it: a bug or a feature.
105              */
106             ack.fAck = 0;
107         }
108         else
109             ack.fAck = 1;
110         GlobalUnlock((HGLOBAL)hi);
111
112         trace("server: posting %s WM_DDE_ACK to %p\n", ack.fAck ? "POSITIVE" : "NEGATIVE", (HWND)wparam);
113
114         status = *((WORD *)&ack);
115         lparam = ReuseDDElParam(lparam, WM_DDE_EXECUTE, WM_DDE_ACK, status, hi);
116
117         PostMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, lparam);
118         return 0;
119     }
120
121     case WM_DDE_TERMINATE:
122     {
123         DDEACK ack;
124         WORD status;
125
126         trace("server: got WM_DDE_TERMINATE from %p with %08lx\n", (HWND)wparam, lparam);
127
128         ack.bAppReturnCode = 0;
129         ack.reserved = 0;
130         ack.fBusy = 0;
131         ack.fAck = 1;
132
133         trace("server: posting %s WM_DDE_ACK to %p\n", ack.fAck ? "POSITIVE" : "NEGATIVE", (HWND)wparam);
134
135         status = *((WORD *)&ack);
136         lparam = PackDDElParam(WM_DDE_ACK, status, 0);
137
138         PostMessageW((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, lparam);
139         return 0;
140     }
141
142     default:
143         break;
144     }
145
146     return DefWindowProcW(hwnd, msg, wparam, lparam);
147 }
148
149 static LRESULT WINAPI dde_client_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
150 {
151     return DefWindowProcA(hwnd, msg, wparam, lparam);
152 }
153
154 static BOOL create_dde_windows(HWND *hwnd_client, HWND *hwnd_server)
155 {
156     WNDCLASSA wcA;
157     WNDCLASSW wcW;
158     static const WCHAR server_class_name[] = {'d','d','e','_','s','e','r','v','e','r','_','w','i','n','d','o','w',0};
159     static const char client_class_name[] = "dde_client_window";
160
161     memset(&wcW, 0, sizeof(wcW));
162     wcW.lpfnWndProc = dde_server_wndproc;
163     wcW.lpszClassName = server_class_name;
164     wcW.hInstance = GetModuleHandleA(0);
165     if (!RegisterClassW(&wcW)) return FALSE;
166
167     memset(&wcA, 0, sizeof(wcA));
168     wcA.lpfnWndProc = dde_client_wndproc;
169     wcA.lpszClassName = client_class_name;
170     wcA.hInstance = GetModuleHandleA(0);
171     assert(RegisterClassA(&wcA));
172
173     *hwnd_server = CreateWindowExW(0, server_class_name, NULL,
174                                    WS_POPUP,
175                                    100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
176                                    GetDesktopWindow(), 0,
177                                    GetModuleHandleA(0), NULL);
178     assert(*hwnd_server);
179
180     *hwnd_client = CreateWindowExA(0, client_class_name, NULL,
181                                    WS_POPUP,
182                                    100, 100, CW_USEDEFAULT, CW_USEDEFAULT,
183                                    GetDesktopWindow(), 0,
184                                    GetModuleHandleA(0), NULL);
185     assert(*hwnd_client);
186
187     trace("server hwnd %p, client hwnd %p\n", *hwnd_server, *hwnd_client);
188
189     ok(IsWindowUnicode(*hwnd_server), "server has to be a unicode window\n");
190     ok(!IsWindowUnicode(*hwnd_client), "client has to be an ANSI window\n");
191
192     return TRUE;
193 }
194
195 static HDDEDATA CALLBACK client_dde_callback(UINT uType, UINT uFmt, HCONV hconv,
196                                      HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
197                                      ULONG_PTR dwData1, ULONG_PTR dwData2)
198 {
199     static const char * const cmd_type[15] = {
200         "XTYP_ERROR", "XTYP_ADVDATA", "XTYP_ADVREQ", "XTYP_ADVSTART",
201         "XTYP_ADVSTOP", "XTYP_EXECUTE", "XTYP_CONNECT", "XTYP_CONNECT_CONFIRM",
202         "XTYP_XACT_COMPLETE", "XTYP_POKE", "XTYP_REGISTER", "XTYP_REQUEST",
203         "XTYP_DISCONNECT", "XTYP_UNREGISTER", "XTYP_WILDCONNECT" };
204     UINT type;
205     const char *cmd_name;
206
207     type = (uType & XTYP_MASK) >> XTYP_SHIFT;
208     cmd_name = (type >= 0 && type <= 14) ? cmd_type[type] : "unknown";
209
210     trace("client_dde_callback: %04x (%s) %d %p %p %p %p %08lx %08lx\n",
211           uType, cmd_name, uFmt, hconv, hsz1, hsz2, hdata, dwData1, dwData2);
212     return 0;
213 }
214
215 static void test_dde_transaction(void)
216 {
217     HSZ hsz_server;
218     DWORD dde_inst, ret, err;
219     HCONV hconv;
220     HWND hwnd_client, hwnd_server;
221     CONVINFO info;
222     HDDEDATA hdata;
223     static const char test_cmd[] = "test dde command";
224
225     /* server: unicode, client: ansi */
226     if (!create_dde_windows(&hwnd_client, &hwnd_server)) return;
227
228     dde_inst = 0;
229     ret = DdeInitializeA(&dde_inst, client_dde_callback, APPCMD_CLIENTONLY, 0);
230     ok(ret == DMLERR_NO_ERROR, "DdeInitializeW failed with error %04lx (%x)\n",
231        ret, DdeGetLastError(dde_inst));
232
233     hsz_server = DdeCreateStringHandleW(dde_inst, TEST_DDE_SERVICE, CP_WINUNICODE);
234
235     hconv = DdeConnect(dde_inst, hsz_server, 0, NULL);
236     ok(hconv != 0, "DdeConnect error %x\n", DdeGetLastError(dde_inst));
237     err = DdeGetLastError(dde_inst);
238     ok(err == DMLERR_NO_ERROR, "wrong dde error %lx\n", err);
239
240     info.cb = sizeof(info);
241     ret = DdeQueryConvInfo(hconv, QID_SYNC, &info);
242     ok(ret, "wrong info size %ld, DdeQueryConvInfo error %x\n", ret, DdeGetLastError(dde_inst));
243     /* should be CP_WINANSI since we used DdeInitializeA */
244     ok(info.ConvCtxt.iCodePage == CP_WINANSI, "wrong iCodePage %d\n", info.ConvCtxt.iCodePage);
245     ok(!info.hConvPartner, "unexpected info.hConvPartner: %p\n", info.hConvPartner);
246 todo_wine {
247     ok((info.wStatus & DDE_FACK), "unexpected info.wStatus: %04x\n", info.wStatus);
248 }
249     ok((info.wStatus & (ST_CONNECTED | ST_CLIENT)) == (ST_CONNECTED | ST_CLIENT), "unexpected info.wStatus: %04x\n", info.wStatus);
250     ok(info.wConvst == XST_CONNECTED, "unexpected info.wConvst: %04x\n", info.wConvst);
251     ok(info.wType == 0, "unexpected info.wType: %04x\n", info.wType);
252
253     trace("hwnd %p, hwndPartner %p\n", info.hwnd, info.hwndPartner);
254
255     trace("sending test client transaction command\n");
256     ret = 0xdeadbeef;
257     hdata = DdeClientTransaction((LPBYTE)test_cmd, strlen(test_cmd) + 1, hconv, (HSZ)0xdead, 0xbeef, XTYP_EXECUTE, 1000, &ret);
258     ok(!hdata, "DdeClientTransaction succeeded\n");
259     ok(ret == DDE_FNOTPROCESSED, "wrong status code %04lx\n", ret);
260     err = DdeGetLastError(dde_inst);
261     ok(err == DMLERR_NOTPROCESSED, "wrong dde error %lx\n", err);
262
263     trace("sending ANSI client transaction command\n");
264     ret = 0xdeadbeef;
265     hdata = DdeClientTransaction((LPBYTE)exec_cmdA, lstrlenA(exec_cmdA) + 1, hconv, 0, 0, XTYP_EXECUTE, 1000, &ret);
266     ok(hdata != 0, "DdeClientTransaction returned %p, error %x\n", hdata, DdeGetLastError(dde_inst));
267     ok(ret == DDE_FACK, "wrong status code %04lx\n", ret);
268
269     err = DdeGetLastError(dde_inst);
270     ok(err == DMLERR_NO_ERROR, "wrong dde error %lx\n", err);
271
272     trace("sending unicode client transaction command\n");
273     ret = 0xdeadbeef;
274     hdata = DdeClientTransaction((LPBYTE)exec_cmdW, (lstrlenW(exec_cmdW) + 1) * sizeof(WCHAR), hconv, 0, 0, XTYP_EXECUTE, 1000, &ret);
275     ok(hdata != 0, "DdeClientTransaction returned %p, error %x\n", hdata, DdeGetLastError(dde_inst));
276     ok(ret == DDE_FACK, "wrong status code %04lx\n", ret);
277     err = DdeGetLastError(dde_inst);
278     ok(err == DMLERR_NO_ERROR, "wrong dde error %lx\n", err);
279
280     ok(DdeDisconnect(hconv), "DdeDisconnect error %x\n", DdeGetLastError(dde_inst));
281
282     info.cb = sizeof(info);
283     ret = DdeQueryConvInfo(hconv, QID_SYNC, &info);
284     ok(!ret, "DdeQueryConvInfo should fail\n");
285     err = DdeGetLastError(dde_inst);
286 todo_wine {
287     ok(err == DMLERR_INVALIDPARAMETER, "wrong dde error %lx\n", err);
288 }
289
290     ok(DdeFreeStringHandle(dde_inst, hsz_server), "DdeFreeStringHandle error %x\n", DdeGetLastError(dde_inst));
291
292     /* This call hangs on win2k SP4 and XP SP1.
293     DdeUninitialize(dde_inst);*/
294
295     DestroyWindow(hwnd_client);
296     DestroyWindow(hwnd_server);
297 }
298
299 static void test_DdeCreateStringHandleW(DWORD dde_inst, int codepage)
300 {
301     static const WCHAR dde_string[] = {'D','D','E',' ','S','t','r','i','n','g',0};
302     HSZ str_handle;
303     WCHAR bufW[256];
304     char buf[256];
305     int ret;
306
307     str_handle = DdeCreateStringHandleW(dde_inst, dde_string, codepage);
308     ok(str_handle != 0, "DdeCreateStringHandleW failed with error %08x\n",
309        DdeGetLastError(dde_inst));
310
311     ret = DdeQueryStringW(dde_inst, str_handle, NULL, 0, codepage);
312     if (codepage == CP_WINANSI)
313         ok(ret == 1, "DdeQueryStringW returned wrong length %d\n", ret);
314     else
315         ok(ret == lstrlenW(dde_string), "DdeQueryStringW returned wrong length %d\n", ret);
316
317     ret = DdeQueryStringW(dde_inst, str_handle, bufW, 256, codepage);
318     if (codepage == CP_WINANSI)
319     {
320         ok(ret == 1, "DdeQueryStringW returned wrong length %d\n", ret);
321         ok(!lstrcmpA("D", (LPCSTR)bufW), "DdeQueryStringW returned wrong string\n");
322     }
323     else
324     {
325         ok(ret == lstrlenW(dde_string), "DdeQueryStringW returned wrong length %d\n", ret);
326         ok(!lstrcmpW(dde_string, bufW), "DdeQueryStringW returned wrong string\n");
327     }
328
329     ret = DdeQueryStringA(dde_inst, str_handle, buf, 256, CP_WINANSI);
330     if (codepage == CP_WINANSI)
331     {
332         ok(ret == 1, "DdeQueryStringA returned wrong length %d\n", ret);
333         ok(!lstrcmpA("D", buf), "DdeQueryStringW returned wrong string\n");
334     }
335     else
336     {
337         ok(ret == lstrlenA("DDE String"), "DdeQueryStringA returned wrong length %d\n", ret);
338         ok(!lstrcmpA("DDE String", buf), "DdeQueryStringA returned wrong string %s\n", buf);
339     }
340
341     ret = DdeQueryStringA(dde_inst, str_handle, buf, 256, CP_WINUNICODE);
342     if (codepage == CP_WINANSI)
343     {
344         ok(ret == 1, "DdeQueryStringA returned wrong length %d\n", ret);
345         ok(!lstrcmpA("D", buf), "DdeQueryStringA returned wrong string %s\n", buf);
346     }
347     else
348     {
349         ok(ret == lstrlenA("DDE String"), "DdeQueryStringA returned wrong length %d\n", ret);
350         ok(!lstrcmpW(dde_string, (LPCWSTR)buf), "DdeQueryStringW returned wrong string\n");
351     }
352
353     ok(DdeFreeStringHandle(dde_inst, str_handle), "DdeFreeStringHandle failed\n");
354 }
355
356 static void test_DdeCreateStringHandle(void)
357 {
358     DWORD dde_inst, ret;
359
360     dde_inst = 0xdeadbeef;
361     SetLastError(0xdeadbeef);
362     ret = DdeInitializeW(&dde_inst, client_dde_callback, APPCMD_CLIENTONLY, 0);
363     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
364     {
365         trace("Skipping the DDE test on a Win9x platform\n");
366         return;
367     }
368
369     ok(ret == DMLERR_INVALIDPARAMETER, "DdeInitializeW should fail, but got %04lx instead\n", ret);
370     ok(DdeGetLastError(dde_inst) == DMLERR_INVALIDPARAMETER, "expected DMLERR_INVALIDPARAMETER\n");
371
372     dde_inst = 0;
373     ret = DdeInitializeW(&dde_inst, client_dde_callback, APPCMD_CLIENTONLY, 0);
374     ok(ret == DMLERR_NO_ERROR, "DdeInitializeW failed with error %04lx (%08x)\n",
375        ret, DdeGetLastError(dde_inst));
376
377     test_DdeCreateStringHandleW(dde_inst, 0);
378     test_DdeCreateStringHandleW(dde_inst, CP_WINUNICODE);
379     test_DdeCreateStringHandleW(dde_inst, CP_WINANSI);
380
381     ok(DdeUninitialize(dde_inst), "DdeUninitialize failed\n");
382 }
383
384 START_TEST(dde)
385 {
386    test_DdeCreateStringHandle();
387    test_dde_transaction();
388 }