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