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