git.oblomov.eu Git - wine/blob - 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 #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(%d) initial value nonzero!\n",i);
 110         ok(!GetLastError(),
 111             "SetClassLongW(%d) failed!\n",i);
 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 %d\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 %d\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     DWORD r;
 304     char buffer[0x10];
 305
 306     memset( &cls, 0, sizeof(cls) );
 307     cls.style         = CS_HREDRAW | CS_VREDRAW;
 308     cls.lpfnWndProc   = ClassTest_WndProc;
 309     cls.cbClsExtra    = 0;
 310     cls.cbWndExtra    = 0;
 311     cls.lpszClassName = name;
 312
 313     cls.lpszMenuName  = "main_module";
 314     cls.hInstance = main_module;
 315
 316     ok( RegisterClassA( &cls ), "Failed to register local class for main module\n" );
 317     check_class( main_module, name, "main_module" );
 318     check_instance( name, main_module, main_module, main_module );
 319     check_thread_instance( name, main_module, main_module, main_module );
 320
 321     cls.lpszMenuName  = "kernel32";
 322     cls.hInstance = kernel32;
 323     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 324     check_class( kernel32, name, "kernel32" );
 325     check_class( main_module, name, "main_module" );
 326     check_instance( name, kernel32, kernel32, kernel32 );
 327     check_thread_instance( name, kernel32, kernel32, kernel32 );
 328     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 329
 330     /* Bug 2631 - Supplying an invalid number of bytes fails */
 331     cls.cbClsExtra    = 0;
 332     cls.cbWndExtra    = -1;
 333     SetLastError(0xdeadbeef);
 334     ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
 335           "Failed with invalid number of WndExtra bytes\n");
 336
 337     cls.cbClsExtra    = -1;
 338     cls.cbWndExtra    = 0;
 339     SetLastError(0xdeadbeef);
 340     ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
 341           "Failed with invalid number of ClsExtra bytes\n");
 342
 343     cls.cbClsExtra    = -1;
 344     cls.cbWndExtra    = -1;
 345     SetLastError(0xdeadbeef);
 346     ok( ((RegisterClassA( &cls ) == 0) && (GetLastError() == ERROR_INVALID_PARAMETER)),
 347           "Failed with invalid number of ClsExtra and cbWndExtra bytes\n");
 348
 349     cls.cbClsExtra    = 0;
 350     cls.cbWndExtra    = 0;
 351     SetLastError(0xdeadbeef);
 352
 353     /* setting global flag doesn't change status of class */
 354     hwnd = CreateWindowExA( 0, name, "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
 355     SetClassLongA( hwnd, GCL_STYLE, CS_GLOBALCLASS );
 356     cls.lpszMenuName  = "kernel32";
 357     cls.hInstance = kernel32;
 358     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 359     check_class( kernel32, name, "kernel32" );
 360     check_class( main_module, name, "main_module" );
 361     check_instance( name, kernel32, kernel32, kernel32 );
 362     check_instance( name, main_module, main_module, main_module );
 363     check_thread_instance( name, kernel32, kernel32, kernel32 );
 364     check_thread_instance( name, main_module, main_module, main_module );
 365     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 366
 367     /* changing the instance doesn't make it global */
 368     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0 );
 369     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 370     check_class( kernel32, name, "kernel32" );
 371     check_instance( name, kernel32, kernel32, kernel32 );
 372     check_thread_instance( name, kernel32, kernel32, kernel32 );
 373     ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
 374     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 375
 376     /* GetClassInfo with instance 0 finds user32 instance */
 377     SetClassLongPtrA( hwnd, GCLP_HMODULE, (LONG_PTR)user32 );
 378     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 379     check_class( kernel32, name, "kernel32" );
 380     check_class( user32, name, "main_module" );
 381     check_class( 0, name, "main_module" );
 382     check_instance( name, kernel32, kernel32, kernel32 );
 383     check_instance( name, user32, 0, user32 );
 384     check_instance( name, 0, 0, kernel32 );
 385     check_thread_instance( name, kernel32, kernel32, kernel32 );
 386     check_thread_instance( name, user32, 0, user32 );
 387     check_thread_instance( name, 0, 0, kernel32 );
 388     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 389
 390     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0x12345678 );
 391     ok( RegisterClassA( &cls ), "Failed to register local class for kernel32\n" );
 392     check_class( kernel32, name, "kernel32" );
 393     check_class( (HINSTANCE)0x12345678, name, "main_module" );
 394     check_instance( name, kernel32, kernel32, kernel32 );
 395     check_instance( name, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678 );
 396     check_thread_instance( name, kernel32, kernel32, kernel32 );
 397     check_thread_instance( name, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0x12345678 );
 398     ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
 399
 400     /* creating a window with instance 0 uses the first class found */
 401     cls.hInstance = (HINSTANCE)0xdeadbeef;
 402     cls.lpszMenuName = "deadbeef";
 403     cls.style = 3;
 404     ok( RegisterClassA( &cls ), "Failed to register local class for deadbeef\n" );
 405     hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
 406     ok( (HINSTANCE)GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == (HINSTANCE)0xdeadbeef,
 407         "Didn't get deadbeef class for null instance\n" );
 408     DestroyWindow( hwnd2 );
 409     ok( UnregisterClassA( name, (HINSTANCE)0xdeadbeef ), "Unregister failed for deadbeef\n" );
 410
 411     hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
 412     ok( (HINSTANCE)GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == kernel32,
 413         "Didn't get kernel32 class for null instance\n" );
 414     DestroyWindow( hwnd2 );
 415
 416     r = GetClassName( hwnd, buffer, 4 );
 417     ok( r == 3, "expected 3, got %d\n", r );
 418     ok( !strcmp( buffer, "__t"), "name wrong: %s\n", buffer );
 419
 420     ok( UnregisterClassA( name, kernel32 ), "Unregister failed for kernel32\n" );
 421
 422     hwnd2 = CreateWindowExA( 0, name, "test_window", 0, 0, 0, 0, 0, 0, 0, NULL, 0 );
 423     ok( GetClassLongPtrA( hwnd2, GCLP_HMODULE ) == 0x12345678,
 424         "Didn't get 12345678 class for null instance\n" );
 425     DestroyWindow( hwnd2 );
 426
 427     SetClassLongPtrA( hwnd, GCLP_HMODULE, (LONG_PTR)main_module );
 428     DestroyWindow( hwnd );
 429
 430     /* null handle means the same thing as main module */
 431     cls.lpszMenuName  = "null";
 432     cls.hInstance = 0;
 433     ok( !RegisterClassA( &cls ), "Succeeded registering local class for null instance\n" );
 434     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
 435     ok( UnregisterClassA( name, main_module ), "Unregister failed for main module\n" );
 436
 437     ok( RegisterClassA( &cls ), "Failed to register local class for null instance\n" );
 438     /* must be found with main module handle */
 439     check_class( main_module, name, "null" );
 440     check_instance( name, main_module, main_module, main_module );
 441     check_thread_instance( name, main_module, main_module, main_module );
 442     ok( !GetClassInfo( 0, name, &wc ), "Class found with null instance\n" );
 443     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %d\n", GetLastError() );
 444     ok( UnregisterClassA( name, 0 ), "Unregister failed for null instance\n" );
 445
 446     /* registering for user32 always fails */
 447     cls.lpszMenuName = "user32";
 448     cls.hInstance = user32;
 449     ok( !RegisterClassA( &cls ), "Succeeded registering local class for user32\n" );
 450     ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error code %d\n", GetLastError() );
 451     cls.style |= CS_GLOBALCLASS;
 452     ok( !RegisterClassA( &cls ), "Succeeded registering global class for user32\n" );
 453     ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error code %d\n", GetLastError() );
 454
 455     /* unregister is OK though */
 456     cls.hInstance = main_module;
 457     ok( RegisterClassA( &cls ), "Failed to register global class for main module\n" );
 458     ok( UnregisterClassA( name, user32 ), "Unregister failed for user32\n" );
 459
 460     /* instance doesn't matter for global class */
 461     cls.style |= CS_GLOBALCLASS;
 462     cls.lpszMenuName  = "main_module";
 463     cls.hInstance = main_module;
 464     ok( RegisterClassA( &cls ), "Failed to register global class for main module\n" );
 465     cls.lpszMenuName  = "kernel32";
 466     cls.hInstance = kernel32;
 467     ok( !RegisterClassA( &cls ), "Succeeded registering local class for kernel32\n" );
 468     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
 469     /* even if global flag is cleared */
 470     hwnd = CreateWindowExA( 0, name, "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
 471     SetClassLongA( hwnd, GCL_STYLE, 0 );
 472     ok( !RegisterClassA( &cls ), "Succeeded registering local class for kernel32\n" );
 473     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
 474
 475     check_class( main_module, name, "main_module" );
 476     check_class( kernel32, name, "main_module" );
 477     check_class( 0, name, "main_module" );
 478     check_class( (HINSTANCE)0x12345678, name, "main_module" );
 479     check_instance( name, main_module, main_module, main_module );
 480     check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, main_module );
 481     check_thread_instance( name, main_module, main_module, main_module );
 482     check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, main_module );
 483
 484     /* changing the instance for global class doesn't make much difference */
 485     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0xdeadbeef );
 486     check_instance( name, main_module, main_module, (HINSTANCE)0xdeadbeef );
 487     check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef );
 488     check_thread_instance( name, main_module, main_module, (HINSTANCE)0xdeadbeef );
 489     check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef );
 490
 491     DestroyWindow( hwnd );
 492     ok( UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister failed for main module global\n" );
 493     ok( !UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister succeeded the second time\n" );
 494     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %d\n", GetLastError() );
 495
 496     cls.hInstance = (HINSTANCE)0x12345678;
 497     ok( RegisterClassA( &cls ), "Failed to register global class for dummy instance\n" );
 498     check_instance( name, main_module, main_module, (HINSTANCE)0x12345678 );
 499     check_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0x12345678 );
 500     check_thread_instance( name, main_module, main_module, (HINSTANCE)0x12345678 );
 501     check_thread_instance( name, (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, (HINSTANCE)0x12345678 );
 502     ok( UnregisterClassA( name, (HINSTANCE)0x87654321 ), "Unregister failed for main module global\n" );
 503
 504     /* check system classes */
 505
 506     /* we cannot register a global class with the name of a system class */
 507     cls.style |= CS_GLOBALCLASS;
 508     cls.lpszMenuName  = "button_main_module";
 509     cls.lpszClassName = "BUTTON";
 510     cls.hInstance = main_module;
 511     ok( !RegisterClassA( &cls ), "Succeeded registering global button class for main module\n" );
 512     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
 513     cls.hInstance = kernel32;
 514     ok( !RegisterClassA( &cls ), "Succeeded registering global button class for kernel32\n" );
 515     ok( GetLastError() == ERROR_CLASS_ALREADY_EXISTS, "Wrong error code %d\n", GetLastError() );
 516
 517     /* local class is OK however */
 518     cls.style &= ~CS_GLOBALCLASS;
 519     cls.lpszMenuName  = "button_main_module";
 520     cls.hInstance = main_module;
 521     ok( RegisterClassA( &cls ), "Failed to register local button class for main module\n" );
 522     check_class( main_module, "BUTTON", "button_main_module" );
 523     cls.lpszMenuName  = "button_kernel32";
 524     cls.hInstance = kernel32;
 525     ok( RegisterClassA( &cls ), "Failed to register local button class for kernel32\n" );
 526     check_class( kernel32, "BUTTON", "button_kernel32" );
 527     check_class( main_module, "BUTTON", "button_main_module" );
 528     ok( UnregisterClassA( "BUTTON", kernel32 ), "Unregister failed for kernel32 button\n" );
 529     ok( UnregisterClassA( "BUTTON", main_module ), "Unregister failed for main module button\n" );
 530     /* GetClassInfo sets instance to passed value for global classes */
 531     check_instance( "BUTTON", 0, 0, user32 );
 532     check_instance( "BUTTON", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 533     check_instance( "BUTTON", user32, 0, user32 );
 534     check_thread_instance( "BUTTON", 0, 0, user32 );
 535     check_thread_instance( "BUTTON", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 536     check_thread_instance( "BUTTON", user32, 0, user32 );
 537
 538     /* we can unregister system classes */
 539     ok( GetClassInfo( 0, "BUTTON", &wc ), "Button class not found with null instance\n" );
 540     ok( GetClassInfo( kernel32, "BUTTON", &wc ), "Button class not found with kernel32\n" );
 541     ok( UnregisterClass( "BUTTON", (HINSTANCE)0x12345678 ), "Failed to unregister button\n" );
 542     ok( !UnregisterClass( "BUTTON", (HINSTANCE)0x87654321 ), "Unregistered button a second time\n" );
 543     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST, "Wrong error code %d\n", GetLastError() );
 544     ok( !GetClassInfo( 0, "BUTTON", &wc ), "Button still exists\n" );
 545     ok( GetLastError() == ERROR_CLASS_DOES_NOT_EXIST ||
 546         GetLastError() == ERROR_INVALID_PARAMETER /* W2K3 */,
 547         "Wrong error code %d\n", GetLastError() );
 548
 549     /* we can change the instance of a system class */
 550     check_instance( "EDIT", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 551     check_thread_instance( "EDIT", (HINSTANCE)0xdeadbeef, (HINSTANCE)0xdeadbeef, user32 );
 552     hwnd = CreateWindowExA( 0, "EDIT", "test", 0, 0, 0, 0, 0, 0, 0, main_module, 0 );
 553     SetClassLongPtrA( hwnd, GCLP_HMODULE, 0xdeadbeef );
 554     check_instance( "EDIT", (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0xdeadbeef );
 555     check_thread_instance( "EDIT", (HINSTANCE)0x12345678, (HINSTANCE)0x12345678, (HINSTANCE)0xdeadbeef );
 556 }
 557
 558 static LRESULT WINAPI TestDlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 559 {
 560     return DefWindowProc(hWnd, uMsg, wParam, lParam);
 561 }
 562
 563 static BOOL RegisterTestDialog(HINSTANCE hInstance)
 564 {
 565     WNDCLASSEX wcx;
 566     ATOM atom = 0;
 567
 568     ZeroMemory(&wcx, sizeof(WNDCLASSEX));
 569     wcx.cbSize = sizeof(wcx);
 570     wcx.lpfnWndProc = TestDlgProc;
 571     wcx.cbClsExtra = 0;
 572     wcx.cbWndExtra = DLGWINDOWEXTRA;
 573     wcx.hInstance = hInstance;
 574     wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
 575     wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
 576     wcx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
 577     wcx.lpszClassName = "TestDialog";
 578     wcx.lpszMenuName =  "TestDialog";
 579     wcx.hIconSm = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(5),
 580         IMAGE_ICON,
 581         GetSystemMetrics(SM_CXSMICON),
 582         GetSystemMetrics(SM_CYSMICON),
 583         LR_DEFAULTCOLOR);
 584
 585     atom = RegisterClassEx(&wcx);
 586     ok(atom != 0, "RegisterClassEx returned 0\n");
 587
 588     return atom;
 589 }
 590
 591 /* test registering a dialog box created by using the CLASS directive in a
 592    resource file, then test creating the dialog using CreateDialogParam. */
 593 static void WINAPI CreateDialogParamTest(HINSTANCE hInstance)
 594 {
 595     HWND hWndMain;
 596
 597     if (RegisterTestDialog(hInstance))
 598     {
 599         hWndMain = CreateDialogParam(hInstance, "CLASS_TEST_DIALOG", NULL, 0, 0);
 600         ok(hWndMain != NULL, "CreateDialogParam returned NULL\n");
 601         ShowWindow(hWndMain, SW_SHOW);
 602         DestroyWindow(hWndMain);
 603     }
 604 }
 605
 606 START_TEST(class)
 607 {
 608     HANDLE hInstance = GetModuleHandleA( NULL );
 609
 610     if (!GetModuleHandleW(0))
 611     {
 612         trace("Class test is incompatible with Win9x implementation, skipping\n");
 613         return;
 614     }
 615
 616     ClassTest(hInstance,FALSE);
 617     ClassTest(hInstance,TRUE);
 618     CreateDialogParamTest(hInstance);
 619     test_styles();
 620     test_instances();
 621 }