29b2706e1cca33cf09d3b4e2f0707f3795ab964e
[reactos.git] / rostests / winetests / user32 / class.c
1 /* Unit test suite for window classes.
2 *
3 * Copyright 2002 Mike McCormack
4 * Copyright 2003 Alexandre Julliard
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 /* To get CS_DROPSHADOW with the MSVC headers */
22 //#define _WIN32_WINNT 0x0501
23
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #include "wine/test.h"
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winreg.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34
35 /* we don't want to include commctrl.h: */
36 static const CHAR WC_EDITA[] = "Edit";
37 static const WCHAR WC_EDITW[] = {'E','d','i','t',0};
38
39 #define NUMCLASSWORDS 4
40
41 #define IS_WNDPROC_HANDLE(x) (((ULONG_PTR)(x) >> 16) == (~0u >> 16))
42
43 static LRESULT WINAPI ClassTest_WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
44 {
45 if (msg == WM_NCCREATE) return 1;
46 return DefWindowProcW (hWnd, msg, wParam, lParam);
47 }
48
49 static LRESULT WINAPI ClassTest_WndProc2 (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
50 {
51 if (msg == WM_NCCREATE) return 1;
52 return DefWindowProcA (hWnd, msg, wParam, lParam);
53 }
54
55 /***********************************************************************
56 */
57 static void ClassTest(HINSTANCE hInstance, BOOL global)
58 {
59 WNDCLASSW cls, wc;
60 static const WCHAR className[] = {'T','e','s','t','C','l','a','s','s',0};
61 static const WCHAR winName[] = {'W','i','n','C','l','a','s','s','T','e','s','t',0};
62 ATOM test_atom;
63 HWND hTestWnd;
64 LONG i;
65 WCHAR str[20];
66 ATOM classatom;
67
68 cls.style = CS_HREDRAW | CS_VREDRAW | (global?CS_GLOBALCLASS:0);
69 cls.lpfnWndProc = ClassTest_WndProc;
70 cls.cbClsExtra = NUMCLASSWORDS*sizeof(DWORD);
71 cls.cbWndExtra = 12;
72 cls.hInstance = hInstance;
73 cls.hIcon = LoadIconW (0, (LPWSTR)IDI_APPLICATION);
74 cls.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW);
75 cls.hbrBackground = GetStockObject (WHITE_BRUSH);
76 cls.lpszMenuName = 0;
77 cls.lpszClassName = className;
78
79 classatom=RegisterClassW(&cls);
80 if (!classatom && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
81 return;
82 ok(classatom, "failed to register class\n");
83
84 ok(!RegisterClassW (&cls),
85 "RegisterClass of the same class should fail for the second time\n");
86
87 /* Setup windows */
88 hTestWnd = CreateWindowW (className, winName,
89 WS_OVERLAPPEDWINDOW + WS_HSCROLL + WS_VSCROLL,
90 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, 0,
91 0, hInstance, 0);
92
93 ok(hTestWnd!=0, "Failed to create window\n");
94
95 /* test initial values of valid classwords */
96 for(i=0; i<NUMCLASSWORDS; i++)
97 {
98 SetLastError(0);
99 ok(!GetClassLongW(hTestWnd,i*sizeof (DWORD)),
100 "GetClassLongW initial value nonzero!\n");
101 ok(!GetLastError(),
102 "GetClassLongW failed!\n");
103 }
104
105 if (0)
106 {
107 /*
108 * GetClassLongW(hTestWnd, NUMCLASSWORDS*sizeof(DWORD))
109 * does not fail on Win 98, though MSDN says it should
110 */
111 SetLastError(0);
112 GetClassLongW(hTestWnd, NUMCLASSWORDS*sizeof(DWORD));
113 ok(GetLastError(),
114 "GetClassLongW() with invalid offset did not fail\n");
115 }
116
117 /* set values of valid class words */
118 for(i=0; i<NUMCLASSWORDS; i++)
119 {
120 SetLastError(0);
121 ok(!SetClassLongW(hTestWnd,i*sizeof(DWORD),i+1),
122 "GetClassLongW(%d) initial value nonzero!\n",i);
123 ok(!GetLastError(),
124 "SetClassLongW(%d) failed!\n",i);
125 }
126
127 /* test values of valid classwords that we set */
128 for(i=0; i<NUMCLASSWORDS; i++)
129 {
130 SetLastError(0);
131 ok( (i+1) == GetClassLongW(hTestWnd,i*sizeof (DWORD)),
132 "GetClassLongW value doesn't match what was set!\n");
133 ok(!GetLastError(),
134 "GetClassLongW failed!\n");
135 }
136
137 /* check GetClassName */
138 i = GetClassNameW(hTestWnd, str, sizeof(str)/sizeof(str[0]));
139 ok(i == lstrlenW(className),
140 "GetClassName returned incorrect length\n");
141 ok(!lstrcmpW(className,str),
142 "GetClassName returned incorrect name for this window's class\n");
143
144 /* check GetClassInfo with our hInstance */
145 if((test_atom = GetClassInfoW(hInstance, str, &wc)))
146 {
147 ok(test_atom == classatom,
148 "class atom did not match\n");
149 ok(wc.cbClsExtra == cls.cbClsExtra,
150 "cbClsExtra did not match\n");
151 ok(wc.cbWndExtra == cls.cbWndExtra,
152 "cbWndExtra did not match\n");
153 ok(wc.hbrBackground == cls.hbrBackground,
154 "hbrBackground did not match\n");
155 ok(wc.hCursor== cls.hCursor,
156 "hCursor did not match\n");
157 ok(wc.hInstance== cls.hInstance,
158 "hInstance did not match\n");
159 }
160 else
161 ok(FALSE,"GetClassInfo (hinstance) failed!\n");
162
163 /* check GetClassInfo with zero hInstance */
164 if(global)
165 {
166 if((test_atom = GetClassInfoW(0, str, &wc)))
167 {
168 ok(test_atom == classatom,
169 "class atom did not match %x != %x\n", test_atom, classatom);
170 ok(wc.cbClsExtra == cls.cbClsExtra,
171 "cbClsExtra did not match %x!=%x\n",wc.cbClsExtra,cls.cbClsExtra);
172 ok(wc.cbWndExtra == cls.cbWndExtra,
173 "cbWndExtra did not match %x!=%x\n",wc.cbWndExtra,cls.cbWndExtra);
174 ok(wc.hbrBackground == cls.hbrBackground,
175 "hbrBackground did not match %p!=%p\n",wc.hbrBackground,cls.hbrBackground);
176 ok(wc.hCursor== cls.hCursor,
177 "hCursor did not match %p!=%p\n",wc.hCursor,cls.hCursor);
178 ok(!wc.hInstance,
179 "hInstance not zero for global class %p\n",wc.hInstance);
180 }
181 else
182 ok(FALSE,"GetClassInfo (0) failed for global class!\n");
183 }
184 else
185 {
186 ok(!GetClassInfoW(0, str, &wc),
187 "GetClassInfo (0) succeeded for local class!\n");
188 }
189
190 ok(!UnregisterClassW(className, hInstance),
191 "Unregister class succeeded with window existing\n");
192
193 ok(DestroyWindow(hTestWnd),
194 "DestroyWindow() failed!\n");
195
196 ok(UnregisterClassW(className, hInstance),
197 "UnregisterClass() failed\n");
198
199 return;
200 }
201
202 static void check_style( const char *name, int must_exist, UINT style, UINT ignore )
203 {
204 WNDCLASS wc;
205
206 if (GetClassInfo( 0, name, &wc ))
207 {
208 ok( !(~wc.style & style & ~ignore), "System class %s is missing bits %x (%08x/%08x)\n",
209 name, ~wc.style & style, wc.style, style );
210 ok( !(wc.style & ~style), "System class %s has extra bits %x (%08x/%08x)\n",
211 name, wc.style & ~style, wc.style, style );
212 }
213 else
214 ok( !must_exist, "System class %s does not exist\n", name );
215 }
216
217 /* test styles of system classes */
218 static void test_styles(void)
219 {
220 /* check style bits */
221 check_style( "Button", 1, CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, 0 );
222 check_style( "ComboBox", 1, CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, 0 );
223 check_style( "Edit", 1, CS_PARENTDC | CS_DBLCLKS, 0 );
224 check_style( "ListBox", 1, CS_PARENTDC | CS_DBLCLKS, CS_PARENTDC /*FIXME*/ );
225 check_style( "MDIClient", 1, 0, 0 );
226 check_style( "ScrollBar", 1, CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, 0 );
227 check_style( "Static", 1, CS_PARENTDC | CS_DBLCLKS, 0 );
228 check_style( "ComboLBox", 1, CS_SAVEBITS | CS_DBLCLKS, 0 );
229 check_style( "DDEMLEvent", 0, 0, 0 );
230 check_style( "Message", 0, 0, 0 );
231 check_style( "#32768", 1, CS_DROPSHADOW | CS_SAVEBITS | CS_DBLCLKS, CS_DROPSHADOW ); /* menu */
232 check_style( "#32769", 1, CS_DBLCLKS, 0 ); /* desktop */
233 check_style( "#32770", 1, CS_SAVEBITS | CS_DBLCLKS, 0 ); /* dialog */
234 todo_wine { check_style( "#32771", 1, CS_SAVEBITS | CS_HREDRAW | CS_VREDRAW, 0 ); } /* task switch */
235 check_style( "#32772", 1, 0, 0 ); /* icon title */
236 }
237
238 static void check_class_(int line, HINSTANCE inst, const char *name, const char *menu_name)
239 {
240 WNDCLASS wc;
241 UINT atom = GetClassInfo(inst,name,&wc);
242 ok_(__FILE__,line)( atom, "Class %s %p not found\n", name, inst );
243 if (atom)
244 {
245 if (wc.lpszMenuName && menu_name)
246 ok_(__FILE__,line)( !strcmp( menu_name, wc.lpszMenuName ),
247 "Wrong name %s/%s for class %s %p\n",
248 wc.lpszMenuName, menu_name, name, inst );
249 else
250 ok_(__FILE__,line)( !menu_name == !wc.lpszMenuName, "Wrong name %p/%p for class %s %p\n",
251 wc.lpszMenuName, menu_name, name, inst );
252 }
253 }
254 #define check_class(inst,name,menu) check_class_(__LINE__,inst,name,menu)
255
256 static void check_instance_( int line, const char *name, HINSTANCE inst,
257 HINSTANCE info_inst, HINSTANCE gcl_inst )
258 {
259 WNDCLASSA wc;
260 HWND hwnd;
261
262 ok_(__FILE__,line)( GetClassInfo( inst, name, &wc ), "Couldn't find class %s inst %p\n", name, inst );
263 ok_(__FILE__,line)( wc.hInstance == info_inst, "Wrong info instance %p/%p for class %s\n",
264 wc.hInstance, info_inst, name );
265 hwnd = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, inst, 0 );
266 ok_(__FILE__,line)( hwnd != NULL, "Couldn't create window for class %s inst %p\n", name, inst );
267 ok_(__FILE__,line)( (HINSTANCE)GetClassLongPtrA( hwnd, GCLP_HMODULE ) == gcl_inst,
268 "Wrong GCL instance %p/%p for class %s\n",
269 (HINSTANCE)GetClassLongPtrA( hwnd, GCLP_HMODULE ), gcl_inst, name );
270 ok_(__FILE__,line)( (HINSTANCE)GetWindowLongPtrA( hwnd, GWLP_HINSTANCE ) == inst,
271 "Wrong GWL instance %p/%p for window %s\n",
272 (HINSTANCE)GetWindowLongPtrA( hwnd, GWLP_HINSTANCE ), inst, name );
273 ok_(__FILE__,line)(!UnregisterClassA(name, inst),
274 "UnregisterClassA should fail while exists a class window\n");
275 ok_(__FILE__,line)(GetLastError() == ERROR_CLASS_HAS_WINDOWS,
276 "GetLastError() should be set to ERROR_CLASS_HAS_WINDOWS not %d\n", GetLastError());
277 DestroyWindow(hwnd);
278 }
279 #define check_instance(name,inst,info_inst,gcl_inst) check_instance_(__LINE__,name,inst,info_inst,gcl_inst)
280
281 struct class_info
282 {
283 const char *name;
284 HINSTANCE inst, info_inst, gcl_inst;
285 };
286
287 static DWORD WINAPI thread_proc(void *param)
288 {
289 struct class_info *class_info = param;
290
291 check_instance(class_info->name, class_info->inst, class_info->info_inst, class_info->gcl_inst);
292
293 return 0;
294 }
295
296 static void check_thread_instance( const char *name, HINSTANCE inst, HINSTANCE info_inst, HINSTANCE gcl_inst )
297 {
298 HANDLE hThread;
299 DWORD tid;
300 struct class_info class_info;
301
302 class_info.name = name;
303 class_info.inst = inst;
304 class_info.info_inst = info_inst;
305 class_info.gcl_inst = gcl_inst;
306
307 hThread = CreateThread(NULL, 0, thread_proc, &class_info, 0, &tid);
308 ok(hThread != NULL, "CreateThread failed, error %d\n", GetLastError());
309 ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
310 CloseHandle(hThread);
311 }
312
313 /* test various instance parameters */
314 static void test_instances(void)
315 {
316 WNDCLASSA cls, wc;
317 WNDCLASSEXA wcexA;
318 HWND hwnd, hwnd2;
319 const char *name = "__test__";
320 HINSTANCE kernel32 = GetModuleHandleA("kernel32");
321 HINSTANCE user32 = GetModuleHandleA("user32");
322 HINSTANCE main_module = GetModuleHandleA(NULL);
323 HINSTANCE zero_instance = 0;
324 DWORD r;
325 char buffer[0x10];
326
327 memset( &cls, 0, sizeof(cls) );
328 cls.style = CS_HREDRAW | CS_VREDRAW;
329 cls.lpfnWndProc = ClassTest_WndProc;
330 cls.cbClsExtra = 0;
331 cls.cbWndExtra = 0;
332 cls.lpszClassName = name;
333
334 cls.lpszMenuName = "main_module";
335 cls.hInstance = main_module;
336
337 ok( RegisterClassA( &cls ), "Failed to register local class for main module\n" );
338 check_class( main_module, name, "main_module" );
339 check_instance( name, main_module, main_module, main_module );
340 check_thread_instance( name, main_module, main_module, main_module );
341
342 cls.lpszMenuName = "kernel32";
343 cls.hInstance = kernel32;
344 ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
345 check_class( kernel32, name, "kernel32" );
346 check_class( main_module, name, "main_module" );
347 check_instance( name, kernel32, kernel32, kernel32 );
348 check_thread_instance( name, kernel32, kernel32, kernel32 );
349 ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
350
351 ZeroMemory(&wcexA, sizeof(wcexA));
352 wcexA.lpfnWndProc = DefWindowProcA;
353 wcexA.lpszClassName = "__classex_test__";
354 SetLastError(0xdeadbeef);
355 wcexA.cbSize = sizeof(wcexA) - 1;
356 ok( ((RegisterClassExA( &wcexA ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
357 "Succeeded with invalid number of cbSize bytes\n");
358 SetLastError(0xdeadbeef);
359 wcexA.cbSize = sizeof(wcexA) + 1;
360 ok( ((RegisterClassExA( &wcexA ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
361 "Succeeded with invalid number of cbSize bytes\n");
362 SetLastError(0xdeadbeef);
363 wcexA.cbSize = sizeof(wcexA);
364 ok( RegisterClassExA( &wcexA ), "Failed with valid number of cbSize bytes\n");
365 wcexA.cbSize = 0xdeadbeef;
366 ok( GetClassInfoEx(main_module, wcexA.lpszClassName, &wcexA), "GetClassInfoEx failed\n");
367 ok( wcexA.cbSize == 0xdeadbeef, "GetClassInfoEx returned wrong cbSize value %d\n", wcexA.cbSize);
368 UnregisterClassA(wcexA.lpszClassName, main_module);
369
370 /* Bug 2631 - Supplying an invalid number of bytes fails */
371 cls.cbClsExtra = 0;
372 cls.cbWndExtra = -1;
373 SetLastError(0xdeadbeef);
374 ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
375 "Failed with invalid number of WndExtra bytes\n");
376
377 cls.cbClsExtra = -1;
378 cls.cbWndExtra = 0;
379 SetLastError(0xdeadbeef);
380 ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
381 "Failed with invalid number of ClsExtra bytes\n");
382
383 cls.cbClsExtra = -1;
384 cls.cbWndExtra = -1;
385 SetLastError(0xdeadbeef);
386 ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
387 "Failed with invalid number of ClsExtra and cbWndExtra bytes\n");
388
389 cls.cbClsExtra = 0;
390 cls.cbWndExtra = 0;
391 SetLastError(0xdeadbeef);
392
393 /* setting global flag doesn't change status of class */
394 hwnd = CreateWindowExA( 0, name, "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
395 ok( hwnd != 0, "CreateWindow failed error %u\n", GetLastError());
396 SetClassLongA( hwnd, GCL_STYLE, CS_GLOBALCLASS );
397 cls.lpszMenuName = "kernel32";
398 cls.hInstance = kernel32;
399 ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
400 check_class( kernel32, name, "kernel32" );
401 check_class( main_module, name, "main_module" );
402 check_instance( name, kernel32, kernel32, kernel32 );
403 check_instance( name, main_module, main_module, main_module );
404 check_thread_instance( name, kernel32, kernel32, kernel32 );
405 check_thread_instance( name, main_module, main_module, main_module );
406 ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
407
408 /* changing the instance doesn't make it global */
409 SetClassLongPtrA( hwnd, GCLP_HMODULE, 0 );
410 ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
411 check_class( kernel32, name, "kernel32" );
412 check_instance( name, kernel32, kernel32, kernel32 );
413 check_thread_instance( name, kernel32, kernel32, kernel32 );
414 ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
415 ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
416
417 /* GetClassInfo with instance 0 finds user32 instance */
418 SetClassLongPtrA( hwnd, GCLP_HMODULE, (LONG_PTR)user32 );
419 ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
420 if (!GetClassInfo( 0, name, &wc )) zero_instance = user32; /* instance 0 not supported on wow64 */
421 else
422 {
423 check_instance( name, 0, 0, kernel32 );
424 check_thread_instance( name, 0, 0, kernel32 );
425 }
426 check_class( kernel32, name, "kernel32" );
427 check_class( user32, name, "main_module" );
428 check_class( zero_instance, name, "main_module" );
429 check_instance( name, kernel32, kernel32, kernel32 );
430 check_instance( name, user32, zero_instance, user32 );
431 check_thread_instance( name, kernel32, kernel32, kernel32 );
432 check_thread_instance( name, user32, zero_instance, user32 );
433 ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
434
435 SetClassLongPtrA( hwnd, GCLP_HMODULE, 0x12345678 );
436 ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
437 check_class( kernel32, name, "kernel32" );
438 check_class( (HINSTANCE)0x12345678, name, "main_module" );
439 check_instance( name, kernel32, kernel32, kernel32 );
440 check_instance( name, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678 );
441 check_thread_instance( name, kernel32, kernel32, kernel32 );
442 check_thread_instance( name, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678 );
443 ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
444
445 /* creating a window with instance 0 uses the first class found */
446 cls.hInstance = (HINSTANCE)0xdeadbeef;
447 cls.lpszMenuName = "deadbeef";
448 cls.style = 3;
449 ok( RegisterClassA( &cls ), "Failed to register local class for deadbeef\n" );
450 hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
451 ok( GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == 0xdeadbeef,
452 "Didn't get deadbeef class for null instance\n" );
453 DestroyWindow( hwnd2 );
454 ok( UnregisterClassA( name, (HINSTANCE)0xdeadbeef ), "Unregister failed for deadbeef\n" );
455
456 hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
457 ok( (HINSTANCE)GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == kernel32,
458 "Didn't get kernel32 class for null instance\n" );
459 DestroyWindow( hwnd2 );
460
461 r = GetClassName( hwnd, buffer, 4 );
462 ok( r == 3, "expected 3, got %d\n", r );
463 ok( !strcmp( buffer, "__t"), "name wrong: %s\n", buffer );
464
465 ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
466
467 hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
468 ok( GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == 0x12345678,
469 "Didn't get 12345678 class for null instance\n" );
470 DestroyWindow( hwnd2 );
471
472 SetClassLongPtrA( hwnd, GCLP_HMODULE, (LONG_PTR)main_module );
473 DestroyWindow( hwnd );
474
475 /* null handle means the same thing as main module */
476 cls.lpszMenuName = "null";
477 cls.hInstance = 0;
478 ok( !RegisterClassA( &cls ), "Succeeded registering local class for null instance\n" );
479 ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
480 ok( UnregisterClassA( name, main_module ), "Unregister failed for main module\n" );
481
482 ok( RegisterClassA( &cls ), "Failed to register local class for null instance\n" );
483 /* must be found with main module handle */
484 check_class( main_module, name, "null" );
485 check_instance( name, main_module, main_module, main_module );
486 check_thread_instance( name, main_module, main_module, main_module );
487 ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
488 ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %d\n", GetLastError() );
489 ok( UnregisterClassA( name, 0 ), "Unregister failed for null instance\n" );
490
491 /* registering for user32 always fails */
492 cls.lpszMenuName = "user32";
493 cls.hInstance = user32;
494 ok( !RegisterClassA( &cls ), "Succeeded registering local class for user32\n" );
495 ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error code %d\n", GetLastError() );
496 cls.style |= CS_GLOBALCLASS;
497 ok( !RegisterClassA( &cls ), "Succeeded registering global class for user32\n" );
498 ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error code %d\n", GetLastError() );
499
500 /* unregister is OK though */
501 cls.hInstance = main_module;
502 ok( RegisterClassA( &cls ), "Failed to register global class for main module\n" );
503 ok( UnregisterClassA( name, user32 ), "Unregister failed for user32\n" );
504
505 /* instance doesn't matter for global class */
506 cls.style |= CS_GLOBALCLASS;
507 cls.lpszMenuName = "main_module";
508 cls.hInstance = main_module;
509 ok( RegisterClassA( &cls ), "Failed to register global class for main module\n" );
510 cls.lpszMenuName = "kernel32";
511 cls.hInstance = kernel32;
512 ok( !RegisterClassA( &cls ), "Succeeded registering local class for kernel32\n" );
513 ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
514 /* even if global flag is cleared */
515 hwnd = CreateWindowExA( 0, name, "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
516 SetClassLongA( hwnd, GCL_STYLE, 0 );
517 ok( !RegisterClassA( &cls ), "Succeeded registering local class for kernel32\n" );
518 ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
519
520 check_class( main_module, name, "main_module" );
521 check_class( kernel32, name, "main_module" );
522 check_class( 0, name, "main_module" );
523 check_class( (HINSTANCE)0x12345678, name, "main_module" );
524 check_instance( name, main_module, main_module, main_module );
525 check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, main_module );
526 check_thread_instance( name, main_module, main_module, main_module );
527 check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, main_module );
528
529 /* changing the instance for global class doesn't make much difference */
530 SetClassLongPtrA( hwnd, GCLP_HMODULE, 0xdeadbeef );
531 check_instance( name, main_module, main_module, (HINSTANCE)0xdeadbeef );
532 check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef );
533 check_thread_instance( name, main_module, main_module, (HINSTANCE)0xdeadbeef );
534 check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef );
535
536 DestroyWindow( hwnd );
537 ok( UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister failed for main module global\n" );
538 ok( !UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister succeeded the second time\n" );
539 ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %d\n", GetLastError() );
540
541 cls.hInstance = (HINSTANCE)0x12345678;
542 ok( RegisterClassA( &cls ), "Failed to register global class for dummy instance\n" );
543 check_instance( name, main_module, main_module, (HINSTANCE)0x12345678 );
544 check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0x12345678 );
545 check_thread_instance( name, main_module, main_module, (HINSTANCE)0x12345678 );
546 check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0x12345678 );
547 ok( UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister failed for main module global\n" );
548
549 /* check system classes */
550
551 /* we cannot register a global class with the name of a system class */
552 cls.style |= CS_GLOBALCLASS;
553 cls.lpszMenuName = "button_main_module";
554 cls.lpszClassName = "BUTTON";
555 cls.hInstance = main_module;
556 ok( !RegisterClassA( &cls ), "Succeeded registering global button class for main module\n" );
557 ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
558 cls.hInstance = kernel32;
559 ok( !RegisterClassA( &cls ), "Succeeded registering global button class for kernel32\n" );
560 ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
561
562 /* local class is OK however */
563 cls.style &= ~CS_GLOBALCLASS;
564 cls.lpszMenuName = "button_main_module";
565 cls.hInstance = main_module;
566 ok( RegisterClassA( &cls ), "Failed to register local button class for main module\n" );
567 check_class( main_module, "BUTTON", "button_main_module" );
568 cls.lpszMenuName = "button_kernel32";
569 cls.hInstance = kernel32;
570 ok( RegisterClassA( &cls ), "Failed to register local button class for kernel32\n" );
571 check_class( kernel32, "BUTTON", "button_kernel32" );
572 check_class( main_module, "BUTTON", "button_main_module" );
573 ok( UnregisterClassA( "BUTTON", kernel32 ), "Unregister failed for kernel32 button\n" );
574 ok( UnregisterClassA( "BUTTON", main_module ), "Unregister failed for main module button\n" );
575 /* GetClassInfo sets instance to passed value for global classes */
576 check_instance( "BUTTON", 0, 0, user32 );
577 check_instance( "BUTTON", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
578 check_instance( "BUTTON", user32, zero_instance, user32 );
579 check_thread_instance( "BUTTON", 0, 0, user32 );
580 check_thread_instance( "BUTTON", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
581 check_thread_instance( "BUTTON", user32, zero_instance, user32 );
582
583 /* we can unregister system classes */
584 ok( GetClassInfo( 0, "BUTTON", &wc ), "Button class not found with null instance\n" );
585 ok( GetClassInfo( kernel32, "BUTTON", &wc ), "Button class not found with kernel32\n" );
586 ok( UnregisterClass( "BUTTON", (HINSTANCE)0x12345678 ), "Failed to unregister button\n" );
587 ok( !UnregisterClass( "BUTTON", (HINSTANCE)0x87654321 ), "Unregistered button a second time\n" );
588 ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %d\n", GetLastError() );
589 ok( !GetClassInfo( 0, "BUTTON", &wc ), "Button still exists\n" );
590 /* last error not set reliably */
591
592 /* we can change the instance of a system class */
593 check_instance( "EDIT", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
594 check_thread_instance( "EDIT", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
595 hwnd = CreateWindowExA( 0, "EDIT", "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
596 SetClassLongPtrA( hwnd, GCLP_HMODULE, 0xdeadbeef );
597 check_instance( "EDIT", (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0xdeadbeef );
598 check_thread_instance( "EDIT", (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0xdeadbeef );
599 DestroyWindow(hwnd);
600 }
601
602 static void test_builtinproc(void)
603 {
604 /* Edit behaves differently */
605 static const CHAR NORMAL_CLASSES[][10] = {
606 "Button",
607 "Static",
608 "ComboBox",
609 "ComboLBox",
610 "ListBox",
611 "ScrollBar",
612 "#32770", /* dialog */
613 };
614 static const int NUM_NORMAL_CLASSES = (sizeof(NORMAL_CLASSES)/sizeof(NORMAL_CLASSES[0]));
615 static const char classA[] = "deftest";
616 static const WCHAR classW[] = {'d','e','f','t','e','s','t',0};
617 WCHAR unistring[] = {0x142, 0x40e, 0x3b4, 0}; /* a string that would be destroyed by a W->A->W conversion */
618 WNDPROC pDefWindowProcA, pDefWindowProcW;
619 WNDPROC pNtdllDefWindowProcA, pNtdllDefWindowProcW;
620 WNDPROC oldproc;
621 WNDCLASSEXA cls; /* the memory layout of WNDCLASSEXA and WNDCLASSEXW is the same */
622 WCHAR buf[128];
623 ATOM atom;
624 HWND hwnd;
625 int i;
626
627 pDefWindowProcA = (void *)GetProcAddress(GetModuleHandle("user32.dll"), "DefWindowProcA");
628 pDefWindowProcW = (void *)GetProcAddress(GetModuleHandle("user32.dll"), "DefWindowProcW");
629 pNtdllDefWindowProcA = (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtdllDefWindowProc_A");
630 pNtdllDefWindowProcW = (void *)GetProcAddress(GetModuleHandle("ntdll.dll"), "NtdllDefWindowProc_W");
631
632 /* On Vista+, the user32.dll export DefWindowProcA/W is forwarded to */
633 /* ntdll.NtdllDefWindowProc_A/W. However, the wndproc returned by */
634 /* GetClassLong/GetWindowLong points to an unexported user32 function */
635 if (pDefWindowProcA == pNtdllDefWindowProcA &&
636 pDefWindowProcW == pNtdllDefWindowProcW)
637 skip("user32.DefWindowProcX forwarded to ntdll.NtdllDefWindowProc_X\n");
638 else
639 {
640 for (i = 0; i < 4; i++)
641 {
642 ZeroMemory(&cls, sizeof(cls));
643 cls.cbSize = sizeof(cls);
644 cls.hInstance = GetModuleHandle(NULL);
645 cls.hbrBackground = GetStockObject (WHITE_BRUSH);
646 if (i & 1)
647 cls.lpfnWndProc = pDefWindowProcA;
648 else
649 cls.lpfnWndProc = pDefWindowProcW;
650
651 if (i & 2)
652 {
653 cls.lpszClassName = classA;
654 atom = RegisterClassExA(&cls);
655 }
656 else
657 {
658 cls.lpszClassName = (LPCSTR)classW;
659 atom = RegisterClassExW((WNDCLASSEXW *)&cls);
660 }
661 ok(atom != 0, "Couldn't register class, i=%d, %d\n", i, GetLastError());
662
663 hwnd = CreateWindowA(classA, NULL, 0, 0, 0, 100, 100, NULL, NULL, GetModuleHandle(NULL), NULL);
664 ok(hwnd != NULL, "Couldn't create window i=%d\n", i);
665
666 ok(GetWindowLongPtrA(hwnd, GWLP_WNDPROC) == (LONG_PTR)pDefWindowProcA, "Wrong ANSI wndproc: %p vs %p\n",
667 (void *)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), pDefWindowProcA);
668 ok(GetClassLongPtrA(hwnd, GCLP_WNDPROC) == (ULONG_PTR)pDefWindowProcA, "Wrong ANSI wndproc: %p vs %p\n",
669 (void *)GetClassLongPtrA(hwnd, GCLP_WNDPROC), pDefWindowProcA);
670
671 ok(GetWindowLongPtrW(hwnd, GWLP_WNDPROC) == (LONG_PTR)pDefWindowProcW, "Wrong Unicode wndproc: %p vs %p\n",
672 (void *)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), pDefWindowProcW);
673 ok(GetClassLongPtrW(hwnd, GCLP_WNDPROC) == (ULONG_PTR)pDefWindowProcW, "Wrong Unicode wndproc: %p vs %p\n",
674 (void *)GetClassLongPtrW(hwnd, GCLP_WNDPROC), pDefWindowProcW);
675
676 DestroyWindow(hwnd);
677 UnregisterClass((LPSTR)(DWORD_PTR)atom, GetModuleHandle(NULL));
678 }
679 }
680
681 /* built-in winproc - window A/W type automatically detected */
682 ZeroMemory(&cls, sizeof(cls));
683 cls.cbSize = sizeof(cls);
684 cls.hInstance = GetModuleHandle(NULL);
685 cls.hbrBackground = GetStockObject (WHITE_BRUSH);
686 cls.lpszClassName = classA;
687 cls.lpfnWndProc = pDefWindowProcW;
688 atom = RegisterClassExA(&cls);
689
690 hwnd = CreateWindowExW(0, classW, NULL, WS_OVERLAPPEDWINDOW,
691 CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, GetModuleHandleA(NULL), 0);
692 ok(IsWindowUnicode(hwnd), "Windows should be Unicode\n");
693 SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)pDefWindowProcA);
694 ok(IsWindowUnicode(hwnd), "Windows should have remained Unicode\n");
695 if (GetWindowLongPtrW(hwnd, GWLP_WNDPROC) == (LONG_PTR)pDefWindowProcA)
696 {
697 /* DefWindowProc isn't magic on wow64 */
698 ok(IS_WNDPROC_HANDLE(GetWindowLongPtrA(hwnd, GWLP_WNDPROC)), "Ansi winproc is not a handle\n");
699 }
700 else
701 {
702 ok(GetWindowLongPtrW(hwnd, GWLP_WNDPROC) == (LONG_PTR)pDefWindowProcW, "Invalid Unicode winproc\n");
703 ok(GetWindowLongPtrA(hwnd, GWLP_WNDPROC) == (LONG_PTR)pDefWindowProcA, "Invalid Ansi winproc\n");
704 }
705 SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)ClassTest_WndProc);
706 ok(IsWindowUnicode(hwnd) == FALSE, "SetWindowLongPtrA should have switched window to ANSI\n");
707
708 DestroyWindow(hwnd);
709 UnregisterClass((LPSTR)(DWORD_PTR)atom, GetModuleHandle(NULL));
710
711 /* custom winproc - the same function can be used as both A and W*/
712 ZeroMemory(&cls, sizeof(cls));
713 cls.cbSize = sizeof(cls);
714 cls.hInstance = GetModuleHandle(NULL);
715 cls.hbrBackground = GetStockObject (WHITE_BRUSH);
716 cls.lpszClassName = classA;
717 cls.lpfnWndProc = ClassTest_WndProc2;
718 atom = RegisterClassExA(&cls);
719
720 hwnd = CreateWindowExW(0, classW, NULL, WS_OVERLAPPEDWINDOW,
721 CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, GetModuleHandleA(NULL), 0);
722 ok(IsWindowUnicode(hwnd) == FALSE, "Window should be ANSI\n");
723 SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)ClassTest_WndProc);
724 ok(IsWindowUnicode(hwnd), "SetWindowLongPtrW should have changed window to Unicode\n");
725 SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)ClassTest_WndProc);
726 ok(IsWindowUnicode(hwnd) == FALSE, "SetWindowLongPtrA should have changed window to ANSI\n");
727
728 DestroyWindow(hwnd);
729 UnregisterClass((LPSTR)(DWORD_PTR)atom, GetModuleHandle(NULL));
730
731 /* For most of the builtin controls both GetWindowLongPtrA and W returns a pointer that is executed directly
732 * by CallWindowProcA/W */
733 for (i = 0; i < NUM_NORMAL_CLASSES; i++)
734 {
735 WNDPROC procA, procW;
736 hwnd = CreateWindowExA(0, NORMAL_CLASSES[i], classA, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 680, 260,
737 NULL, NULL, NULL, 0);
738 ok(hwnd != NULL, "Couldn't create window of class %s\n", NORMAL_CLASSES[i]);
739 SetWindowText(hwnd, classA); /* ComboBox needs this */
740 procA = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC);
741 procW = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
742 ok(!IS_WNDPROC_HANDLE(procA), "procA should not be a handle for %s (%p)\n", NORMAL_CLASSES[i], procA);
743 ok(!IS_WNDPROC_HANDLE(procW), "procW should not be a handle for %s (%p)\n", NORMAL_CLASSES[i], procW);
744 CallWindowProcA(procA, hwnd, WM_GETTEXT, 120, (LPARAM)buf);
745 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT A/A invalid return for class %s\n", NORMAL_CLASSES[i]);
746 CallWindowProcA(procW, hwnd, WM_GETTEXT, 120, (LPARAM)buf);
747 ok(memcmp(buf, classW, sizeof(classW)) == 0, "WM_GETTEXT A/W invalid return for class %s\n", NORMAL_CLASSES[i]);
748 CallWindowProcW(procA, hwnd, WM_GETTEXT, 120, (LPARAM)buf);
749 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT W/A invalid return for class %s\n", NORMAL_CLASSES[i]);
750 CallWindowProcW(procW, hwnd, WM_GETTEXT, 120, (LPARAM)buf);
751 ok(memcmp(buf, classW, sizeof(classW)) == 0, "WM_GETTEXT W/W invalid return for class %s\n", NORMAL_CLASSES[i]);
752
753 oldproc = (WNDPROC)SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)ClassTest_WndProc);
754 ok(IS_WNDPROC_HANDLE(oldproc) == FALSE, "Class %s shouldn't return a handle\n", NORMAL_CLASSES[i]);
755 SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)oldproc);
756 DestroyWindow(hwnd);
757 }
758
759 /* Edit controls are special - they return a wndproc handle when GetWindowLongPtr is called with a different A/W.
760 * On the other hand there is no W->A->W conversion so this control is treated specially. */
761 hwnd = CreateWindowW(WC_EDITW, unistring, WS_OVERLAPPEDWINDOW,
762 CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, NULL, 0);
763 /* GetClassLongPtr returns that both the Unicode and ANSI wndproc */
764 ok(IS_WNDPROC_HANDLE(GetClassLongPtrA(hwnd, GCLP_WNDPROC)) == FALSE, "Edit control class should have a Unicode wndproc\n");
765 ok(IS_WNDPROC_HANDLE(GetClassLongPtrW(hwnd, GCLP_WNDPROC)) == FALSE, "Edit control class should have a ANSI wndproc\n");
766 /* But GetWindowLongPtr returns only a handle for the ANSI one */
767 ok(IS_WNDPROC_HANDLE(GetWindowLongPtrA(hwnd, GWLP_WNDPROC)), "Edit control should return a wndproc handle\n");
768 ok(!IS_WNDPROC_HANDLE(GetWindowLongPtrW(hwnd, GWLP_WNDPROC)), "Edit control shouldn't return a W wndproc handle\n");
769 CallWindowProcW((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
770 ok(memcmp(buf, unistring, sizeof(unistring)) == 0, "WM_GETTEXT invalid return\n");
771 CallWindowProcA((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
772 ok(memcmp(buf, unistring, sizeof(unistring)) == 0, "WM_GETTEXT invalid return\n");
773 CallWindowProcW((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
774 ok(memcmp(buf, unistring, sizeof(unistring)) == 0, "WM_GETTEXT invalid return\n");
775
776 SetWindowTextW(hwnd, classW);
777 CallWindowProcA((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
778 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
779
780 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)ClassTest_WndProc2);
781 /* SetWindowLongPtr returns a wndproc handle - like GetWindowLongPtr */
782 ok(IS_WNDPROC_HANDLE(oldproc), "Edit control should return a wndproc handle\n");
783 ok(IsWindowUnicode(hwnd) == FALSE, "SetWindowLongPtrA should have changed window to ANSI\n");
784 SetWindowTextA(hwnd, classA); /* Windows resets the title to WideStringToMultiByte(unistring) */
785 memset(buf, 0, sizeof(buf));
786 CallWindowProcA((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
787 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
788 CallWindowProcA((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
789 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
790 CallWindowProcW((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
791 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
792
793 CallWindowProcW((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
794 ok(memcmp(buf, classW, sizeof(classW)) == 0, "WM_GETTEXT invalid return\n");
795
796 SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)oldproc);
797
798 DestroyWindow(hwnd);
799
800 hwnd = CreateWindowA(WC_EDITA, classA, WS_OVERLAPPEDWINDOW,
801 CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, NULL, 0);
802
803 /* GetClassLongPtr returns that both the Unicode and ANSI wndproc */
804 ok(!IS_WNDPROC_HANDLE(GetClassLongPtrA(hwnd, GCLP_WNDPROC)), "Edit control class should have a Unicode wndproc\n");
805 ok(!IS_WNDPROC_HANDLE(GetClassLongPtrW(hwnd, GCLP_WNDPROC)), "Edit control class should have a ANSI wndproc\n");
806 /* But GetWindowLongPtr returns only a handle for the Unicode one */
807 ok(!IS_WNDPROC_HANDLE(GetWindowLongPtrA(hwnd, GWLP_WNDPROC)), "Edit control shouldn't return an A wndproc handle\n");
808 ok(IS_WNDPROC_HANDLE(GetWindowLongPtrW(hwnd, GWLP_WNDPROC)), "Edit control should return a wndproc handle\n");
809 CallWindowProcA((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
810 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
811 CallWindowProcA((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
812 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
813 CallWindowProcW((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
814 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
815
816 CallWindowProcW((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
817 ok(memcmp(buf, classW, sizeof(classW)) == 0, "WM_GETTEXT invalid return\n");
818
819 oldproc = (WNDPROC)SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)ClassTest_WndProc);
820 SetWindowTextW(hwnd, unistring);
821 CallWindowProcW((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
822 ok(memcmp(buf, unistring, sizeof(unistring)) == 0, "WM_GETTEXT invalid return\n");
823 CallWindowProcA((WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
824 ok(memcmp(buf, unistring, sizeof(unistring)) == 0, "WM_GETTEXT invalid return\n");
825 CallWindowProcW((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
826 ok(memcmp(buf, unistring, sizeof(unistring)) == 0, "WM_GETTEXT invalid return\n");
827
828 SetWindowTextW(hwnd, classW);
829 CallWindowProcA((WNDPROC)GetWindowLongPtrA(hwnd, GWLP_WNDPROC), hwnd, WM_GETTEXT, 120, (LPARAM)buf);
830 ok(memcmp(buf, classA, sizeof(classA)) == 0, "WM_GETTEXT invalid return\n");
831
832 SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)oldproc);
833
834 DestroyWindow(hwnd);
835 }
836
837
838 static LRESULT WINAPI TestDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
839 {
840 return DefWindowProc(hWnd, uMsg, wParam, lParam);
841 }
842
843 static BOOL RegisterTestDialog(HINSTANCE hInstance)
844 {
845 WNDCLASSEX wcx;
846 ATOM atom = 0;
847
848 ZeroMemory(&wcx, sizeof(WNDCLASSEX));
849 wcx.cbSize = sizeof(wcx);
850 wcx.lpfnWndProc = TestDlgProc;
851 wcx.cbClsExtra = 0;
852 wcx.cbWndExtra = DLGWINDOWEXTRA;
853 wcx.hInstance = hInstance;
854 wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
855 wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
856 wcx.hbrBackground = GetStockObject(WHITE_BRUSH);
857 wcx.lpszClassName = "TestDialog";
858 wcx.lpszMenuName = "TestDialog";
859 wcx.hIconSm = LoadImage(hInstance, MAKEINTRESOURCE(5), IMAGE_ICON,
860 GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
861 LR_DEFAULTCOLOR);
862
863 atom = RegisterClassEx(&wcx);
864 ok(atom != 0, "RegisterClassEx returned 0\n");
865
866 return atom;
867 }
868
869 /* test registering a dialog box created by using the CLASS directive in a
870 resource file, then test creating the dialog using CreateDialogParam. */
871 static void CreateDialogParamTest(HINSTANCE hInstance)
872 {
873 HWND hWndMain;
874
875 if (RegisterTestDialog(hInstance))
876 {
877 hWndMain = CreateDialogParam(hInstance, "CLASS_TEST_DIALOG", NULL, 0, 0);
878 ok(hWndMain != NULL, "CreateDialogParam returned NULL\n");
879 ShowWindow(hWndMain, SW_SHOW);
880 DestroyWindow(hWndMain);
881 }
882 }
883
884 static const struct
885 {
886 const char name[9];
887 int value;
888 int badvalue;
889 } extra_values[] =
890 {
891 {"#32770",30,30}, /* Dialog */
892 #ifdef _WIN64
893 {"Edit",8,8},
894 #else
895 {"Edit",6,8}, /* Windows XP 64-bit returns 8 also to 32-bit applications */
896 #endif
897 };
898
899 static void test_extra_values(void)
900 {
901 int i;
902 for(i=0; i< sizeof(extra_values)/sizeof(extra_values[0]); i++)
903 {
904 WNDCLASSEX wcx;
905 BOOL ret = GetClassInfoEx(NULL,extra_values[i].name,&wcx);
906
907 ok( ret, "GetClassInfo (0) failed for global class %s\n", extra_values[i].name);
908 if (!ret) continue;
909 ok(extra_values[i].value == wcx.cbWndExtra || broken(extra_values[i].badvalue == wcx.cbWndExtra),
910 "expected %d, got %d\n", extra_values[i].value, wcx.cbWndExtra);
911 }
912 }
913
914 static void test_GetClassInfo(void)
915 {
916 static const WCHAR staticW[] = {'s','t','a','t','i','c',0};
917 WNDCLASSA wc;
918 WNDCLASSEXA wcx;
919 BOOL ret;
920
921 SetLastError(0xdeadbeef);
922 ret = GetClassInfoA(0, "static", &wc);
923 ok(ret, "GetClassInfoA() error %d\n", GetLastError());
924
925 if (0) { /* crashes under XP */
926 SetLastError(0xdeadbeef);
927 ret = GetClassInfoA(0, "static", NULL);
928 ok(ret, "GetClassInfoA() error %d\n", GetLastError());
929
930 SetLastError(0xdeadbeef);
931 ret = GetClassInfoW(0, staticW, NULL);
932 ok(ret, "GetClassInfoW() error %d\n", GetLastError());
933 }
934
935 wcx.cbSize = sizeof(wcx);
936 SetLastError(0xdeadbeef);
937 ret = GetClassInfoExA(0, "static", &wcx);
938 ok(ret, "GetClassInfoExA() error %d\n", GetLastError());
939
940 SetLastError(0xdeadbeef);
941 ret = GetClassInfoExA(0, "static", NULL);
942 ok(!ret, "GetClassInfoExA() should fail\n");
943 ok(GetLastError() == ERROR_NOACCESS ||
944 broken(GetLastError() == 0xdeadbeef), /* win9x */
945 "expected ERROR_NOACCESS, got %d\n", GetLastError());
946
947 SetLastError(0xdeadbeef);
948 ret = GetClassInfoExW(0, staticW, NULL);
949 ok(!ret, "GetClassInfoExW() should fail\n");
950 ok(GetLastError() == ERROR_NOACCESS ||
951 broken(GetLastError() == 0xdeadbeef) /* NT4 */ ||
952 broken(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED), /* win9x */
953 "expected ERROR_NOACCESS, got %d\n", GetLastError());
954
955 wcx.cbSize = 0;
956 wcx.lpfnWndProc = NULL;
957 SetLastError(0xdeadbeef);
958 ret = GetClassInfoExA(0, "static", &wcx);
959 ok(ret, "GetClassInfoExA() error %d\n", GetLastError());
960 ok(wcx.cbSize == 0, "expected 0, got %u\n", wcx.cbSize);
961 ok(wcx.lpfnWndProc != NULL, "got null proc\n");
962
963 wcx.cbSize = sizeof(wcx) - 1;
964 wcx.lpfnWndProc = NULL;
965 SetLastError(0xdeadbeef);
966 ret = GetClassInfoExA(0, "static", &wcx);
967 ok(ret, "GetClassInfoExA() error %d\n", GetLastError());
968 ok(wcx.cbSize == sizeof(wcx) - 1, "expected sizeof(wcx)-1, got %u\n", wcx.cbSize);
969 ok(wcx.lpfnWndProc != NULL, "got null proc\n");
970
971 wcx.cbSize = sizeof(wcx) + 1;
972 wcx.lpfnWndProc = NULL;
973 SetLastError(0xdeadbeef);
974 ret = GetClassInfoExA(0, "static", &wcx);
975 ok(ret, "GetClassInfoExA() error %d\n", GetLastError());
976 ok(wcx.cbSize == sizeof(wcx) + 1, "expected sizeof(wcx)+1, got %u\n", wcx.cbSize);
977 ok(wcx.lpfnWndProc != NULL, "got null proc\n");
978 }
979
980 START_TEST(class)
981 {
982 HANDLE hInstance = GetModuleHandleA( NULL );
983
984 test_GetClassInfo();
985 test_extra_values();
986
987 if (!GetModuleHandleW(0))
988 {
989 trace("Class test is incompatible with Win9x implementation, skipping\n");
990 return;
991 }
992
993 ClassTest(hInstance,FALSE);
994 ClassTest(hInstance,TRUE);
995 CreateDialogParamTest(hInstance);
996 test_styles();
997 test_builtinproc();
998
999 /* this test unregisters the Button class so it should be executed at the end */
1000 test_instances();
1001 }