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