git.oblomov.eu Git - wine/blob - dlls/user/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #define NUMCLASSWORDS 4
  37
  38 static LRESULT WINAPI ClassTest_WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  39 {
  40     return DefWindowProcW (hWnd, msg, wParam, lParam);
  41 }
  42
  43 /***********************************************************************
  44  */
  45 static void ClassTest(HINSTANCE hInstance, BOOL global)
  46 {
  47     WNDCLASSW cls, wc;
  48     static const WCHAR className[] = {'T','e','s','t','C','l','a','s','s',0};
  49     static const WCHAR winName[]   = {'W','i','n','C','l','a','s','s','T','e','s','t',0};
  50     ATOM test_atom;
  51     HWND hTestWnd;
  52     LONG i;
  53     WCHAR str[20];
  54     ATOM classatom;
  55
  56     cls.style         = CS_HREDRAW | CS_VREDRAW | (global?CS_GLOBALCLASS:0);
  57     cls.lpfnWndProc   = ClassTest_WndProc;
  58     cls.cbClsExtra    = NUMCLASSWORDS*sizeof(DWORD);
  59     cls.cbWndExtra    = 12;
  60     cls.hInstance     = hInstance;
  61     cls.hIcon         = LoadIconW (0, (LPWSTR)IDI_APPLICATION);
  62     cls.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
  63     cls.hbrBackground = GetStockObject (WHITE_BRUSH);
  64     cls.lpszMenuName  = 0;
  65     cls.lpszClassName = className;
  66
  67     classatom=RegisterClassW(&cls);
  68     if (!classatom && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
  69         return;
  70     ok(classatom, "failed to register class\n");
  71
  72     ok(!RegisterClassW (&cls),
  73         "RegisterClass of the same class should fail for the second time\n");
  74
  75     /* Setup windows */
  76     hTestWnd = CreateWindowW (className, winName,
  77        WS_OVERLAPPEDWINDOW + WS_HSCROLL + WS_VSCROLL,
  78        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, 0,
  79        0, hInstance, 0);
  80
  81     ok(hTestWnd!=0, "Failed to create window\n");
  82
  83     /* test initial values of valid classwords */
  84     for(i=0; i<NUMCLASSWORDS; i++)
  85     {
  86         SetLastError(0);
  87         ok(!GetClassLongW(hTestWnd,i*sizeof (DWORD)),
  88             "GetClassLongW initial value nonzero!\n");
  89         ok(!GetLastError(),
  90             "GetClassLongW failed!\n");
  91     }
  92
  93 #if 0
  94     /*
  95      *  GetClassLongW(hTestWnd, NUMCLASSWORDS*sizeof(DWORD))
  96      *  does not fail on Win 98, though MSDN says it should
  97      */
  98     SetLastError(0);
  99     GetClassLongW(hTestWnd, NUMCLASSWORDS*sizeof(DWORD));
 100     ok(GetLastError(),
 101         "GetClassLongW() with invalid offset did not fail\n");
 102 #endif
 103
 104     /* set values of valid class words */
 105     for(i=0; i<NUMCLASSWORDS; i++)
 106     {
 107         SetLastError(0);
 108         ok(!SetClassLongW(hTestWnd,i*sizeof(DWORD),i+1),
 109             "GetClassLongW(%ld) initial value nonzero!\n",i*sizeof(DWORD));
 110         ok(!GetLastError(),
 111             "SetClassLongW(%ld) failed!\n",i*sizeof(DWORD));
 112     }
 113
 114     /* test values of valid classwords that we set */
 115     for(i=0; i<NUMCLASSWORDS; i++)
 116     {
 117         SetLastError(0);
 118         ok( (i+1) == GetClassLongW(hTestWnd,i*sizeof (DWORD)),
 119             "GetClassLongW value doesn't match what was set!\n");
 120         ok(!GetLastError(),
 121             "GetClassLongW failed!\n");
 122     }
 123
 124     /* check GetClassName */
 125     i = GetClassNameW(hTestWnd, str, sizeof(str));
 126     ok(i == lstrlenW(className),
 127         "GetClassName returned incorrect length\n");
 128     ok(!lstrcmpW(className,str),
 129         "GetClassName returned incorrect name for this window's class\n");
 130
 131     /* check GetClassInfo with our hInstance */
 132     if((test_atom = GetClassInfoW(hInstance, str, &wc)))
 133     {
 134         ok(test_atom == classatom,
 135             "class atom did not match\n");
 136         ok(wc.cbClsExtra == cls.cbClsExtra,
 137             "cbClsExtra did not match\n");
 138         ok(wc.cbWndExtra == cls.cbWndExtra,
 139             "cbWndExtra did not match\n");
 140         ok(wc.hbrBackground == cls.hbrBackground,
 141             "hbrBackground did not match\n");
 142         ok(wc.hCursor== cls.hCursor,
 143             "hCursor did not match\n");
 144         ok(wc.hInstance== cls.hInstance,
 145             "hInstance did not match\n");
 146     }
 147     else
 148         ok(FALSE,"GetClassInfo (hinstance) failed!\n");
 149
 150     /* check GetClassInfo with zero hInstance */
 151     if(global)
 152     {
 153         if((test_atom = GetClassInfoW(0, str, &wc)))
 154         {
 155             ok(test_atom == classatom,
 156                 "class atom did not match %x != %x\n", test_atom, classatom);
 157             ok(wc.cbClsExtra == cls.cbClsExtra,
 158                 "cbClsExtra did not match %x!=%x\n",wc.cbClsExtra,cls.cbClsExtra);
 159             ok(wc.cbWndExtra == cls.cbWndExtra,
 160                 "cbWndExtra did not match %x!=%x\n",wc.cbWndExtra,cls.cbWndExtra);
 161             ok(wc.hbrBackground == cls.hbrBackground,
 162                 "hbrBackground did not match %p!=%p\n",wc.hbrBackground,cls.hbrBackground);
 163             ok(wc.hCursor== cls.hCursor,
 164                 "hCursor did not match %p!=%p\n",wc.hCursor,cls.hCursor);
 165             ok(!wc.hInstance,
 166                 "hInstance not zero for global class %p\n",wc.hInstance);
 167         }
 168         else
 169             ok(FALSE,"GetClassInfo (0) failed for global class!\n");
 170     }
 171     else
 172     {
 173         ok(!GetClassInfoW(0, str, &wc),
 174             "GetClassInfo (0) succeeded for local class!\n");
 175     }
 176
 177     ok(!UnregisterClassW(className, hInstance),
 178         "Unregister class succeeded with window existing\n");
 179
 180     ok(DestroyWindow(hTestWnd),
 181         "DestroyWindow() failed!\n");
 182
 183     ok(UnregisterClassW(className, hInstance),
 184         "UnregisterClass() failed\n");
 185
 186     return;
 187 }
 188
 189 static void check_style( const char *name, int must_exist, UINT style, UINT ignore )
 190 {
 191     WNDCLASS wc;
 192
 193     if (GetClassInfo( 0, name, &wc ))
 194     {
 195         ok( !(~wc.style & style & ~ignore), "System class %s is missing bits %x (%08x/%08x)\n",
 196             name, ~wc.style & style, wc.style, style );
 197         ok( !(wc.style & ~style), "System class %s has extra bits %x (%08x/%08x)\n",
 198             name, wc.style & ~style, wc.style, style );
 199     }
 200     else
 201         ok( !must_exist, "System class %s does not exist\n", name );
 202 }
 203
 204 /* test styles of system classes */
 205 static void test_styles(void)
 206 {
 207     /* check style bits */
 208     check_style( "Button",     1, CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, 0 );
 209     check_style( "ComboBox",   1, CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, 0 );
 210     check_style( "Edit",       1, CS_PARENTDC | CS_DBLCLKS, 0 );
 211     check_style( "ListBox",    1, CS_PARENTDC | CS_DBLCLKS, CS_PARENTDC /*FIXME*/ );
 212     check_style( "MDIClient",  1, 0, 0 );
 213     check_style( "ScrollBar",  1, CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, 0 );
 214     check_style( "Static",     1, CS_PARENTDC | CS_DBLCLKS, 0 );
 215     check_style( "ComboLBox",  1, CS_SAVEBITS | CS_DBLCLKS, 0 );
 216     check_style( "DDEMLEvent", 0, 0, 0 );
 217     check_style( "Message",    0, 0, 0 );
 218     check_style( "#32768",     1, CS_DROPSHADOW | CS_SAVEBITS | CS_DBLCLKS, CS_DROPSHADOW );  /* menu */
 219     check_style( "#32769",     1, CS_DBLCLKS, 0 );  /* desktop */
 220     check_style( "#32770",     1, CS_SAVEBITS | CS_DBLCLKS, 0 );  /* dialog */
 221     todo_wine { check_style( "#32771",     1, CS_SAVEBITS | CS_HREDRAW | CS_VREDRAW, 0 ); } /* task switch */
 222     check_style( "#32772",     1, 0, 0 );  /* icon title */
 223 }
 224
 225 static void check_class(HINSTANCE inst, const char *name, const char *menu_name)
 226 {
 227     WNDCLASS wc;
 228     UINT atom = GetClassInfo(inst,name,&wc);
 229     ok( atom, "Class %s %p not found\n", name, inst );
 230     if (atom)
 231     {
 232         if (wc.lpszMenuName && menu_name)
 233             ok( !strcmp( menu_name, wc.lpszMenuName ), "Wrong name %s/%s for class %s %p\n",
 234                 wc.lpszMenuName, menu_name, name, inst );
 235         else
 236             ok( !menu_name == !wc.lpszMenuName, "Wrong name %p/%p for class %s %p\n",
 237                 wc.lpszMenuName, menu_name, name, inst );
 238     }
 239 }
 240
 241 static void check_instance( const char *name, HINSTANCE inst, HINSTANCE info_inst, HINSTANCE gcl_inst )
 242 {
 243     WNDCLASSA wc;
 244     HWND hwnd;
 245
 246     ok( GetClassInfo( inst, name, &wc ), "Couldn't find class %s inst %p\n", name, inst );
 247     ok( wc.hInstance == info_inst, "Wrong info instance %p/%p for class %s\n",
 248         wc.hInstance, info_inst, name );
 249     hwnd = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, inst, 0 );
 250     ok( hwnd != NULL, "Couldn't create window for class %s inst %p\n", name, inst );
 251     ok( (HINSTANCE)GetClassLongPtrA( hwnd, GCLP_HMODULE ) == gcl_inst,
 252         "Wrong GCL instance %p/%p for class %s\n",
 253         (HINSTANCE)GetClassLongPtrA( hwnd, GCLP_HMODULE ), gcl_inst, name );
 254     ok( (HINSTANCE)GetWindowLongPtrA( hwnd, GWLP_HINSTANCE ) == inst,
 255         "Wrong GWL instance %p/%p for window %s\n",
 256         (HINSTANCE)GetWindowLongPtrA( hwnd, GWLP_HINSTANCE ), inst, name );
 257     ok(!UnregisterClassA(name, inst), "UnregisterClassA should fail while exists a class window\n");
 258     ok(GetLastError() == ERROR_CLASS_HAS_WINDOWS, "GetLastError() should be set to ERROR_CLASS_HAS_WINDOWS not %ld\n", GetLastError());
 259     DestroyWindow(hwnd);
 260 }
 261
 262 struct class_info
 263 {
 264     const char *name;
 265     HINSTANCE inst, info_inst, gcl_inst;
 266 };
 267
 268 static DWORD WINAPI thread_proc(void *param)
 269 {
 270     struct class_info *class_info = (struct class_info *)param;
 271
 272     check_instance(class_info->name, class_info->inst, class_info->info_inst, class_info->gcl_inst);
 273
 274     return 0;
 275 }
 276
 277 static void check_thread_instance( const char *name, HINSTANCE inst, HINSTANCE info_inst, HINSTANCE gcl_inst )
 278 {
 279     HANDLE hThread;
 280     DWORD tid;
 281     struct class_info class_info;
 282
 283     class_info.name = name;
 284     class_info.inst = inst;
 285     class_info.info_inst = info_inst;
 286     class_info.gcl_inst = gcl_inst;
 287
 288     hThread = CreateThread(NULL, 0, thread_proc, &class_info, 0, &tid);
 289     ok(hThread != NULL, "CreateThread failed, error %ld\n", GetLastError());
 290     ok(WaitForSingleObject(hThread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
 291     CloseHandle(hThread);
 292 }
 293
 294 /* test various instance parameters */
 295 static void test_instances(void)
 296 {
 297     WNDCLASSA cls, wc;
 298     HWND hwnd, hwnd2;
 299     const char *name = "__test__";
 300     HINSTANCE kernel32 = GetModuleHandleA("kernel32");
 301     HINSTANCE user32 = GetModuleHandleA("user32");
 302     HINSTANCE main_module = GetModuleHandleA(NULL);
 303
 304     memset( &cls, 0, sizeof(cls) );
 305     cls.style         = CS_HREDRAW | CS_VREDRAW;
 306     cls.lpfnWndProc   = ClassTest_WndProc;
 307     cls.cbClsExtra    = 0;
 308     cls.cbWndExtra    = 0;
 309     cls.lpszClassName = name;
 310
 311     cls.lpszMenuName  = "main_module";
 312     cls.hInstance = main_module;
 313
 314     ok( RegisterClassA( &cls ), "Failed to register local class for main module\n" );
 315     check_class( main_module, name, "main_module" );
 316     check_instance( name, main_module, main_module, main_module );
 317     check_thread_instance( name, main_module, main_module, main_module );
 318
 319     cls.lpszMenuName  = "kernel32";
 320     cls.hInstance = kernel32;
 321     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 322     check_class( kernel32, name, "kernel32" );
 323     check_class( main_module, name, "main_module" );
 324     check_instance( name, kernel32, kernel32, kernel32 );
 325     check_thread_instance( name, kernel32, kernel32, kernel32 );
 326     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 327
 328     /* Bug 2631 - Supplying an invalid number of bytes fails */
 329     cls.cbClsExtra    = 0;
 330     cls.cbWndExtra    = -1;
 331     SetLastError(0xdeadbeef);
 332     ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
 333           "Failed with invalid number of WndExtra bytes\n");
 334
 335     cls.cbClsExtra    = -1;
 336     cls.cbWndExtra    = 0;
 337     SetLastError(0xdeadbeef);
 338     ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
 339           "Failed with invalid number of ClsExtra bytes\n");
 340
 341     cls.cbClsExtra    = -1;
 342     cls.cbWndExtra    = -1;
 343     SetLastError(0xdeadbeef);
 344     ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
 345           "Failed with invalid number of ClsExtra and cbWndExtra bytes\n");
 346
 347     cls.cbClsExtra    = 0;
 348     cls.cbWndExtra    = 0;
 349     SetLastError(0xdeadbeef);
 350
 351     /* setting global flag doesn't change status of class */
 352     hwnd = CreateWindowExA( 0, name, "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
 353     SetClassLongA( hwnd, GCL_STYLE, CS_GLOBALCLASS );
 354     cls.lpszMenuName  = "kernel32";
 355     cls.hInstance = kernel32;
 356     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 357     check_class( kernel32, name, "kernel32" );
 358     check_class( main_module, name, "main_module" );
 359     check_instance( name, kernel32, kernel32, kernel32 );
 360     check_instance( name, main_module, main_module, main_module );
 361     check_thread_instance( name, kernel32, kernel32, kernel32 );
 362     check_thread_instance( name, main_module, main_module, main_module );
 363     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 364
 365     /* changing the instance doesn't make it global */
 366     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0 );
 367     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 368     check_class( kernel32, name, "kernel32" );
 369     check_instance( name, kernel32, kernel32, kernel32 );
 370     check_thread_instance( name, kernel32, kernel32, kernel32 );
 371     ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
 372     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 373
 374     /* GetClassInfo with instance 0 finds user32 instance */
 375     SetClassLongPtrA( hwnd, GCLP_HMODULE, (LONG_PTR)user32 );
 376     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 377     check_class( kernel32, name, "kernel32" );
 378     check_class( user32, name, "main_module" );
 379     check_class( 0, name, "main_module" );
 380     check_instance( name, kernel32, kernel32, kernel32 );
 381     check_instance( name, user32, 0, user32 );
 382     check_instance( name, 0, 0, kernel32 );
 383     check_thread_instance( name, kernel32, kernel32, kernel32 );
 384     check_thread_instance( name, user32, 0, user32 );
 385     check_thread_instance( name, 0, 0, kernel32 );
 386     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 387
 388     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0x12345678 );
 389     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 390     check_class( kernel32, name, "kernel32" );
 391     check_class( (HINSTANCE)0x12345678, name, "main_module" );
 392     check_instance( name, kernel32, kernel32, kernel32 );
 393     check_instance( name, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678 );
 394     check_thread_instance( name, kernel32, kernel32, kernel32 );
 395     check_thread_instance( name, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678 );
 396     ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
 397
 398     /* creating a window with instance 0 uses the first class found */
 399     cls.hInstance = (HINSTANCE)0xdeadbeef;
 400     cls.lpszMenuName = "deadbeef";
 401     cls.style = 3;
 402     ok( RegisterClassA( &cls ), "Failed to register local class for deadbeef\n" );
 403     hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
 404     ok( (HINSTANCE)GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == (HINSTANCE)0xdeadbeef,
 405         "Didn't get deadbeef class for null instance\n" );
 406     DestroyWindow( hwnd2 );
 407     ok( UnregisterClassA( name, (HINSTANCE)0xdeadbeef ), "Unregister failed for deadbeef\n" );
 408
 409     hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
 410     ok( (HINSTANCE)GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == kernel32,
 411         "Didn't get kernel32 class for null instance\n" );
 412     DestroyWindow( hwnd2 );
 413
 414     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 415
 416     hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
 417     ok( GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == 0x12345678,
 418         "Didn't get 12345678 class for null instance\n" );
 419     DestroyWindow( hwnd2 );
 420
 421     SetClassLongPtrA( hwnd, GCLP_HMODULE, (LONG_PTR)main_module );
 422     DestroyWindow( hwnd );
 423
 424     /* null handle means the same thing as main module */
 425     cls.lpszMenuName  = "null";
 426     cls.hInstance = 0;
 427     ok( !RegisterClassA( &cls ), "Succeeded registering local class for null instance\n" );
 428     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %ld\n", GetLastError() );
 429     ok( UnregisterClassA( name, main_module ), "Unregister failed for main module\n" );
 430
 431     ok( RegisterClassA( &cls ), "Failed to register local class for null instance\n" );
 432     /* must be found with main module handle */
 433     check_class( main_module, name, "null" );
 434     check_instance( name, main_module, main_module, main_module );
 435     check_thread_instance( name, main_module, main_module, main_module );
 436     ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
 437     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %ld\n", GetLastError() );
 438     ok( UnregisterClassA( name, 0 ), "Unregister failed for null instance\n" );
 439
 440     /* registering for user32 always fails */
 441     cls.lpszMenuName = "user32";
 442     cls.hInstance = user32;
 443     ok( !RegisterClassA( &cls ), "Succeeded registering local class for user32\n" );
 444     ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error code %ld\n", GetLastError() );
 445     cls.style |= CS_GLOBALCLASS;
 446     ok( !RegisterClassA( &cls ), "Succeeded registering global class for user32\n" );
 447     ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error code %ld\n", GetLastError() );
 448
 449     /* unregister is OK though */
 450     cls.hInstance = main_module;
 451     ok( RegisterClassA( &cls ), "Failed to register global class for main module\n" );
 452     ok( UnregisterClassA( name, user32 ), "Unregister failed for user32\n" );
 453
 454     /* instance doesn't matter for global class */
 455     cls.style |= CS_GLOBALCLASS;
 456     cls.lpszMenuName  = "main_module";
 457     cls.hInstance = main_module;
 458     ok( RegisterClassA( &cls ), "Failed to register global class for main module\n" );
 459     cls.lpszMenuName  = "kernel32";
 460     cls.hInstance = kernel32;
 461     ok( !RegisterClassA( &cls ), "Succeeded registering local class for kernel32\n" );
 462     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %ld\n", GetLastError() );
 463     /* even if global flag is cleared */
 464     hwnd = CreateWindowExA( 0, name, "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
 465     SetClassLongA( hwnd, GCL_STYLE, 0 );
 466     ok( !RegisterClassA( &cls ), "Succeeded registering local class for kernel32\n" );
 467     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %ld\n", GetLastError() );
 468
 469     check_class( main_module, name, "main_module" );
 470     check_class( kernel32, name, "main_module" );
 471     check_class( 0, name, "main_module" );
 472     check_class( (HINSTANCE)0x12345678, name, "main_module" );
 473     check_instance( name, main_module, main_module, main_module );
 474     check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, main_module );
 475     check_thread_instance( name, main_module, main_module, main_module );
 476     check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, main_module );
 477
 478     /* changing the instance for global class doesn't make much difference */
 479     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0xdeadbeef );
 480     check_instance( name, main_module, main_module, (HINSTANCE)0xdeadbeef );
 481     check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef );
 482     check_thread_instance( name, main_module, main_module, (HINSTANCE)0xdeadbeef );
 483     check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef );
 484
 485     DestroyWindow( hwnd );
 486     ok( UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister failed for main module global\n" );
 487     ok( !UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister succeeded the second time\n" );
 488     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %ld\n", GetLastError() );
 489
 490     cls.hInstance = (HINSTANCE)0x12345678;
 491     ok( RegisterClassA( &cls ), "Failed to register global class for dummy instance\n" );
 492     check_instance( name, main_module, main_module, (HINSTANCE)0x12345678 );
 493     check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0x12345678 );
 494     check_thread_instance( name, main_module, main_module, (HINSTANCE)0x12345678 );
 495     check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0x12345678 );
 496     ok( UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister failed for main module global\n" );
 497
 498     /* check system classes */
 499
 500     /* we cannot register a global class with the name of a system class */
 501     cls.style |= CS_GLOBALCLASS;
 502     cls.lpszMenuName  = "button_main_module";
 503     cls.lpszClassName = "BUTTON";
 504     cls.hInstance = main_module;
 505     ok( !RegisterClassA( &cls ), "Succeeded registering global button class for main module\n" );
 506     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %ld\n", GetLastError() );
 507     cls.hInstance = kernel32;
 508     ok( !RegisterClassA( &cls ), "Succeeded registering global button class for kernel32\n" );
 509     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %ld\n", GetLastError() );
 510
 511     /* local class is OK however */
 512     cls.style &= ~CS_GLOBALCLASS;
 513     cls.lpszMenuName  = "button_main_module";
 514     cls.hInstance = main_module;
 515     ok( RegisterClassA( &cls ), "Failed to register local button class for main module\n" );
 516     check_class( main_module, "BUTTON", "button_main_module" );
 517     cls.lpszMenuName  = "button_kernel32";
 518     cls.hInstance = kernel32;
 519     ok( RegisterClassA( &cls ), "Failed to register local button class for kernel32\n" );
 520     check_class( kernel32, "BUTTON", "button_kernel32" );
 521     check_class( main_module, "BUTTON", "button_main_module" );
 522     ok( UnregisterClassA( "BUTTON", kernel32 ), "Unregister failed for kernel32 button\n" );
 523     ok( UnregisterClassA( "BUTTON", main_module ), "Unregister failed for main module button\n" );
 524     /* GetClassInfo sets instance to passed value for global classes */
 525     check_instance( "BUTTON", 0, 0, user32 );
 526     check_instance( "BUTTON", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 527     check_instance( "BUTTON", user32, 0, user32 );
 528     check_thread_instance( "BUTTON", 0, 0, user32 );
 529     check_thread_instance( "BUTTON", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 530     check_thread_instance( "BUTTON", user32, 0, user32 );
 531
 532     /* we can unregister system classes */
 533     ok( GetClassInfo( 0, "BUTTON", &wc ), "Button class not found with null instance\n" );
 534     ok( GetClassInfo( kernel32, "BUTTON", &wc ), "Button class not found with kernel32\n" );
 535     ok( UnregisterClass( "BUTTON", (HINSTANCE)0x12345678 ), "Failed to unregister button\n" );
 536     ok( !UnregisterClass( "BUTTON", (HINSTANCE)0x87654321 ), "Unregistered button a second time\n" );
 537     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %ld\n", GetLastError() );
 538     ok( !GetClassInfo( 0, "BUTTON", &wc ), "Button still exists\n" );
 539     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %ld\n", GetLastError() );
 540
 541     /* we can change the instance of a system class */
 542     check_instance( "EDIT", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 543     check_thread_instance( "EDIT", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 544     hwnd = CreateWindowExA( 0, "EDIT", "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
 545     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0xdeadbeef );
 546     check_instance( "EDIT", (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0xdeadbeef );
 547     check_thread_instance( "EDIT", (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0xdeadbeef );
 548 }
 549
 550 static LRESULT WINAPI TestDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 551 {
 552     return DefWindowProc(hWnd, uMsg, wParam, lParam);
 553 }
 554
 555 static BOOL RegisterTestDialog(HINSTANCE hInstance)
 556 {
 557     WNDCLASSEX wcx;
 558     ATOM atom = 0;
 559
 560     ZeroMemory(&wcx, sizeof(WNDCLASSEX));
 561     wcx.cbSize = sizeof(wcx);
 562     wcx.lpfnWndProc = TestDlgProc;
 563     wcx.cbClsExtra = 0;
 564     wcx.cbWndExtra = DLGWINDOWEXTRA;
 565     wcx.hInstance = hInstance;
 566     wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
 567     wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
 568     wcx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
 569     wcx.lpszClassName = "TestDialog";
 570     wcx.lpszMenuName =  "TestDialog";
 571     wcx.hIconSm = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(5),
 572         IMAGE_ICON,
 573         GetSystemMetrics(SM_CXSMICON),
 574         GetSystemMetrics(SM_CYSMICON),
 575         LR_DEFAULTCOLOR);
 576
 577     atom = RegisterClassEx(&wcx);
 578     ok(atom != 0, "RegisterClassEx returned 0\n");
 579
 580     return atom;
 581 }
 582
 583 /* test registering a dialog box created by using the CLASS directive in a
 584    resource file, then test creating the dialog using CreateDialogParam. */
 585 static void WINAPI CreateDialogParamTest(HINSTANCE hInstance)
 586 {
 587     HWND hWndMain;
 588
 589     if (RegisterTestDialog(hInstance))
 590     {
 591         hWndMain = CreateDialogParam(hInstance, "CLASS_TEST_DIALOG", NULL, 0, 0);
 592         ok(hWndMain != NULL, "CreateDialogParam returned NULL\n");
 593         ShowWindow(hWndMain, SW_SHOW);
 594         DestroyWindow(hWndMain);
 595     }
 596 }
 597
 598 START_TEST(class)
 599 {
 600     HANDLE hInstance = GetModuleHandleA( NULL );
 601
 602     if (!GetModuleHandleW(0))
 603     {
 604         trace("Class test is incompatible with Win9x implementation, skipping\n");
 605         return;
 606     }
 607
 608     ClassTest(hInstance,FALSE);
 609     ClassTest(hInstance,TRUE);
 610     CreateDialogParamTest(hInstance);
 611     test_styles();
 612     test_instances();
 613 }