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