git.oblomov.eu Git - wine/blob - dlls/user/tests/sysparams.c

   1 /* Unit test suite for functions SystemParametersInfo and GetSystemMetrics.
   2  *
   3  * Copyright 2002 Andriy Palamarchuk
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include <assert.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23
  24 #include "wine/test.h"
  25 #include "winbase.h"
  26 #include "winreg.h"
  27 #include "winuser.h"
  28
  29 #ifndef IDI_APPLICATIONA
  30 #define IDI_APPLICATIONA IDI_APPLICATION
  31 #endif
  32 #ifndef IDC_ARROWA
  33 #define IDC_ARROWA IDC_ARROW
  34 #endif
  35
  36 #define eq(received, expected, label, type) \
  37         ok((received) == (expected), "%s: got " type " instead of " type, (label),(received),(expected))
  38
  39
  40 /* FIXME: should fix the tests to not require this */
  41 static int has_unicode(void) { return 1; }
  42
  43 #define SPI_SETBEEP_REGKEY           "Control Panel\\Sound"
  44 #define SPI_SETBEEP_VALNAME          "Beep"
  45 #define SPI_SETMOUSE_REGKEY             "Control Panel\\Mouse"
  46 #define SPI_SETMOUSE_VALNAME1           "MouseThreshold1"
  47 #define SPI_SETMOUSE_VALNAME2           "MouseThreshold2"
  48 #define SPI_SETMOUSE_VALNAME3           "MouseSpeed"
  49 #define SPI_SETBORDER_REGKEY         "Control Panel\\Desktop"
  50 #define SPI_SETBORDER_VALNAME        "BorderWidth"
  51 #define SPI_SETKEYBOARDSPEED_REGKEY             "Control Panel\\Keyboard"
  52 #define SPI_SETKEYBOARDSPEED_VALNAME            "KeyboardSpeed"
  53 #define SPI_ICONHORIZONTALSPACING_REGKEY        "Control Panel\\Desktop"
  54 #define SPI_ICONHORIZONTALSPACING_VALNAME       "IconSpacing"
  55 #define SPI_SETSCREENSAVETIMEOUT_REGKEY         "Control Panel\\Desktop"
  56 #define SPI_SETSCREENSAVETIMEOUT_VALNAME        "ScreenSaveTimeOut"
  57 #define SPI_SETSCREENSAVEACTIVE_REGKEY          "Control Panel\\Desktop"
  58 #define SPI_SETSCREENSAVEACTIVE_VALNAME         "ScreenSaveActive"
  59 #define SPI_SETGRIDGRANULARITY_REGKEY           "Control Panel\\Desktop"
  60 #define SPI_SETGRIDGRANULARITY_VALNAME          "GridGranularity"
  61 #define SPI_SETKEYBOARDDELAY_REGKEY             "Control Panel\\Keyboard"
  62 #define SPI_SETKEYBOARDDELAY_VALNAME            "KeyboardDelay"
  63 #define SPI_ICONVERTICALSPACING_REGKEY          "Control Panel\\Desktop"
  64 #define SPI_ICONVERTICALSPACING_VALNAME         "IconVerticalSpacing"
  65 #define SPI_SETICONTITLEWRAP_REGKEY             "Control Panel\\Desktop"
  66 #define SPI_SETICONTITLEWRAP_VALNAME            "IconTitleWrap"
  67 #define SPI_SETMENUDROPALIGNMENT_REGKEY         "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows"
  68 #define SPI_SETMENUDROPALIGNMENT_VALNAME        "MenuDropAlignment"
  69 #define SPI_SETDOUBLECLKWIDTH_REGKEY            "Control Panel\\Mouse"
  70 #define SPI_SETDOUBLECLKWIDTH_VALNAME           "DoubleClickWidth"
  71 #define SPI_SETDOUBLECLKHEIGHT_REGKEY           "Control Panel\\Mouse"
  72 #define SPI_SETDOUBLECLKHEIGHT_VALNAME          "DoubleClickHeight"
  73 #define SPI_SETDOUBLECLICKTIME_REGKEY           "Control Panel\\Mouse"
  74 #define SPI_SETDOUBLECLICKTIME_VALNAME          "DoubleClickSpeed"
  75 #define SPI_SETMOUSEBUTTONSWAP_REGKEY           "Control Panel\\Mouse"
  76 #define SPI_SETMOUSEBUTTONSWAP_VALNAME          "SwapMouseButtons"
  77 #define SPI_SETWORKAREA_REGKEY                  "Control Panel\\Desktop"
  78 #define SPI_SETWORKAREA_VALNAME                 "WINE_WorkArea"
  79 #define SPI_SETSHOWSOUNDS_REGKEY     "Control Panel\\Accessibility\\ShowSounds"
  80 #define SPI_SETSHOWSOUNDS_VALNAME    "On"
  81 #define SPI_SETFASTTASKSWITCH_REGKEY            "Control Panel\\Desktop"
  82 #define SPI_SETFASTTASKSWITCH_VALNAME           "CoolSwitch"
  83 #define SPI_SETDRAGFULLWINDOWS_REGKEY           "Control Panel\\Desktop"
  84 #define SPI_SETDRAGFULLWINDOWS_VALNAME          "DragFullWindows"
  85 /* FIXME - don't have access to Windows with this action (W95, NT5.0). Set real values */
  86 #define SPI_SETKEYBOARDPREF_REGKEY      "Control Panel\\Desktop"
  87 #define SPI_SETKEYBOARDPREF_VALNAME     "WINE_WorkArea"
  88 #define SPI_SETSCREENREADER_REGKEY      "Control Panel\\Desktop"
  89 #define SPI_SETSCREENREADER_VALNAME     "???"
  90
  91 /* volatile registry branch under CURRENT_USER_REGKEY for temporary values storage */
  92 #define WINE_CURRENT_USER_REGKEY     "Wine"
  93
  94 static HWND ghTestWnd;
  95
  96 static DWORD WINAPI SysParamsThreadFunc( LPVOID lpParam );
  97 static LRESULT CALLBACK SysParamsTestWndProc( HWND hWnd, UINT msg, WPARAM wParam,
  98                                               LPARAM lParam );
  99 static int change_counter;
 100 static int change_last_param;
 101 static char change_reg_section[MAX_PATH];
 102
 103 static LRESULT CALLBACK SysParamsTestWndProc( HWND hWnd, UINT msg, WPARAM wParam,
 104                                               LPARAM lParam )
 105 {
 106     switch(msg) {
 107
 108     case WM_SETTINGCHANGE:
 109         change_counter++;
 110         change_last_param = wParam;
 111         strncpy( change_reg_section, (LPSTR) lParam, sizeof( change_reg_section ));
 112         break;
 113
 114     case WM_DESTROY:
 115         PostQuitMessage( 0 );
 116         break;
 117
 118     default:
 119         return( DefWindowProcA( hWnd, msg, wParam, lParam ) );
 120     }
 121
 122     return 0;
 123 }
 124
 125 /*
 126 Performs testing for system parameters messages
 127 params:
 128  - system parameter id
 129  - supposed value of the registry key
 130 */
 131 static void test_change_message( UINT action, char *reg_section )
 132 {
 133     ok( 1 == change_counter,
 134         "Missed a message: change_counter=%d", change_counter );
 135     change_counter = 0;
 136     ok( action == change_last_param,
 137         "Wrong action %d != %d", action, change_last_param );
 138     change_last_param = 0;
 139     ok( !strcmp( reg_section, change_reg_section ),
 140         "Unexpected registry section %s != %s",
 141         reg_section, change_reg_section );
 142     strcpy( change_reg_section, "");
 143 }
 144
 145 /*
 146  * Tests the HKEY_CURRENT_USER subkey value.
 147  * The value should contain string value.
 148  *
 149  * Params:
 150  * lpsSubKey - subkey name
 151  * lpsRegName - registry entry name
 152  * lpsTestValue - value to test
 153  */
 154 static void _test_reg_key( LPSTR subKey, LPSTR valName, LPSTR testValue, char *file, int line )
 155 {
 156     CHAR  value[MAX_PATH] = "";
 157     DWORD valueLen = MAX_PATH;
 158     DWORD type;
 159     HKEY hKey;
 160
 161     RegOpenKeyA( HKEY_CURRENT_USER, subKey, &hKey );
 162     RegQueryValueExA( hKey, valName, NULL, &type, value, &valueLen );
 163     RegCloseKey( hKey );
 164     ok( !strcmp( testValue, value ),
 165         "Wrong value in registry: subKey=%s, valName=%s, testValue=%s, value=%s",
 166         subKey, valName, testValue, value );
 167 }
 168
 169 #define test_reg_key( subKey, valName, testValue ) \
 170     _test_reg_key( subKey, valName, testValue, __FILE__, __LINE__ )
 171
 172 static void test_SPI_SETBEEP( void )                   /*      2 */
 173 {
 174     BOOL old_b;
 175     BOOL b;
 176     BOOL curr_val;
 177
 178     trace("testing SPI_{GET,SET}BEEP\n");
 179     SystemParametersInfoA( SPI_GETBEEP, 0, &old_b, 0 );
 180
 181     curr_val = TRUE;
 182     SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 183     test_change_message( SPI_SETBEEP, "" );
 184     test_reg_key( SPI_SETBEEP_REGKEY,
 185                   SPI_SETBEEP_VALNAME,
 186                   curr_val ? "Yes" : "No" );
 187     SystemParametersInfoA( SPI_GETBEEP, 0, &b, 0 );
 188     eq( b, curr_val, "SPI_{GET,SET}BEEP", "%d" );
 189     if (has_unicode())
 190     {
 191         SystemParametersInfoW( SPI_GETBEEP, 0, &b, 0 );
 192         eq( b, curr_val, "SystemParametersInfoW", "%d" );
 193     }
 194
 195     /* is a message sent for the second change? */
 196     SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 197     test_change_message( SPI_SETBEEP, "" );
 198
 199     curr_val = FALSE;
 200     if (has_unicode())
 201         SystemParametersInfoW( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 202     else
 203         SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 204     test_change_message( SPI_SETBEEP, "" );
 205     test_reg_key( SPI_SETBEEP_REGKEY,
 206                   SPI_SETBEEP_VALNAME,
 207                   curr_val ? "Yes" : "No" );
 208     SystemParametersInfoA( SPI_GETBEEP, 0, &b, 0 );
 209     eq( b, curr_val, "SPI_{GET,SET}BEEP", "%d" );
 210     if (has_unicode())
 211     {
 212         SystemParametersInfoW( SPI_GETBEEP, 0, &b, 0 );
 213         eq( b, curr_val, "SystemParametersInfoW", "%d" );
 214     }
 215     ok( MessageBeep( MB_OK ), "Return value of MessageBeep when sound is disabled" );
 216
 217     SystemParametersInfoA( SPI_SETBEEP, old_b, 0, SPIF_UPDATEINIFILE );
 218 }
 219
 220 static char *setmouse_valuenames[3] = {
 221     SPI_SETMOUSE_VALNAME1,
 222     SPI_SETMOUSE_VALNAME2,
 223     SPI_SETMOUSE_VALNAME3
 224 };
 225
 226 /*
 227  * Runs check for one setting of spi_setmouse.
 228  */
 229 static void run_spi_setmouse_test( int curr_val[], POINT *req_change, POINT *proj_change,
 230                                    int nchange )
 231 {
 232     INT mi[3];
 233     static int aw_turn = 0;
 234
 235     char buf[20];
 236     int i;
 237
 238     aw_turn++;
 239     if (has_unicode() && (aw_turn % 2))        /* call unicode version each second call */
 240         SystemParametersInfoW( SPI_SETMOUSE, 0, curr_val, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 241     else
 242         SystemParametersInfoA( SPI_SETMOUSE, 0, curr_val, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 243     test_change_message( SPI_SETMOUSE, "" );
 244     for (i = 0; i < 3; i++)
 245     {
 246         sprintf( buf, "%d", curr_val[i] );
 247         test_reg_key( SPI_SETMOUSE_REGKEY, setmouse_valuenames[i], buf );
 248     }
 249
 250     SystemParametersInfoA( SPI_GETMOUSE, 0, mi, 0 );
 251     for (i = 0; i < 3; i++)
 252     {
 253         ok(mi[i] == curr_val[i],
 254            "incorrect value for %d: %d != %d", i, mi[i], curr_val[i]);
 255     }
 256
 257     if (has_unicode())
 258     {
 259         SystemParametersInfoW( SPI_GETMOUSE, 0, mi, 0 );
 260         for (i = 0; i < 3; i++)
 261         {
 262             ok(mi[i] == curr_val[i],
 263                "incorrect value for %d: %d != %d", i, mi[i], curr_val[i]);
 264         }
 265     }
 266
 267 #if 0  /* FIXME: this always fails for me  - AJ */
 268     for (i = 0; i < nchange; i++)
 269     {
 270         POINT mv;
 271         mouse_event( MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 0, 0, 0, 0 );
 272         mouse_event( MOUSEEVENTF_MOVE, req_change[i].x, req_change[i].y, 0, 0 );
 273         GetCursorPos( &mv );
 274         ok( proj_change[i].x == mv.x, "Projected dx and real dx comparison. May fail under high load." );
 275         ok( proj_change[i].y == mv.y, "Projected dy equals real dy. May fail under high load." );
 276     }
 277 #endif
 278 }
 279
 280 static void test_SPI_SETMOUSE( void )                  /*      4 */
 281 {
 282     INT old_mi[3];
 283
 284     /* win nt default values - 6, 10, 1*/
 285     INT curr_val[3] = {6, 10, 1};
 286
 287     /*requested and projected mouse movements */
 288     POINT req_change[] =   { {6, 6}, { 7, 6}, { 8, 6}, {10, 10}, {11, 10}, {100, 100} };
 289     POINT proj_change1[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
 290     POINT proj_change2[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {44, 20}, {400, 400} };
 291     POINT proj_change3[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
 292     POINT proj_change4[] = { {6, 6}, { 7, 6}, { 8, 6}, {10, 10}, {11, 10}, {100, 100} };
 293     POINT proj_change5[] = { {6, 6}, { 7, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
 294     POINT proj_change6[] = { {6, 6}, {28, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
 295     POINT proj_change7[] = { {6, 6}, {14, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
 296     POINT proj_change8[] = { {6, 6}, {28, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
 297
 298     int nchange = sizeof( req_change ) / sizeof( POINT );
 299
 300     trace("testing SPI_{GET,SET}MOUSE\n");
 301     SystemParametersInfoA( SPI_GETMOUSE, 0, old_mi, 0 );
 302
 303     run_spi_setmouse_test( curr_val, req_change, proj_change1, nchange );
 304
 305     /* acceleration change */
 306     curr_val[2] = 2;
 307     run_spi_setmouse_test( curr_val, req_change, proj_change2, nchange );
 308
 309     /* acceleration change */
 310     curr_val[2] = 3;
 311     run_spi_setmouse_test( curr_val, req_change, proj_change3, nchange );
 312
 313     /* acceleration change */
 314     curr_val[2] = 0;
 315     run_spi_setmouse_test( curr_val, req_change, proj_change4, nchange );
 316
 317     /* threshold change */
 318     curr_val[2] = 1;
 319     curr_val[0] = 7;
 320     run_spi_setmouse_test( curr_val, req_change, proj_change5, nchange );
 321
 322     /* threshold change */
 323     curr_val[2] = 2;
 324     curr_val[0] = 6;
 325     curr_val[1] = 6;
 326     run_spi_setmouse_test( curr_val, req_change, proj_change6, nchange );
 327
 328     /* threshold change */
 329     curr_val[1] = 7;
 330     run_spi_setmouse_test( curr_val, req_change, proj_change7, nchange );
 331
 332     /* threshold change */
 333     curr_val[1] = 5;
 334     run_spi_setmouse_test( curr_val, req_change, proj_change8, nchange );
 335
 336     SystemParametersInfoA( SPI_SETMOUSE, 0, old_mi, SPIF_UPDATEINIFILE );
 337 }
 338
 339 static void test_SPI_SETBORDER( void )                 /*      6 */
 340 {
 341     UINT old_border;
 342     UINT curr_val;
 343     UINT border;
 344     UINT frame;
 345     char buf[10];
 346
 347     /* tests one configuration of border settings */
 348 #define TEST_SETBORDER \
 349     SystemParametersInfoA( SPI_SETBORDER, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE ); \
 350     test_change_message( SPI_SETBORDER, "" ); \
 351     sprintf( buf, "%d", curr_val ); \
 352     test_reg_key( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME, buf ); \
 353     if (curr_val == 0) curr_val = 1; \
 354     SystemParametersInfoA( SPI_GETBORDER, 0, &border, 0 ); \
 355     eq( border, curr_val, "SPI_{GET,SET}BORDER", "%d"); \
 356     frame = curr_val + GetSystemMetrics( SM_CXDLGFRAME ); \
 357     eq( frame, GetSystemMetrics( SM_CXFRAME ), "SM_CXFRAME", "%d" ); \
 358     eq( frame, GetSystemMetrics( SM_CYFRAME ), "SM_CYFRAME", "%d" ); \
 359     eq( frame, GetSystemMetrics( SM_CXSIZEFRAME ), "SM_CXSIZEFRAME", "%d" ); \
 360     eq( frame, GetSystemMetrics( SM_CYSIZEFRAME ), "SM_CYSIZEFRAME", "%d" )
 361
 362     /* These tests hang when XFree86 4.0 for Windows is running (tested on
 363      *  WinNT, SP2, Cygwin/XFree 4.1.0. Skip the test when XFree86 is
 364      * running.
 365      */
 366     if (!FindWindowA( NULL, "Cygwin/XFree86" ))
 367     {
 368         trace("testing SPI_{GET,SET}BORDER\n");
 369         SystemParametersInfoA( SPI_GETBORDER, 0, &old_border, 0 );
 370
 371         curr_val = 1;
 372         TEST_SETBORDER;
 373
 374         curr_val = 0;
 375         TEST_SETBORDER;
 376
 377         curr_val = 7;
 378         TEST_SETBORDER;
 379
 380         curr_val = 20;
 381         TEST_SETBORDER;
 382
 383         /* This will restore sane values if the test hang previous run. */
 384         if ( old_border == 7 || old_border == 20 )
 385             old_border = 1;
 386
 387         SystemParametersInfoA( SPI_SETBORDER, old_border, 0, SPIF_UPDATEINIFILE );
 388     }
 389
 390 #undef TEST_SETBORDER
 391 }
 392
 393 static void test_SPI_SETKEYBOARDSPEED( void )          /*     10 */
 394 {
 395     UINT old_speed;
 396     UINT curr_val;
 397     UINT speed;
 398     char buf[10];
 399
 400     trace("testing SPI_{GET,SET}KEYBOARDSPEED\n");
 401     SystemParametersInfoA( SPI_GETKEYBOARDSPEED, 0, &old_speed, 0 );
 402
 403     curr_val = 0;
 404     SystemParametersInfoA( SPI_SETKEYBOARDSPEED, curr_val, 0,
 405                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 406     test_change_message( SPI_SETKEYBOARDSPEED, "" );
 407     sprintf( buf, "%d", curr_val );
 408     test_reg_key( SPI_SETKEYBOARDSPEED_REGKEY, SPI_SETKEYBOARDSPEED_VALNAME, buf );
 409
 410     SystemParametersInfoA( SPI_GETKEYBOARDSPEED, 0, &speed, 0 );
 411     eq( speed, curr_val, "SPI_{GET,SET}KEYBOARDSPEED", "%d" );
 412
 413     curr_val = 32;
 414     SystemParametersInfoA( SPI_SETKEYBOARDSPEED, curr_val, 0,
 415                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 416     curr_val = 31; /* max value */
 417     test_change_message( SPI_SETKEYBOARDSPEED, "" );
 418     sprintf( buf, "%d", curr_val );
 419     test_reg_key( SPI_SETKEYBOARDSPEED_REGKEY, SPI_SETKEYBOARDSPEED_VALNAME, buf );
 420
 421     SystemParametersInfoA( SPI_GETKEYBOARDSPEED, 0, &speed, 0 );
 422     eq( speed, curr_val, "SPI_{GET,SET}KEYBOARDSPEED", "%d");
 423
 424     SystemParametersInfoA( SPI_SETKEYBOARDSPEED, old_speed, 0, SPIF_UPDATEINIFILE );
 425 }
 426
 427 static void test_SPI_ICONHORIZONTALSPACING( void )     /*     13 */
 428 {
 429     UINT old_spacing;
 430     UINT spacing;
 431     UINT curr_val;
 432     char buf[10];
 433
 434     trace("testing SPI_ICONHORIZONTALSPACING\n");
 435     /* default value: 75 */
 436     SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &old_spacing, 0 );
 437
 438     curr_val = 101;
 439     SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, curr_val, 0,
 440                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 441     test_change_message( SPI_ICONHORIZONTALSPACING, "" );
 442     sprintf( buf, "%d", curr_val );
 443     test_reg_key( SPI_ICONHORIZONTALSPACING_REGKEY,
 444                   SPI_ICONHORIZONTALSPACING_VALNAME, buf );
 445
 446     SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &spacing, 0 );
 447     eq( spacing, curr_val, "ICONHORIZONTALSPACING", "%d");
 448     eq( GetSystemMetrics( SM_CXICONSPACING ), curr_val, "SM_CXICONSPACING", "%d" );
 449
 450     curr_val = 10;
 451     SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, curr_val, 0,
 452                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 453     curr_val = 32;      /*min value*/
 454     test_change_message( SPI_ICONHORIZONTALSPACING, "" );
 455     sprintf( buf, "%d", curr_val );
 456     test_reg_key( SPI_ICONHORIZONTALSPACING_REGKEY,
 457                   SPI_ICONHORIZONTALSPACING_VALNAME, buf );
 458
 459     SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &spacing, 0 );
 460     eq( spacing, curr_val, "ICONHORIZONTALSPACING", "%d" );
 461     eq( GetSystemMetrics( SM_CXICONSPACING ), curr_val, "SM_CXICONSPACING", "%d" );
 462
 463     SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, old_spacing, 0,
 464                           SPIF_UPDATEINIFILE );
 465 }
 466
 467 static void test_SPI_SETSCREENSAVETIMEOUT( void )      /*     14 */
 468 {
 469     UINT old_timeout;
 470     UINT timeout;
 471     UINT curr_val;
 472     char buf[10];
 473
 474     trace("testing SPI_{GET,SET}SCREENSAVETIMEOUT\n");
 475     SystemParametersInfoA( SPI_GETSCREENSAVETIMEOUT, 0, &old_timeout, 0 );
 476
 477     curr_val = 0;
 478     SystemParametersInfoA( SPI_SETSCREENSAVETIMEOUT, curr_val, 0,
 479                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 480     test_change_message( SPI_SETSCREENSAVETIMEOUT, "" );
 481     sprintf( buf, "%d", curr_val );
 482     test_reg_key( SPI_SETSCREENSAVETIMEOUT_REGKEY,
 483                   SPI_SETSCREENSAVETIMEOUT_VALNAME, buf );
 484
 485     SystemParametersInfoA( SPI_GETSCREENSAVETIMEOUT, 0, &timeout, 0 );
 486     eq( timeout, curr_val, "SPI_{GET,SET}SCREENSAVETIMEOUT", "%d" );
 487
 488     curr_val = 50000;
 489     SystemParametersInfoA( SPI_SETSCREENSAVETIMEOUT, curr_val, 0,
 490                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 491     test_change_message( SPI_SETSCREENSAVETIMEOUT, "" );
 492     sprintf( buf, "%d", curr_val );
 493     test_reg_key( SPI_SETSCREENSAVETIMEOUT_REGKEY,
 494                   SPI_SETSCREENSAVETIMEOUT_VALNAME, buf );
 495
 496     SystemParametersInfoA( SPI_GETSCREENSAVETIMEOUT, 0, &timeout, 0 );
 497     eq( timeout, curr_val, "SPI_{GET,SET}SCREENSAVETIMEOUT", "%d" );
 498
 499     SystemParametersInfoA( SPI_SETSCREENSAVETIMEOUT, old_timeout, 0,
 500                           SPIF_UPDATEINIFILE );
 501 }
 502
 503 static void test_SPI_SETSCREENSAVEACTIVE( void )       /*     17 */
 504 {
 505     BOOL old_b;
 506     BOOL b;
 507     BOOL curr_val;
 508
 509     trace("testing SPI_{GET,SET}SCREENSAVEACTIVE\n");
 510     SystemParametersInfoA( SPI_GETSCREENSAVEACTIVE, 0, &old_b, 0 );
 511
 512     curr_val = TRUE;
 513     SystemParametersInfoA( SPI_SETSCREENSAVEACTIVE, curr_val, 0,
 514                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 515     test_change_message( SPI_SETSCREENSAVEACTIVE, "" );
 516     test_reg_key( SPI_SETSCREENSAVEACTIVE_REGKEY,
 517                   SPI_SETSCREENSAVEACTIVE_VALNAME,
 518                   curr_val ? "1" : "0" );
 519
 520     SystemParametersInfoA( SPI_GETSCREENSAVEACTIVE, 0, &b, 0 );
 521     eq( b, curr_val, "SPI_{GET,SET}SCREENSAVEACTIVE", "%d" );
 522
 523     curr_val = FALSE;
 524     SystemParametersInfoA( SPI_SETSCREENSAVEACTIVE, curr_val, 0,
 525                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 526     test_change_message( SPI_SETSCREENSAVEACTIVE, "" );
 527     test_reg_key( SPI_SETSCREENSAVEACTIVE_REGKEY,
 528                   SPI_SETSCREENSAVEACTIVE_VALNAME,
 529                   curr_val ? "1" : "0" );
 530
 531     SystemParametersInfoA( SPI_GETSCREENSAVEACTIVE, 0, &b, 0 );
 532     eq( b, curr_val, "SPI_{GET,SET}SCREENSAVEACTIVE", "%d" );
 533
 534     SystemParametersInfoA( SPI_SETSCREENSAVEACTIVE, old_b, 0, SPIF_UPDATEINIFILE );
 535 }
 536
 537 static void test_SPI_SETGRIDGRANULARITY( void )        /*     19 */
 538 {
 539     /* ??? */;
 540 }
 541
 542 static void test_SPI_SETKEYBOARDDELAY( void )          /*     23 */
 543 {
 544     UINT old_delay;
 545     UINT delay;
 546     UINT curr_val;
 547     char buf[10];
 548
 549     trace("testing SPI_{GET,SET}KEYBOARDDELAY\n");
 550     SystemParametersInfoA( SPI_GETKEYBOARDDELAY, 0, &old_delay, 0 );
 551
 552     curr_val = 0;
 553     SystemParametersInfoA( SPI_SETKEYBOARDDELAY, curr_val, 0,
 554                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 555     test_change_message( SPI_SETKEYBOARDDELAY, "" );
 556     sprintf( buf, "%d", curr_val );
 557     test_reg_key( SPI_SETKEYBOARDDELAY_REGKEY,
 558                   SPI_SETKEYBOARDDELAY_VALNAME, buf );
 559
 560     SystemParametersInfoA( SPI_GETKEYBOARDDELAY, 0, &delay, 0 );
 561     eq( delay, curr_val, "SPI_{GET,SET}KEYBOARDDELAY", "%d" );
 562
 563     curr_val = 3;      /* max value */
 564     SystemParametersInfoA( SPI_SETKEYBOARDDELAY, curr_val, 0,
 565                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 566     test_change_message( SPI_SETKEYBOARDDELAY, "" );
 567     sprintf( buf, "%d", curr_val );
 568     test_reg_key( SPI_SETKEYBOARDDELAY_REGKEY,
 569                   SPI_SETKEYBOARDDELAY_VALNAME, buf );
 570
 571     SystemParametersInfoA( SPI_GETKEYBOARDDELAY, 0, &delay, 0 );
 572     eq( delay, curr_val, "SPI_{GET,SET}KEYBOARDDELAY", "%d" );
 573
 574     SystemParametersInfoA( SPI_SETKEYBOARDDELAY, old_delay, 0, SPIF_UPDATEINIFILE );
 575 }
 576
 577 static void test_SPI_ICONVERTICALSPACING( void )       /*     24 */
 578 {
 579     UINT old_spacing;
 580     UINT spacing;
 581     UINT curr_val;
 582     char buf[10];
 583
 584     trace("testing SPI_ICONVERTICALSPACING\n");
 585     /* default value: 75 */
 586     SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &old_spacing, 0 );
 587
 588     curr_val = 101;
 589     SystemParametersInfoA( SPI_ICONVERTICALSPACING, curr_val, 0,
 590                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 591     test_change_message( SPI_ICONVERTICALSPACING, "" );
 592     sprintf( buf, "%d", curr_val );
 593     test_reg_key( SPI_ICONVERTICALSPACING_REGKEY,
 594                   SPI_ICONVERTICALSPACING_VALNAME, buf );
 595
 596     SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &spacing, 0 );
 597     eq( spacing, curr_val, "ICONVERTICALSPACING", "%d" );
 598     eq( GetSystemMetrics( SM_CYICONSPACING ), curr_val, "SM_CYICONSPACING", "%d" );
 599
 600     curr_val = 10;
 601     SystemParametersInfoA( SPI_ICONVERTICALSPACING, curr_val, 0,
 602                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 603     curr_val = 32;      /*min value*/
 604     test_change_message( SPI_ICONVERTICALSPACING, "" );
 605     sprintf( buf, "%d", curr_val );
 606     test_reg_key( SPI_ICONVERTICALSPACING_REGKEY,
 607                   SPI_ICONVERTICALSPACING_VALNAME, buf );
 608
 609     SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &spacing, 0 );
 610     eq( spacing, curr_val, "ICONVERTICALSPACING", "%d" );
 611     eq( GetSystemMetrics( SM_CYICONSPACING ), curr_val, "SM_CYICONSPACING", "%d" );
 612
 613     SystemParametersInfoA( SPI_ICONVERTICALSPACING, old_spacing, 0,
 614                           SPIF_UPDATEINIFILE );
 615 }
 616
 617 static void test_SPI_SETICONTITLEWRAP( void )          /*     26 */
 618 {
 619     BOOL old_b;
 620     BOOL b;
 621     BOOL curr_val;
 622
 623     /* These tests hang when XFree86 4.0 for Windows is running (tested on
 624      * WinNT, SP2, Cygwin/XFree 4.1.0. Skip the test when XFree86 is
 625      * running.
 626      */
 627     if (!FindWindowA( NULL, "Cygwin/XFree86" ))
 628     {
 629         trace("testing SPI_{GET,SET}ICONTITLEWRAP\n");
 630         SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &old_b, 0 );
 631
 632         curr_val = TRUE;
 633         SystemParametersInfoA( SPI_SETICONTITLEWRAP, curr_val, 0,
 634                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 635         test_change_message( SPI_SETICONTITLEWRAP, "" );
 636         test_reg_key( SPI_SETICONTITLEWRAP_REGKEY,
 637                       SPI_SETICONTITLEWRAP_VALNAME,
 638                       curr_val ? "1" : "0" );
 639
 640         SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &b, 0 );
 641         eq( b, curr_val, "SPI_{GET,SET}ICONTITLEWRAP", "%d" );
 642
 643         curr_val = FALSE;
 644         SystemParametersInfoA( SPI_SETICONTITLEWRAP, curr_val, 0,
 645                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 646         test_change_message( SPI_SETICONTITLEWRAP, "" );
 647         test_reg_key( SPI_SETICONTITLEWRAP_REGKEY,
 648                       SPI_SETICONTITLEWRAP_VALNAME,
 649                       curr_val ? "1" : "0" );
 650
 651         SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &b, 0 );
 652         eq( b, curr_val, "SPI_{GET,SET}ICONTITLEWRAP", "%d" );
 653
 654         SystemParametersInfoA( SPI_SETICONTITLEWRAP, old_b, 0, SPIF_UPDATEINIFILE );
 655     }
 656 }
 657
 658 static void test_SPI_SETMENUDROPALIGNMENT( void )      /*     28 */
 659 {
 660     BOOL old_b;
 661     BOOL b;
 662     BOOL curr_val;
 663
 664     trace("testing SPI_{GET,SET}MENUDROPALIGNMENT\n");
 665     SystemParametersInfoA( SPI_GETMENUDROPALIGNMENT, 0, &old_b, 0 );
 666
 667     curr_val = TRUE;
 668     SystemParametersInfoA( SPI_SETMENUDROPALIGNMENT, curr_val, 0,
 669                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 670     test_change_message( SPI_SETMENUDROPALIGNMENT, "" );
 671     test_reg_key( SPI_SETMENUDROPALIGNMENT_REGKEY,
 672                   SPI_SETMENUDROPALIGNMENT_VALNAME,
 673                   curr_val ? "1" : "0" );
 674
 675     SystemParametersInfoA( SPI_GETMENUDROPALIGNMENT, 0, &b, 0 );
 676     eq( b, curr_val, "SPI_{GET,SET}MENUDROPALIGNMENT", "%d" );
 677     eq( GetSystemMetrics( SM_MENUDROPALIGNMENT ), curr_val, "SM_MENUDROPALIGNMENT", "%d" );
 678
 679     curr_val = FALSE;
 680     SystemParametersInfoA( SPI_SETMENUDROPALIGNMENT, curr_val, 0,
 681                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 682     test_change_message( SPI_SETMENUDROPALIGNMENT, "" );
 683     test_reg_key( SPI_SETMENUDROPALIGNMENT_REGKEY,
 684                   SPI_SETMENUDROPALIGNMENT_VALNAME,
 685                   curr_val ? "1" : "0" );
 686
 687     SystemParametersInfoA( SPI_GETMENUDROPALIGNMENT, 0, &b, 0 );
 688     eq( b, curr_val, "SPI_{GET,SET}MENUDROPALIGNMENT", "%d" );
 689     eq( GetSystemMetrics( SM_MENUDROPALIGNMENT ), curr_val, "SM_MENUDROPALIGNMENT", "%d" );
 690
 691     SystemParametersInfoA( SPI_SETMENUDROPALIGNMENT, old_b, 0,
 692                            SPIF_UPDATEINIFILE );
 693 }
 694
 695 static void test_SPI_SETDOUBLECLKWIDTH( void )         /*     29 */
 696 {
 697     UINT old_width;
 698     UINT curr_val;
 699     char buf[10];
 700
 701     trace("testing SPI_SETDOUBLECLKWIDTH\n");
 702     old_width = GetSystemMetrics( SM_CXDOUBLECLK );
 703
 704     curr_val = 0;
 705     SystemParametersInfoA( SPI_SETDOUBLECLKWIDTH, curr_val, 0,
 706                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 707     test_change_message( SPI_SETDOUBLECLKWIDTH, "" );
 708     sprintf( buf, "%d", curr_val );
 709     test_reg_key( SPI_SETDOUBLECLKWIDTH_REGKEY,
 710                   SPI_SETDOUBLECLKWIDTH_VALNAME, buf );
 711     eq( GetSystemMetrics( SM_CXDOUBLECLK ), curr_val, "SM_CXDOUBLECLK", "%d" );
 712
 713     curr_val = 10000;
 714     SystemParametersInfoA( SPI_SETDOUBLECLKWIDTH, curr_val, 0,
 715                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 716     test_change_message( SPI_SETDOUBLECLKWIDTH, "" );
 717     sprintf( buf, "%d", curr_val );
 718     test_reg_key( SPI_SETDOUBLECLKWIDTH_REGKEY,
 719                   SPI_SETDOUBLECLKWIDTH_VALNAME, buf );
 720     eq( GetSystemMetrics( SM_CXDOUBLECLK ), curr_val, "SM_CXDOUBLECLK", "%d" );
 721
 722     SystemParametersInfoA( SPI_SETDOUBLECLKWIDTH, old_width, 0,
 723                           SPIF_UPDATEINIFILE );
 724 }
 725
 726 static void test_SPI_SETDOUBLECLKHEIGHT( void )        /*     30 */
 727 {
 728     UINT old_height;
 729     UINT curr_val;
 730     char buf[10];
 731
 732     trace("testing SPI_SETDOUBLECLKHEIGHT\n");
 733     old_height = GetSystemMetrics( SM_CYDOUBLECLK );
 734
 735     curr_val = 0;
 736     SystemParametersInfoA( SPI_SETDOUBLECLKHEIGHT, curr_val, 0,
 737                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 738     test_change_message( SPI_SETDOUBLECLKHEIGHT, "" );
 739     sprintf( buf, "%d", curr_val );
 740     test_reg_key( SPI_SETDOUBLECLKHEIGHT_REGKEY,
 741                   SPI_SETDOUBLECLKHEIGHT_VALNAME, buf );
 742     eq( GetSystemMetrics( SM_CYDOUBLECLK ), curr_val, "SM_CYDOUBLECLK", "%d" );
 743
 744     curr_val = 10000;
 745     SystemParametersInfoA( SPI_SETDOUBLECLKHEIGHT, curr_val, 0,
 746                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 747     test_change_message( SPI_SETDOUBLECLKHEIGHT, "" );
 748     sprintf( buf, "%d", curr_val );
 749     test_reg_key( SPI_SETDOUBLECLKHEIGHT_REGKEY,
 750                   SPI_SETDOUBLECLKHEIGHT_VALNAME, buf );
 751     eq( GetSystemMetrics( SM_CYDOUBLECLK ), curr_val, "SM_CYDOUBLECLK", "%d" );
 752
 753     SystemParametersInfoA( SPI_SETDOUBLECLKHEIGHT, old_height, 0,
 754                           SPIF_UPDATEINIFILE );
 755 }
 756
 757 static void test_SPI_SETDOUBLECLICKTIME( void )        /*     32 */
 758 {
 759     UINT curr_val;
 760     UINT saved_val;
 761     UINT old_time;
 762     char buf[10];
 763
 764     trace("testing SPI_SETDOUBLECLICKTIME\n");
 765     old_time = GetDoubleClickTime();
 766
 767     curr_val = 0;
 768     SystemParametersInfoA( SPI_SETDOUBLECLICKTIME, curr_val, 0,
 769                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 770     test_change_message( SPI_SETDOUBLECLICKTIME, "" );
 771     sprintf( buf, "%d", curr_val );
 772     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 773                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 774     curr_val = 500; /* used value for 0 */
 775     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 776
 777     curr_val = 1000;
 778     SystemParametersInfoA( SPI_SETDOUBLECLICKTIME, curr_val, 0,
 779                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 780     test_change_message( SPI_SETDOUBLECLICKTIME, "" );
 781     sprintf( buf, "%d", curr_val );
 782     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 783                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 784     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 785
 786     saved_val = curr_val;
 787
 788     curr_val = 0;
 789     SetDoubleClickTime( curr_val );
 790     sprintf( buf, "%d", saved_val );
 791     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 792                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 793     curr_val = 500; /* used value for 0 */
 794     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 795
 796     curr_val = 1000;
 797     SetDoubleClickTime( curr_val );
 798     sprintf( buf, "%d", saved_val );
 799     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 800                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 801     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 802
 803     SystemParametersInfoA(SPI_SETDOUBLECLICKTIME, old_time, 0, SPIF_UPDATEINIFILE);
 804 }
 805
 806 static void test_SPI_SETMOUSEBUTTONSWAP( void )        /*     33 */
 807 {
 808     BOOL old_b;
 809     BOOL curr_val;
 810
 811     trace("testing SPI_SETMOUSEBUTTONSWAP\n");
 812     old_b = GetSystemMetrics( SM_SWAPBUTTON );
 813
 814     curr_val = TRUE;
 815     SystemParametersInfoA( SPI_SETMOUSEBUTTONSWAP, curr_val, 0,
 816                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 817     test_change_message( SPI_SETMOUSEBUTTONSWAP, "" );
 818     test_reg_key( SPI_SETMOUSEBUTTONSWAP_REGKEY,
 819                   SPI_SETMOUSEBUTTONSWAP_VALNAME,
 820                   curr_val ? "1" : "0" );
 821     eq( GetSystemMetrics( SM_SWAPBUTTON ), curr_val, "SM_SWAPBUTTON", "%d" );
 822
 823     curr_val = FALSE;
 824     SystemParametersInfoA( SPI_SETMOUSEBUTTONSWAP, curr_val, 0,
 825                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 826     test_change_message( SPI_SETMOUSEBUTTONSWAP, "" );
 827     test_reg_key( SPI_SETMOUSEBUTTONSWAP_REGKEY,
 828                   SPI_SETMOUSEBUTTONSWAP_VALNAME,
 829                   curr_val ? "1" : "0" );
 830     eq( GetSystemMetrics( SM_SWAPBUTTON ), curr_val, "SM_SWAPBUTTON", "%d" );
 831
 832     SystemParametersInfoA( SPI_SETMOUSEBUTTONSWAP, old_b, 0,
 833                            SPIF_UPDATEINIFILE );
 834 }
 835
 836 static void test_SPI_SETFASTTASKSWITCH( void )         /*     36 */
 837 {
 838     /* Temporarily commented out.
 839     BOOL old_b;
 840     BOOL b;
 841     BOOL res;
 842     BOOL curr_val;
 843
 844     SystemParametersInfoA( SPI_GETFASTTASKSWITCH, 0, &old_b, 0 );
 845
 846     curr_val = TRUE;
 847     res = SystemParametersInfoA( SPI_SETFASTTASKSWITCH, curr_val, 0,
 848                                  SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 849     ok( !res, "Must not set" );
 850
 851     SystemParametersInfoA( SPI_GETFASTTASKSWITCH, 0, &b, 0 );
 852     ok( b, "retrieved value is the same as set" );
 853
 854     curr_val = FALSE;
 855     res = SystemParametersInfoA( SPI_SETFASTTASKSWITCH, curr_val, 0,
 856                                  SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 857     ok( !res, "Must not set" );
 858
 859     SystemParametersInfoA( SPI_GETFASTTASKSWITCH, 0, &b, 0 );
 860
 861     ok( b, "retrieved value is the same as set" );
 862
 863     SystemParametersInfoA( SPI_SETFASTTASKSWITCH, old_b, 0,
 864                            SPIF_UPDATEINIFILE );
 865     */
 866 }
 867
 868 static void test_SPI_SETDRAGFULLWINDOWS( void )        /*     37 */
 869 {
 870     BOOL old_b;
 871     BOOL b;
 872     BOOL curr_val;
 873
 874     trace("testing SPI_{GET,SET}DRAGFULLWINDOWS\n");
 875     SystemParametersInfoA( SPI_GETDRAGFULLWINDOWS, 0, &old_b, 0 );
 876
 877     curr_val = TRUE;
 878     SystemParametersInfoA( SPI_SETDRAGFULLWINDOWS, curr_val, 0,
 879                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 880     test_change_message( SPI_SETDRAGFULLWINDOWS, "" );
 881     test_reg_key( SPI_SETDRAGFULLWINDOWS_REGKEY,
 882                   SPI_SETDRAGFULLWINDOWS_VALNAME,
 883                   curr_val ? "1" : "0" );
 884
 885     SystemParametersInfoA( SPI_GETDRAGFULLWINDOWS, 0, &b, 0 );
 886     eq( b, curr_val, "SPI_{GET,SET}DRAGFULLWINDOWS", "%d" );
 887
 888     curr_val = FALSE;
 889     SystemParametersInfoA( SPI_SETDRAGFULLWINDOWS, curr_val, 0,
 890                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 891     test_change_message( SPI_SETDRAGFULLWINDOWS, "" );
 892     test_reg_key( SPI_SETDRAGFULLWINDOWS_REGKEY,
 893                   SPI_SETDRAGFULLWINDOWS_VALNAME,
 894                   curr_val ? "1" : "0" );
 895
 896     SystemParametersInfoA( SPI_GETDRAGFULLWINDOWS, 0, &b, 0 );
 897     eq( b, curr_val, "SPI_{GET,SET}DRAGFULLWINDOWS", "%d" );
 898
 899     SystemParametersInfoA( SPI_SETDRAGFULLWINDOWS, old_b, 0, SPIF_UPDATEINIFILE );
 900 }
 901
 902 static void test_SPI_SETWORKAREA( void )               /*     47 */
 903 {
 904     /* default - 0,0,1152, 864 */
 905     RECT old_area;
 906     RECT area;
 907     RECT curr_val;
 908
 909     trace("testing SPI_{GET,SET}WORKAREA\n");
 910     SystemParametersInfoA(SPI_GETWORKAREA, 0, &old_area, 0);
 911
 912     curr_val.left = 1;
 913     curr_val.top = 1;
 914     curr_val.right = 800;
 915     curr_val.bottom = 600;
 916     SystemParametersInfoA( SPI_SETWORKAREA, 0, &curr_val,
 917                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 918     test_change_message( SPI_SETWORKAREA, "" );
 919     SystemParametersInfoA( SPI_GETWORKAREA, 0, &area, 0 );
 920     eq( area.left,   curr_val.left,   "left",   "%d" );
 921     eq( area.top,    curr_val.top,    "top",    "%d" );
 922     eq( area.right,  curr_val.right,  "right",  "%d" );
 923     eq( area.bottom, curr_val.bottom, "bottom", "%d" );
 924
 925     curr_val.left = 2;
 926     curr_val.top = 2;
 927     curr_val.right = 801;
 928     curr_val.bottom = 601;
 929     SystemParametersInfoA( SPI_SETWORKAREA, 0, &curr_val,
 930                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 931     test_change_message( SPI_SETWORKAREA, "" );
 932     SystemParametersInfoA( SPI_GETWORKAREA, 0, &area, 0 );
 933     eq( area.left,   curr_val.left,   "left",   "%d" );
 934     eq( area.top,    curr_val.top,    "top",    "%d" );
 935     eq( area.right,  curr_val.right,  "right",  "%d" );
 936     eq( area.bottom, curr_val.bottom, "bottom", "%d" );
 937
 938     SystemParametersInfoA(SPI_SETWORKAREA, 0, &old_area, SPIF_UPDATEINIFILE);
 939 }
 940
 941 static void test_SPI_SETSHOWSOUNDS( void )             /*     57 */
 942 {
 943     BOOL old_b;
 944     BOOL b;
 945     BOOL curr_val;
 946
 947     trace("testing SPI_{GET,SET}SHOWSOUNDS\n");
 948     SystemParametersInfoA( SPI_GETSHOWSOUNDS, 0, &old_b, 0 );
 949
 950     curr_val = TRUE;
 951     SystemParametersInfoA( SPI_SETSHOWSOUNDS, curr_val, 0,
 952                            SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 953     test_change_message( SPI_SETSHOWSOUNDS, "" );
 954     test_reg_key( SPI_SETSHOWSOUNDS_REGKEY,
 955                   SPI_SETSHOWSOUNDS_VALNAME,
 956                   curr_val ? "1" : "0" );
 957
 958     SystemParametersInfoA( SPI_GETSHOWSOUNDS, 0, &b, 0 );
 959     eq( b, curr_val, "SPI_GETSHOWSOUNDS", "%d" );
 960     eq( GetSystemMetrics( SM_SHOWSOUNDS ), curr_val, "SM_SHOWSOUNDS", "%d" );
 961
 962     curr_val = FALSE;
 963     SystemParametersInfoA( SPI_SETSHOWSOUNDS, curr_val, 0,
 964                           SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 965     test_change_message( SPI_SETSHOWSOUNDS, "" );
 966     test_reg_key( SPI_SETSHOWSOUNDS_REGKEY,
 967                   SPI_SETSHOWSOUNDS_VALNAME,
 968                   curr_val ? "1" : "0" );
 969
 970     SystemParametersInfoA( SPI_GETSHOWSOUNDS, 0, &b, 0 );
 971     eq( b, curr_val, "SPI_GETSHOWSOUNDS", "%d" );
 972     eq( GetSystemMetrics( SM_SHOWSOUNDS ), curr_val, "SM_SHOWSOUNDS", "%d" );
 973
 974     SystemParametersInfoA( SPI_SETSHOWSOUNDS, old_b, 0, SPIF_UPDATEINIFILE );
 975 }
 976
 977 static void test_SPI_SETKEYBOARDPREF( void )           /*     69 */
 978 {
 979     /* TODO!!! - don't have version of Windows which has this */
 980 }
 981
 982 static void test_SPI_SETSCREENREADER( void )           /*     71 */
 983 {
 984     /* TODO!!! - don't have version of Windows which has this */
 985 }
 986
 987 /*
 988  * Registry entries for the system parameters.
 989  * Names are created by 'SET' flags names.
 990  * We assume that corresponding 'GET' entries use the same registry keys.
 991  */
 992 static DWORD WINAPI SysParamsThreadFunc( LPVOID lpParam )
 993 {
 994     test_SPI_SETBEEP();                         /*      1 */
 995     test_SPI_SETMOUSE();                        /*      4 */
 996     test_SPI_SETBORDER();                       /*      6 */
 997     test_SPI_SETKEYBOARDSPEED();                /*     10 */
 998     test_SPI_ICONHORIZONTALSPACING();           /*     13 */
 999     test_SPI_SETSCREENSAVETIMEOUT();            /*     14 */
1000     test_SPI_SETSCREENSAVEACTIVE();             /*     17 */
1001     test_SPI_SETGRIDGRANULARITY();              /*     19 */
1002     test_SPI_SETKEYBOARDDELAY();                /*     23 */
1003     test_SPI_ICONVERTICALSPACING();             /*     24 */
1004     test_SPI_SETICONTITLEWRAP();                /*     26 */
1005     test_SPI_SETMENUDROPALIGNMENT();            /*     28 */
1006     test_SPI_SETDOUBLECLKWIDTH();               /*     29 */
1007     test_SPI_SETDOUBLECLKHEIGHT();              /*     30 */
1008     test_SPI_SETDOUBLECLICKTIME();              /*     32 */
1009     test_SPI_SETMOUSEBUTTONSWAP();              /*     33 */
1010     test_SPI_SETFASTTASKSWITCH();               /*     36 */
1011     test_SPI_SETDRAGFULLWINDOWS();              /*     37 */
1012     test_SPI_SETWORKAREA();                     /*     47 */
1013     test_SPI_SETSHOWSOUNDS();                   /*     57 */
1014     test_SPI_SETKEYBOARDPREF();                 /*     69 */
1015     test_SPI_SETSCREENREADER();                 /*     71 */
1016     SendMessageA( ghTestWnd, WM_DESTROY, 0, 0 );
1017     return 0;
1018 }
1019
1020 START_TEST(sysparams)
1021 {
1022     WNDCLASSA wc;
1023     MSG msg;
1024     HANDLE hThread;
1025     DWORD dwThreadId;
1026     HANDLE hInstance = GetModuleHandleA( NULL );
1027
1028     change_counter = 0;
1029     change_last_param = 0;
1030     strcpy( change_reg_section, "" );
1031
1032     wc.lpszClassName = "SysParamsTestClass";
1033     wc.lpfnWndProc = SysParamsTestWndProc;
1034     wc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;
1035     wc.hInstance = hInstance;
1036     wc.hIcon = LoadIconA( 0, IDI_APPLICATIONA );
1037     wc.hCursor = LoadCursorA( 0, IDC_ARROWA );
1038     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1 );
1039     wc.lpszMenuName = 0;
1040     wc.cbClsExtra = 0;
1041     wc.cbWndExtra = 0;
1042     RegisterClassA( &wc );
1043
1044     ghTestWnd = CreateWindowA( "SysParamsTestClass", "Test System Parameters Application",
1045                                WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, hInstance, NULL );
1046
1047     hThread = CreateThread( NULL, 0, SysParamsThreadFunc, 0, 0, &dwThreadId );
1048     assert( hThread );
1049     CloseHandle( hThread );
1050
1051     while( GetMessageA( &msg, 0, 0, 0 )) {
1052         TranslateMessage( &msg );
1053         DispatchMessageA( &msg );
1054     }
1055 }