[COMCTL32_WINETEST] Sync with Wine Staging 4.18. CORE-16441
[reactos.git] / modules / rostests / winetests / comctl32 / subclass.c
1 /* Unit tests for subclassed windows.
2 *
3 * Copyright 2004 Kevin Koltzau
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #define _WIN32_WINNT 0x0501 /* For SetWindowSubclass/etc */
21
22 #include <assert.h>
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "winuser.h"
29 #include "commctrl.h"
30
31 #include "wine/heap.h"
32 #include "wine/test.h"
33
34 static BOOL (WINAPI *pSetWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR, DWORD_PTR);
35 static BOOL (WINAPI *pRemoveWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR);
36 static LRESULT (WINAPI *pDefSubclassProc)(HWND, UINT, WPARAM, LPARAM);
37
38 #define SEND_NEST 0x01
39 #define DELETE_SELF 0x02
40 #define DELETE_PREV 0x04
41
42 struct message {
43 int procnum; /* WndProc id message is expected from */
44 WPARAM wParam; /* expected value of wParam */
45 };
46
47 static int sequence_cnt, sequence_size;
48 static struct message* sequence;
49
50 static const struct message Sub_BasicTest[] = {
51 { 2, 1 },
52 { 1, 1 },
53 { 2, 2 },
54 { 1, 2 },
55 { 0 }
56 };
57
58 static const struct message Sub_DeletedTest[] = {
59 { 2, 1 },
60 { 1, 1 },
61 { 0 }
62 };
63
64 static const struct message Sub_AfterDeletedTest[] = {
65 { 1, 1 },
66 { 0 }
67 };
68
69 static const struct message Sub_OldAfterNewTest[] = {
70 { 3, 1 },
71 { 2, 1 },
72 { 1, 1 },
73 { 3, 2 },
74 { 2, 2 },
75 { 1, 2 },
76 { 0 }
77 };
78
79 static const struct message Sub_MixTest[] = {
80 { 3, 1 },
81 { 4, 1 },
82 { 2, 1 },
83 { 1, 1 },
84 { 0 }
85 };
86
87 static const struct message Sub_MixAndNestTest[] = {
88 { 3, 1 },
89 { 4, 1 },
90 { 3, 2 },
91 { 4, 2 },
92 { 2, 2 },
93 { 1, 2 },
94 { 2, 1 },
95 { 1, 1 },
96 { 0 }
97 };
98
99 static const struct message Sub_MixNestDelTest[] = {
100 { 3, 1 },
101 { 4, 1 },
102 { 3, 2 },
103 { 2, 2 },
104 { 1, 2 },
105 { 2, 1 },
106 { 1, 1 },
107 { 0 }
108 };
109
110 static const struct message Sub_MixDelPrevTest[] = {
111 { 3, 1 },
112 { 5, 1 },
113 { 2, 1 },
114 { 1, 1 },
115 { 0 }
116 };
117
118 static void add_message(const struct message *msg)
119 {
120 if (!sequence)
121 {
122 sequence_size = 10;
123 sequence = heap_alloc( sequence_size * sizeof (struct message) );
124 }
125 if (sequence_cnt == sequence_size)
126 {
127 sequence_size *= 2;
128 sequence = heap_realloc( sequence, sequence_size * sizeof (struct message) );
129 }
130 assert(sequence);
131
132 sequence[sequence_cnt].wParam = msg->wParam;
133 sequence[sequence_cnt].procnum = msg->procnum;
134
135 sequence_cnt++;
136 }
137
138 static void flush_sequence(void)
139 {
140 heap_free(sequence);
141 sequence = NULL;
142 sequence_cnt = sequence_size = 0;
143 }
144
145 static void ok_sequence(const struct message *expected, const char *context)
146 {
147 static const struct message end_of_sequence = { 0, 0 };
148 const struct message *actual;
149
150 add_message(&end_of_sequence);
151
152 actual = sequence;
153
154 while(expected->procnum && actual->procnum)
155 {
156 ok(expected->procnum == actual->procnum,
157 "%s: the procnum %d was expected, but got procnum %d instead\n",
158 context, expected->procnum, actual->procnum);
159 ok(expected->wParam == actual->wParam,
160 "%s: in procnum %d expecting wParam 0x%lx got 0x%lx\n",
161 context, expected->procnum, expected->wParam, actual->wParam);
162 expected++;
163 actual++;
164 }
165 ok(!expected->procnum, "Received fewer messages than expected\n");
166 ok(!actual->procnum, "Received more messages than expected\n");
167 flush_sequence();
168 }
169
170 static LRESULT WINAPI wnd_proc_1(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
171 {
172 struct message msg;
173
174 if(message == WM_USER) {
175 msg.wParam = wParam;
176 msg.procnum = 1;
177 add_message(&msg);
178 }
179 return DefWindowProcA(hwnd, message, wParam, lParam);
180 }
181
182
183 static WNDPROC orig_proc_3;
184 static LRESULT WINAPI wnd_proc_3(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
185 {
186 struct message msg;
187
188 if(message == WM_USER) {
189 msg.wParam = wParam;
190 msg.procnum = 3;
191 add_message(&msg);
192 }
193 return CallWindowProcA(orig_proc_3, hwnd, message, wParam, lParam);
194 }
195
196 static LRESULT WINAPI wnd_proc_sub(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, UINT_PTR uldSubclass, DWORD_PTR dwRefData)
197 {
198 struct message msg;
199
200 if(message == WM_USER) {
201 msg.wParam = wParam;
202 msg.procnum = uldSubclass;
203 add_message(&msg);
204
205 if(lParam) {
206 if(dwRefData & DELETE_SELF) {
207 pRemoveWindowSubclass(hwnd, wnd_proc_sub, uldSubclass);
208 pRemoveWindowSubclass(hwnd, wnd_proc_sub, uldSubclass);
209 }
210 if(dwRefData & DELETE_PREV)
211 pRemoveWindowSubclass(hwnd, wnd_proc_sub, uldSubclass-1);
212 if(dwRefData & SEND_NEST)
213 SendMessageA(hwnd, WM_USER, wParam+1, 0);
214 }
215 }
216 return pDefSubclassProc(hwnd, message, wParam, lParam);
217 }
218
219 static void test_subclass(void)
220 {
221 BOOL ret;
222 HWND hwnd = CreateWindowExA(0, "TestSubclass", "Test subclass", WS_OVERLAPPEDWINDOW,
223 100, 100, 200, 200, 0, 0, 0, NULL);
224 ok(hwnd != NULL, "failed to create test subclass wnd\n");
225
226 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0);
227 ok(ret == TRUE, "Expected TRUE\n");
228 SendMessageA(hwnd, WM_USER, 1, 0);
229 SendMessageA(hwnd, WM_USER, 2, 0);
230 ok_sequence(Sub_BasicTest, "Basic");
231
232 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, DELETE_SELF);
233 ok(ret == TRUE, "Expected TRUE\n");
234 SendMessageA(hwnd, WM_USER, 1, 1);
235 ok_sequence(Sub_DeletedTest, "Deleted");
236
237 SendMessageA(hwnd, WM_USER, 1, 0);
238 ok_sequence(Sub_AfterDeletedTest, "After Deleted");
239
240 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0);
241 ok(ret == TRUE, "Expected TRUE\n");
242 orig_proc_3 = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)wnd_proc_3);
243 SendMessageA(hwnd, WM_USER, 1, 0);
244 SendMessageA(hwnd, WM_USER, 2, 0);
245 ok_sequence(Sub_OldAfterNewTest, "Old after New");
246
247 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0);
248 ok(ret == TRUE, "Expected TRUE\n");
249 SendMessageA(hwnd, WM_USER, 1, 0);
250 ok_sequence(Sub_MixTest, "Mix");
251
252 /* Now the fun starts */
253 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST);
254 ok(ret == TRUE, "Expected TRUE\n");
255 SendMessageA(hwnd, WM_USER, 1, 1);
256 ok_sequence(Sub_MixAndNestTest, "Mix and nest");
257
258 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST | DELETE_SELF);
259 ok(ret == TRUE, "Expected TRUE\n");
260 SendMessageA(hwnd, WM_USER, 1, 1);
261 ok_sequence(Sub_MixNestDelTest, "Mix, nest, del");
262
263 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0);
264 ok(ret == TRUE, "Expected TRUE\n");
265 ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 5, DELETE_PREV);
266 ok(ret == TRUE, "Expected TRUE\n");
267 SendMessageA(hwnd, WM_USER, 1, 1);
268 ok_sequence(Sub_MixDelPrevTest, "Mix and del prev");
269
270 ret = pSetWindowSubclass(NULL, wnd_proc_sub, 1, 0);
271 ok(ret == FALSE, "Expected FALSE\n");
272
273 ret = pSetWindowSubclass(hwnd, NULL, 1, 0);
274 ok(ret == FALSE, "Expected FALSE\n");
275
276 pRemoveWindowSubclass(hwnd, wnd_proc_sub, 2);
277 pRemoveWindowSubclass(hwnd, wnd_proc_sub, 5);
278
279 DestroyWindow(hwnd);
280 }
281
282 static BOOL register_window_classes(void)
283 {
284 WNDCLASSA cls;
285 ATOM atom;
286
287 cls.style = 0;
288 cls.lpfnWndProc = wnd_proc_1;
289 cls.cbClsExtra = 0;
290 cls.cbWndExtra = 0;
291 cls.hInstance = GetModuleHandleA(0);
292 cls.hIcon = 0;
293 cls.hCursor = NULL;
294 cls.hbrBackground = NULL;
295 cls.lpszMenuName = NULL;
296 cls.lpszClassName = "TestSubclass";
297 atom = RegisterClassA(&cls);
298 ok(atom, "failed to register test class\n");
299
300 return atom != 0;
301 }
302
303 static BOOL init_function_pointers(void)
304 {
305 HMODULE hmod;
306 void *ptr;
307
308 hmod = LoadLibraryA("comctl32.dll");
309 ok(hmod != NULL, "got %p\n", hmod);
310
311 /* Functions have to be loaded by ordinal. Only XP and W2K3 export
312 * them by name.
313 */
314 #define MAKEFUNC_ORD(f, ord) (p##f = (void*)GetProcAddress(hmod, (LPSTR)(ord)))
315 MAKEFUNC_ORD(SetWindowSubclass, 410);
316 MAKEFUNC_ORD(RemoveWindowSubclass, 412);
317 MAKEFUNC_ORD(DefSubclassProc, 413);
318 #undef MAKEFUNC_ORD
319
320 if(!pSetWindowSubclass || !pRemoveWindowSubclass || !pDefSubclassProc)
321 {
322 win_skip("SetWindowSubclass and friends are not available\n");
323 return FALSE;
324 }
325
326 /* test named exports */
327 ptr = GetProcAddress(hmod, "SetWindowSubclass");
328 ok(broken(ptr == 0) || ptr != 0, "expected named export for SetWindowSubclass\n");
329 if(ptr)
330 {
331 #define TESTNAMED(f) \
332 ptr = (void*)GetProcAddress(hmod, #f); \
333 ok(ptr != 0, "expected named export for " #f "\n");
334 TESTNAMED(RemoveWindowSubclass);
335 TESTNAMED(DefSubclassProc);
336 /* GetWindowSubclass exported for V6 only */
337 #undef TESTNAMED
338 }
339
340 return TRUE;
341 }
342
343 START_TEST(subclass)
344 {
345 if(!init_function_pointers()) return;
346
347 if(!register_window_classes()) return;
348
349 test_subclass();
350 }