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 <stdarg.h>
  23 #include <stdio.h>
  24
  25 #define _WIN32_WINNT 0x0500 /* For SPI_GETMOUSEHOVERWIDTH and more */
  26
  27 #include "wine/test.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winreg.h"
  32 #include "winuser.h"
  33
  34 #ifndef SPI_GETDESKWALLPAPER
  35 # define SPI_GETDESKWALLPAPER 0x0073
  36 #endif
  37
  38 static int strict;
  39
  40 #define eq(received, expected, label, type) \
  41         ok((received) == (expected), "%s: got " type " instead of " type "\n", (label),(received),(expected))
  42
  43
  44 #define SPI_SETBEEP_REGKEY                      "Control Panel\\Sound"
  45 #define SPI_SETBEEP_VALNAME                     "Beep"
  46 #define SPI_SETMOUSE_REGKEY                     "Control Panel\\Mouse"
  47 #define SPI_SETMOUSE_VALNAME1                   "MouseThreshold1"
  48 #define SPI_SETMOUSE_VALNAME2                   "MouseThreshold2"
  49 #define SPI_SETMOUSE_VALNAME3                   "MouseSpeed"
  50 #define SPI_SETBORDER_REGKEY                    "Control Panel\\Desktop\\WindowMetrics"
  51 #define SPI_SETBORDER_VALNAME                   "BorderWidth"
  52 #define SPI_SETKEYBOARDSPEED_REGKEY             "Control Panel\\Keyboard"
  53 #define SPI_SETKEYBOARDSPEED_VALNAME            "KeyboardSpeed"
  54 #define SPI_SETSCREENSAVETIMEOUT_REGKEY         "Control Panel\\Desktop"
  55 #define SPI_SETSCREENSAVETIMEOUT_VALNAME        "ScreenSaveTimeOut"
  56 #define SPI_SETSCREENSAVEACTIVE_REGKEY          "Control Panel\\Desktop"
  57 #define SPI_SETSCREENSAVEACTIVE_VALNAME         "ScreenSaveActive"
  58 #define SPI_SETGRIDGRANULARITY_REGKEY           "Control Panel\\Desktop"
  59 #define SPI_SETGRIDGRANULARITY_VALNAME          "GridGranularity"
  60 #define SPI_SETKEYBOARDDELAY_REGKEY             "Control Panel\\Keyboard"
  61 #define SPI_SETKEYBOARDDELAY_VALNAME            "KeyboardDelay"
  62 #define SPI_SETICONTITLEWRAP_REGKEY1            "Control Panel\\Desktop\\WindowMetrics"
  63 #define SPI_SETICONTITLEWRAP_REGKEY2            "Control Panel\\Desktop"
  64 #define SPI_SETICONTITLEWRAP_VALNAME            "IconTitleWrap"
  65 #define SPI_SETMENUDROPALIGNMENT_REGKEY1        "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows"
  66 #define SPI_SETMENUDROPALIGNMENT_REGKEY2        "Control Panel\\Desktop"
  67 #define SPI_SETMENUDROPALIGNMENT_VALNAME        "MenuDropAlignment"
  68 #define SPI_SETDOUBLECLKWIDTH_REGKEY1           "Control Panel\\Mouse"
  69 #define SPI_SETDOUBLECLKWIDTH_REGKEY2           "Control Panel\\Desktop"
  70 #define SPI_SETDOUBLECLKWIDTH_VALNAME           "DoubleClickWidth"
  71 #define SPI_SETDOUBLECLKHEIGHT_REGKEY1          "Control Panel\\Mouse"
  72 #define SPI_SETDOUBLECLKHEIGHT_REGKEY2          "Control Panel\\Desktop"
  73 #define SPI_SETDOUBLECLKHEIGHT_VALNAME          "DoubleClickHeight"
  74 #define SPI_SETDOUBLECLICKTIME_REGKEY           "Control Panel\\Mouse"
  75 #define SPI_SETDOUBLECLICKTIME_VALNAME          "DoubleClickSpeed"
  76 #define SPI_SETMOUSEBUTTONSWAP_REGKEY           "Control Panel\\Mouse"
  77 #define SPI_SETMOUSEBUTTONSWAP_VALNAME          "SwapMouseButtons"
  78 #define SPI_SETWORKAREA_REGKEY                  "Control Panel\\Desktop"
  79 #define SPI_SETWORKAREA_VALNAME                 "WINE_WorkArea"
  80 #define SPI_SETSHOWSOUNDS_REGKEY                "Control Panel\\Accessibility\\ShowSounds"
  81 #define SPI_SETSHOWSOUNDS_VALNAME               "On"
  82 #define SPI_SETKEYBOARDPREF_REGKEY              "Control Panel\\Accessibility\\Keyboard Preference"
  83 #define SPI_SETKEYBOARDPREF_VALNAME             "On"
  84 #define SPI_SETKEYBOARDPREF_REGKEY_LEGACY       "Control Panel\\Accessibility"
  85 #define SPI_SETKEYBOARDPREF_VALNAME_LEGACY      "Keyboard Preference"
  86 #define SPI_SETSCREENREADER_REGKEY              "Control Panel\\Accessibility\\Blind Access"
  87 #define SPI_SETSCREENREADER_VALNAME             "On"
  88 #define SPI_SETSCREENREADER_REGKEY_LEGACY       "Control Panel\\Accessibility"
  89 #define SPI_SETSCREENREADER_VALNAME_LEGACY      "Blind Access"
  90 #define SPI_SETLOWPOWERACTIVE_REGKEY            "Control Panel\\Desktop"
  91 #define SPI_SETLOWPOWERACTIVE_VALNAME           "LowPowerActive"
  92 #define SPI_SETPOWEROFFACTIVE_REGKEY            "Control Panel\\Desktop"
  93 #define SPI_SETPOWEROFFACTIVE_VALNAME           "PowerOffActive"
  94 #define SPI_SETDRAGFULLWINDOWS_REGKEY           "Control Panel\\Desktop"
  95 #define SPI_SETDRAGFULLWINDOWS_VALNAME          "DragFullWindows"
  96 #define SPI_SETMOUSEHOVERWIDTH_REGKEY           "Control Panel\\Mouse"
  97 #define SPI_SETMOUSEHOVERWIDTH_VALNAME          "MouseHoverWidth"
  98 #define SPI_SETMOUSEHOVERHEIGHT_REGKEY          "Control Panel\\Mouse"
  99 #define SPI_SETMOUSEHOVERHEIGHT_VALNAME         "MouseHoverHeight"
 100 #define SPI_SETMOUSEHOVERTIME_REGKEY            "Control Panel\\Mouse"
 101 #define SPI_SETMOUSEHOVERTIME_VALNAME           "MouseHoverTime"
 102 #define SPI_SETMOUSESCROLLLINES_REGKEY          "Control Panel\\Desktop"
 103 #define SPI_SETMOUSESCROLLLINES_VALNAME         "WheelScrollLines"
 104 #define SPI_SETMENUSHOWDELAY_REGKEY             "Control Panel\\Desktop"
 105 #define SPI_SETMENUSHOWDELAY_VALNAME            "MenuShowDelay"
 106 #define SPI_SETDESKWALLPAPER_REGKEY             "Control Panel\\Desktop"
 107 #define SPI_SETDESKWALLPAPER_VALNAME            "Wallpaper"
 108
 109 /* volatile registry branch under CURRENT_USER_REGKEY for temporary values storage */
 110 #define WINE_CURRENT_USER_REGKEY     "Wine"
 111
 112 static HWND ghTestWnd;
 113
 114 static DWORD WINAPI SysParamsThreadFunc( LPVOID lpParam );
 115 static LRESULT CALLBACK SysParamsTestWndProc( HWND hWnd, UINT msg, WPARAM wParam,
 116                                               LPARAM lParam );
 117 static int change_counter;
 118 static int change_last_param;
 119
 120 static LRESULT CALLBACK SysParamsTestWndProc( HWND hWnd, UINT msg, WPARAM wParam,
 121                                               LPARAM lParam )
 122 {
 123     switch (msg) {
 124
 125     case WM_SETTINGCHANGE:
 126         if (change_counter>0) {
 127             ok(0,"too many changes counter=%d last change=%d\n",
 128                change_counter,change_last_param);
 129         }
 130         change_counter++;
 131         change_last_param = wParam;
 132         break;
 133
 134     case WM_DESTROY:
 135         PostQuitMessage( 0 );
 136         break;
 137
 138     default:
 139         return( DefWindowProcA( hWnd, msg, wParam, lParam ) );
 140     }
 141
 142     return 0;
 143 }
 144
 145 /*
 146 Performs testing for system parameters messages
 147 params:
 148  - system parameter id
 149  - supposed value of the registry key
 150 */
 151 static void test_change_message( int action, int optional )
 152 {
 153     if (change_counter==0 && optional==1)
 154         return;
 155     ok( 1 == change_counter,
 156         "Missed a message: change_counter=%d\n", change_counter );
 157     change_counter = 0;
 158     ok( action == change_last_param,
 159         "Wrong action got %d expected %d\n", change_last_param, action );
 160     change_last_param = 0;
 161 }
 162
 163 static BOOL test_error_msg ( int rc, char *name )
 164 {
 165     DWORD last_error = GetLastError();
 166
 167     if (rc==0)
 168     {
 169         if (last_error==0xdeadbeef || last_error==ERROR_INVALID_SPI_VALUE)
 170         {
 171             trace("%s not supported on this platform. Skipping test\n", name);
 172         }
 173         else if (last_error==ERROR_ACCESS_DENIED)
 174         {
 175             trace("%s does not have privileges to run. Skipping test\n", name);
 176         }
 177         else
 178         {
 179             trace("%s failed for reason: %ld. Indicating test failure and skipping remainder of test\n",name,last_error);
 180             ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,last_error);
 181         }
 182         return FALSE;
 183     }
 184     else
 185     {
 186         ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,last_error);
 187         return TRUE;
 188     }
 189 }
 190
 191 /*
 192  * Tests the HKEY_CURRENT_USER subkey value.
 193  * The value should contain string value.
 194  *
 195  * Params:
 196  * lpsSubKey - subkey name
 197  * lpsRegName - registry entry name
 198  * lpsTestValue - value to test
 199  */
 200 static void _test_reg_key( LPCSTR subKey1, LPCSTR subKey2, LPCSTR valName1, LPCSTR valName2, LPCSTR testValue )
 201 {
 202     CHAR  value[MAX_PATH];
 203     DWORD valueLen;
 204     DWORD type;
 205     HKEY hKey;
 206     LONG rc;
 207     int found=0;
 208
 209     *value='\0';
 210     valueLen=sizeof(value);
 211     RegOpenKeyA( HKEY_CURRENT_USER, subKey1, &hKey );
 212     rc=RegQueryValueExA( hKey, valName1, NULL, &type, value, &valueLen );
 213     RegCloseKey( hKey );
 214     if (rc==ERROR_SUCCESS)
 215     {
 216         ok( !strcmp( testValue, value ),
 217             "Wrong value in registry: subKey=%s, valName=%s, testValue=%s, value=%s\n",
 218             subKey1, valName1, testValue, value );
 219         found++;
 220     }
 221     else if (strict)
 222     {
 223         ok(0,"Missing registry entry: subKey=%s, valName=%s\n",
 224            subKey1, valName1);
 225     }
 226     if (valName2)
 227     {
 228         *value='\0';
 229         valueLen=sizeof(value);
 230         RegOpenKeyA( HKEY_CURRENT_USER, subKey1, &hKey );
 231         rc=RegQueryValueExA( hKey, valName2, NULL, &type, value, &valueLen );
 232         RegCloseKey( hKey );
 233         if (rc==ERROR_SUCCESS)
 234         {
 235             ok( !strcmp( testValue, value ),
 236                 "Wrong value in registry: subKey=%s, valName=%s, testValue=%s, value=%s\n",
 237                 subKey1, valName2, testValue, value );
 238             found++;
 239         }
 240         else if (strict)
 241         {
 242             ok( 0,"Missing registry entry: subKey=%s, valName=%s\n",
 243                 subKey1, valName2 );
 244         }
 245     }
 246     if (subKey2 && !strict)
 247     {
 248         *value='\0';
 249         valueLen=sizeof(value);
 250         RegOpenKeyA( HKEY_CURRENT_USER, subKey2, &hKey );
 251         rc=RegQueryValueExA( hKey, valName1, NULL, &type, value, &valueLen );
 252         RegCloseKey( hKey );
 253         if (rc==ERROR_SUCCESS)
 254         {
 255             ok( !strcmp( testValue, value ),
 256                 "Wrong value in registry: subKey=%s, valName=%s, testValue=%s, value=%s\n",
 257                 subKey2, valName1, testValue, value );
 258             found++;
 259         }
 260         else if (strict)
 261         {
 262             ok( 0,"Missing registry entry: subKey=%s, valName=%s\n",
 263                 subKey2, valName1 );
 264         }
 265         if (valName2)
 266         {
 267             *value='\0';
 268             valueLen=sizeof(value);
 269             RegOpenKeyA( HKEY_CURRENT_USER, subKey2, &hKey );
 270             rc=RegQueryValueExA( hKey, valName2, NULL, &type, value, &valueLen );
 271             RegCloseKey( hKey );
 272             if (rc==ERROR_SUCCESS)
 273             {
 274                 ok( !strcmp( testValue, value ),
 275                     "Wrong value in registry: subKey=%s, valName=%s, testValue=%s, value=%s\n",
 276                     subKey2, valName2, testValue, value );
 277                 found++;
 278             }
 279             else if (strict)
 280             {
 281                 ok( 0,"Missing registry entry: subKey=%s, valName=%s\n",
 282                     subKey2, valName2 );
 283             }
 284          }
 285     }
 286     ok(found,"Missing registry values: %s or %s in keys: %s or %s\n",
 287        valName1, (valName2?valName2:"<n/a>"), subKey1, (subKey2?subKey2:"<n/a>") );
 288 }
 289
 290 #define test_reg_key( subKey, valName, testValue ) \
 291     _test_reg_key( subKey, NULL, valName, NULL, testValue )
 292 #define test_reg_key_ex( subKey1, subKey2, valName, testValue ) \
 293     _test_reg_key( subKey1, subKey2, valName, NULL, testValue )
 294 #define test_reg_key_ex2( subKey1, subKey2, valName1, valName2, testValue ) \
 295     _test_reg_key( subKey1, subKey2, valName1, valName2, testValue )
 296
 297 static void test_SPI_SETBEEP( void )                   /*      2 */
 298 {
 299     BOOL rc;
 300     BOOL old_b;
 301     BOOL b;
 302     BOOL curr_val;
 303
 304     trace("testing SPI_{GET,SET}BEEP\n");
 305     SetLastError(0xdeadbeef);
 306     rc=SystemParametersInfoA( SPI_GETBEEP, 0, &old_b, 0 );
 307     if (!test_error_msg(rc,"SPI_{GET,SET}BEEP"))
 308         return;
 309
 310     curr_val = TRUE;
 311     rc=SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 312     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 313     test_change_message( SPI_SETBEEP, 0 );
 314     test_reg_key( SPI_SETBEEP_REGKEY,
 315                   SPI_SETBEEP_VALNAME,
 316                   curr_val ? "Yes" : "No" );
 317     rc=SystemParametersInfoA( SPI_GETBEEP, 0, &b, 0 );
 318     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 319     eq( b, curr_val, "SPI_{GET,SET}BEEP", "%d" );
 320     rc=SystemParametersInfoW( SPI_GETBEEP, 0, &b, 0 );
 321     if (rc!=0 || GetLastError()!=ERROR_CALL_NOT_IMPLEMENTED)
 322     {
 323         ok(rc!=0,"SystemParametersInfoW: rc=%d err=%ld\n",rc,GetLastError());
 324         eq( b, curr_val, "SystemParametersInfoW", "%d" );
 325     }
 326
 327     /* is a message sent for the second change? */
 328     rc=SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 329     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 330     test_change_message( SPI_SETBEEP, 0 );
 331
 332     curr_val = FALSE;
 333     rc=SystemParametersInfoW( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 334     if (rc==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 335         rc=SystemParametersInfoA( SPI_SETBEEP, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 336     ok(rc!=0,"SystemParametersInfo: rc=%d err=%ld\n",rc,GetLastError());
 337     test_change_message( SPI_SETBEEP, 0 );
 338     test_reg_key( SPI_SETBEEP_REGKEY,
 339                   SPI_SETBEEP_VALNAME,
 340                   curr_val ? "Yes" : "No" );
 341     rc=SystemParametersInfoA( SPI_GETBEEP, 0, &b, 0 );
 342     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 343     eq( b, curr_val, "SPI_{GET,SET}BEEP", "%d" );
 344     rc=SystemParametersInfoW( SPI_GETBEEP, 0, &b, 0 );
 345     if (rc!=0 || GetLastError()!=ERROR_CALL_NOT_IMPLEMENTED)
 346     {
 347         ok(rc!=0,"SystemParametersInfoW: rc=%d err=%ld\n",rc,GetLastError());
 348         eq( b, curr_val, "SystemParametersInfoW", "%d" );
 349     }
 350     ok( MessageBeep( MB_OK ), "Return value of MessageBeep when sound is disabled\n" );
 351
 352     rc=SystemParametersInfoA( SPI_SETBEEP, old_b, 0, SPIF_UPDATEINIFILE );
 353     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 354 }
 355
 356 static const char *setmouse_valuenames[3] = {
 357     SPI_SETMOUSE_VALNAME1,
 358     SPI_SETMOUSE_VALNAME2,
 359     SPI_SETMOUSE_VALNAME3
 360 };
 361
 362 /*
 363  * Runs check for one setting of spi_setmouse.
 364  */
 365 static void run_spi_setmouse_test( int curr_val[], POINT *req_change, POINT *proj_change,
 366                                    int nchange )
 367 {
 368     BOOL rc;
 369     INT mi[3];
 370     static int aw_turn = 0;
 371     static BOOL w_implemented = 1;
 372
 373     char buf[20];
 374     int i;
 375
 376     aw_turn++;
 377     rc=0;
 378     if ((aw_turn % 2!=0) && (w_implemented))
 379     {
 380         /* call unicode on odd (non even) calls */
 381         SetLastError(0xdeadbeef);
 382         rc=SystemParametersInfoW( SPI_SETMOUSE, 0, curr_val, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 383         if (rc==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 384         {
 385             w_implemented = 0;
 386             trace("SystemParametersInfoW not supported on this platform\n");
 387         }
 388     }
 389
 390     if ((aw_turn % 2==0) || (!w_implemented))
 391     {
 392         /* call ascii version on even calls or if unicode is not available */
 393         rc=SystemParametersInfoA( SPI_SETMOUSE, 0, curr_val, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 394     }
 395
 396     ok(rc!=0,"SystemParametersInfo: rc=%d err=%ld\n",rc,GetLastError());
 397     test_change_message( SPI_SETMOUSE, 0 );
 398     for (i = 0; i < 3; i++)
 399     {
 400         sprintf( buf, "%d", curr_val[i] );
 401         test_reg_key( SPI_SETMOUSE_REGKEY, setmouse_valuenames[i], buf );
 402     }
 403
 404     rc=SystemParametersInfoA( SPI_GETMOUSE, 0, mi, 0 );
 405     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 406     for (i = 0; i < 3; i++)
 407     {
 408         ok(mi[i] == curr_val[i],
 409            "incorrect value for %d: %d != %d\n", i, mi[i], curr_val[i]);
 410     }
 411
 412     if (w_implemented)
 413     {
 414         rc=SystemParametersInfoW( SPI_GETMOUSE, 0, mi, 0 );
 415         ok(rc!=0,"SystemParametersInfoW: rc=%d err=%ld\n",rc,GetLastError());
 416         for (i = 0; i < 3; i++)
 417         {
 418             ok(mi[i] == curr_val[i],
 419                "incorrect value for %d: %d != %d\n", i, mi[i], curr_val[i]);
 420         }
 421     }
 422
 423 #if 0  /* FIXME: this always fails for me  - AJ */
 424     for (i = 0; i < nchange; i++)
 425     {
 426         POINT mv;
 427         mouse_event( MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 0, 0, 0, 0 );
 428         mouse_event( MOUSEEVENTF_MOVE, req_change[i].x, req_change[i].y, 0, 0 );
 429         GetCursorPos( &mv );
 430         ok( proj_change[i].x == mv.x, "Projected dx and real dx comparison. May fail under high load.\n" );
 431         ok( proj_change[i].y == mv.y, "Projected dy equals real dy. May fail under high load.\n" );
 432     }
 433 #endif
 434 }
 435
 436 static void test_SPI_SETMOUSE( void )                  /*      4 */
 437 {
 438     BOOL rc;
 439     INT old_mi[3];
 440
 441     /* win nt default values - 6, 10, 1 */
 442     INT curr_val[3] = {6, 10, 1};
 443
 444     /* requested and projected mouse movements */
 445     POINT req_change[] =   { {6, 6}, { 7, 6}, { 8, 6}, {10, 10}, {11, 10}, {100, 100} };
 446     POINT proj_change1[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
 447     POINT proj_change2[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {44, 20}, {400, 400} };
 448     POINT proj_change3[] = { {6, 6}, {14, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
 449     POINT proj_change4[] = { {6, 6}, { 7, 6}, { 8, 6}, {10, 10}, {11, 10}, {100, 100} };
 450     POINT proj_change5[] = { {6, 6}, { 7, 6}, {16, 6}, {20, 20}, {22, 20}, {200, 200} };
 451     POINT proj_change6[] = { {6, 6}, {28, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
 452     POINT proj_change7[] = { {6, 6}, {14, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
 453     POINT proj_change8[] = { {6, 6}, {28, 6}, {32, 6}, {40, 40}, {44, 40}, {400, 400} };
 454
 455     int nchange = sizeof( req_change ) / sizeof( POINT );
 456
 457     trace("testing SPI_{GET,SET}MOUSE\n");
 458     SetLastError(0xdeadbeef);
 459     rc=SystemParametersInfoA( SPI_GETMOUSE, 0, old_mi, 0 );
 460     if (!test_error_msg(rc,"SPI_{GET,SET}MOUSE"))
 461         return;
 462
 463     run_spi_setmouse_test( curr_val, req_change, proj_change1, nchange );
 464
 465     /* acceleration change */
 466     curr_val[2] = 2;
 467     run_spi_setmouse_test( curr_val, req_change, proj_change2, nchange );
 468
 469     /* acceleration change */
 470     curr_val[2] = 3;
 471     run_spi_setmouse_test( curr_val, req_change, proj_change3, nchange );
 472
 473     /* acceleration change */
 474     curr_val[2] = 0;
 475     run_spi_setmouse_test( curr_val, req_change, proj_change4, nchange );
 476
 477     /* threshold change */
 478     curr_val[2] = 1;
 479     curr_val[0] = 7;
 480     run_spi_setmouse_test( curr_val, req_change, proj_change5, nchange );
 481
 482     /* threshold change */
 483     curr_val[2] = 2;
 484     curr_val[0] = 6;
 485     curr_val[1] = 6;
 486     run_spi_setmouse_test( curr_val, req_change, proj_change6, nchange );
 487
 488     /* threshold change */
 489     curr_val[1] = 7;
 490     run_spi_setmouse_test( curr_val, req_change, proj_change7, nchange );
 491
 492     /* threshold change */
 493     curr_val[1] = 5;
 494     run_spi_setmouse_test( curr_val, req_change, proj_change8, nchange );
 495
 496     rc=SystemParametersInfoA( SPI_SETMOUSE, 0, old_mi, SPIF_UPDATEINIFILE );
 497     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 498 }
 499
 500 #if 0
 501 static void test_setborder(UINT curr_val)
 502 {
 503     BOOL rc;
 504     UINT border;
 505     INT frame;
 506     char buf[10];
 507
 508     rc=SystemParametersInfoA( SPI_SETBORDER, curr_val, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 509     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 510     test_change_message( SPI_SETBORDER, 1 );
 511     sprintf( buf, "%d", curr_val );
 512     test_reg_key( SPI_SETBORDER_REGKEY, SPI_SETBORDER_VALNAME, buf );
 513
 514     if (curr_val == 0)
 515         curr_val = 1;
 516     rc=SystemParametersInfoA( SPI_GETBORDER, 0, &border, 0 );
 517     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 518     eq( border, curr_val, "SPI_{GET,SET}BORDER", "%d");
 519
 520     frame = curr_val + GetSystemMetrics( SM_CXDLGFRAME );
 521     eq( frame, GetSystemMetrics( SM_CXFRAME ), "SM_CXFRAME", "%d" );
 522     eq( frame, GetSystemMetrics( SM_CYFRAME ), "SM_CYFRAME", "%d" );
 523     eq( frame, GetSystemMetrics( SM_CXSIZEFRAME ), "SM_CXSIZEFRAME", "%d" );
 524     eq( frame, GetSystemMetrics( SM_CYSIZEFRAME ), "SM_CYSIZEFRAME", "%d" );
 525 }
 526
 527 static void test_SPI_SETBORDER( void )                 /*      6 */
 528 {
 529     BOOL rc;
 530     UINT old_border;
 531
 532     /* These tests hang when XFree86 4.0 for Windows is running (tested on
 533      *  WinNT, SP2, Cygwin/XFree 4.1.0. Skip the test when XFree86 is
 534      * running.
 535      */
 536     if (FindWindowA( NULL, "Cygwin/XFree86" ))
 537         return;
 538
 539     trace("testing SPI_{GET,SET}BORDER\n");
 540     SetLastError(0xdeadbeef);
 541     rc=SystemParametersInfoA( SPI_GETBORDER, 0, &old_border, 0 );
 542     if (!test_error_msg(rc,"SPI_{GET,SET}BORDER"))
 543         return;
 544
 545     test_setborder(1);
 546     test_setborder(0);
 547     test_setborder(7);
 548     test_setborder(20);
 549
 550     /* This will restore sane values if the test hang previous run. */
 551     if ( old_border == 7 || old_border == 20 )
 552         old_border = -15;
 553
 554     rc=SystemParametersInfoA( SPI_SETBORDER, old_border, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 555     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 556 }
 557 #endif
 558
 559 static void test_SPI_SETKEYBOARDSPEED( void )          /*     10 */
 560 {
 561     BOOL rc;
 562     UINT old_speed;
 563     const UINT vals[]={0,20,31};
 564     unsigned int i;
 565
 566     trace("testing SPI_{GET,SET}KEYBOARDSPEED\n");
 567     SetLastError(0xdeadbeef);
 568     rc=SystemParametersInfoA( SPI_GETKEYBOARDSPEED, 0, &old_speed, 0 );
 569     if (!test_error_msg(rc,"SPI_{GET,SET}KEYBOARDSPEED"))
 570         return;
 571
 572     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 573     {
 574         UINT v;
 575         char buf[10];
 576
 577         rc=SystemParametersInfoA( SPI_SETKEYBOARDSPEED, vals[i], 0,
 578                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 579         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 580         test_change_message( SPI_SETKEYBOARDSPEED, 0 );
 581         sprintf( buf, "%d", vals[i] );
 582         test_reg_key( SPI_SETKEYBOARDSPEED_REGKEY, SPI_SETKEYBOARDSPEED_VALNAME, buf );
 583
 584         rc=SystemParametersInfoA( SPI_GETKEYBOARDSPEED, 0, &v, 0 );
 585         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 586         eq( v, vals[i], "SPI_{GET,SET}KEYBOARDSPEED", "%d" );
 587     }
 588
 589     rc=SystemParametersInfoA( SPI_SETKEYBOARDSPEED, old_speed, 0, SPIF_UPDATEINIFILE );
 590     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 591 }
 592
 593 static void test_SPI_ICONHORIZONTALSPACING( void )     /*     13 */
 594 {
 595     BOOL rc;
 596     INT old_spacing;
 597     INT spacing;
 598     INT curr_val;
 599
 600     trace("testing SPI_ICONHORIZONTALSPACING\n");
 601     SetLastError(0xdeadbeef);
 602     /* default value: 75 */
 603     rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &old_spacing, 0 );
 604     if (!test_error_msg(rc,"SPI_ICONHORIZONTALSPACING"))
 605         return;
 606
 607     /* do not increase the value as it would upset the user's icon layout */
 608     curr_val = (old_spacing > 32 ? old_spacing-1 : 32);
 609     rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, curr_val, 0,
 610                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 611     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 612     test_change_message( SPI_ICONHORIZONTALSPACING, 0 );
 613     /* The registry keys depend on the Windows version and the values too
 614      * => don't test them
 615      */
 616
 617     rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &spacing, 0 );
 618     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 619     eq( spacing, curr_val, "ICONHORIZONTALSPACING", "%d");
 620     eq( GetSystemMetrics( SM_CXICONSPACING ), curr_val, "SM_CXICONSPACING", "%d" );
 621
 622     curr_val = 10;
 623     rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, curr_val, 0,
 624                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 625     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 626     curr_val = 32;      /*min value*/
 627     test_change_message( SPI_ICONHORIZONTALSPACING, 0 );
 628
 629     rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, 0, &spacing, 0 );
 630     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 631     eq( spacing, curr_val, "ICONHORIZONTALSPACING", "%d" );
 632     eq( GetSystemMetrics( SM_CXICONSPACING ), curr_val, "SM_CXICONSPACING", "%d" );
 633
 634     rc=SystemParametersInfoA( SPI_ICONHORIZONTALSPACING, old_spacing, 0, SPIF_UPDATEINIFILE );
 635     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 636 }
 637
 638 static void test_SPI_SETSCREENSAVETIMEOUT( void )      /*     14 */
 639 {
 640     BOOL rc;
 641     UINT old_timeout;
 642     const UINT vals[]={0,32767};
 643     unsigned int i;
 644
 645     trace("testing SPI_{GET,SET}SCREENSAVETIMEOUT\n");
 646     SetLastError(0xdeadbeef);
 647     rc=SystemParametersInfoA( SPI_GETSCREENSAVETIMEOUT, 0, &old_timeout, 0 );
 648     if (!test_error_msg(rc,"SPI_{GET,SET}SCREENSAVETIMEOUT"))
 649         return;
 650
 651     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 652     {
 653         UINT v;
 654         char buf[10];
 655
 656         rc=SystemParametersInfoA( SPI_SETSCREENSAVETIMEOUT, vals[i], 0,
 657                                SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 658         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 659         test_change_message( SPI_SETSCREENSAVETIMEOUT, 0 );
 660         sprintf( buf, "%d", vals[i] );
 661         test_reg_key( SPI_SETSCREENSAVETIMEOUT_REGKEY,
 662                       SPI_SETSCREENSAVETIMEOUT_VALNAME, buf );
 663
 664         SystemParametersInfoA( SPI_GETSCREENSAVETIMEOUT, 0, &v, 0 );
 665         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 666         eq( v, vals[i], "SPI_{GET,SET}SCREENSAVETIMEOUT", "%d" );
 667     }
 668
 669     rc=SystemParametersInfoA( SPI_SETSCREENSAVETIMEOUT, old_timeout, 0,
 670                               SPIF_UPDATEINIFILE );
 671     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 672 }
 673
 674 static void test_SPI_SETSCREENSAVEACTIVE( void )       /*     17 */
 675 {
 676     BOOL rc;
 677     BOOL old_b;
 678     const UINT vals[]={TRUE,FALSE};
 679     unsigned int i;
 680
 681     trace("testing SPI_{GET,SET}SCREENSAVEACTIVE\n");
 682     SetLastError(0xdeadbeef);
 683     rc=SystemParametersInfoA( SPI_GETSCREENSAVEACTIVE, 0, &old_b, 0 );
 684     if (!test_error_msg(rc,"SPI_{GET,SET}SCREENSAVEACTIVE"))
 685         return;
 686
 687     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 688     {
 689         UINT v;
 690
 691         rc=SystemParametersInfoA( SPI_SETSCREENSAVEACTIVE, vals[i], 0,
 692                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 693         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 694         test_change_message( SPI_SETSCREENSAVEACTIVE, 0 );
 695         test_reg_key( SPI_SETSCREENSAVEACTIVE_REGKEY,
 696                       SPI_SETSCREENSAVEACTIVE_VALNAME,
 697                       vals[i] ? "1" : "0" );
 698
 699         rc=SystemParametersInfoA( SPI_GETSCREENSAVEACTIVE, 0, &v, 0 );
 700         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 701         eq( v, vals[i], "SPI_{GET,SET}SCREENSAVEACTIVE", "%d" );
 702     }
 703
 704     rc=SystemParametersInfoA( SPI_SETSCREENSAVEACTIVE, old_b, 0, SPIF_UPDATEINIFILE );
 705     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 706 }
 707
 708 static void test_SPI_SETGRIDGRANULARITY( void )        /*     19 */
 709 {
 710     /* ??? */;
 711 }
 712
 713 static void test_SPI_SETKEYBOARDDELAY( void )          /*     23 */
 714 {
 715     BOOL rc;
 716     UINT old_delay;
 717     const UINT vals[]={0,3};
 718     unsigned int i;
 719
 720     trace("testing SPI_{GET,SET}KEYBOARDDELAY\n");
 721     SetLastError(0xdeadbeef);
 722     rc=SystemParametersInfoA( SPI_GETKEYBOARDDELAY, 0, &old_delay, 0 );
 723     if (!test_error_msg(rc,"SPI_{GET,SET}KEYBOARDDELAY"))
 724         return;
 725
 726     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 727     {
 728         UINT delay;
 729         char buf[10];
 730
 731         rc=SystemParametersInfoA( SPI_SETKEYBOARDDELAY, vals[i], 0,
 732                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 733         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 734         test_change_message( SPI_SETKEYBOARDDELAY, 0 );
 735         sprintf( buf, "%d", vals[i] );
 736         test_reg_key( SPI_SETKEYBOARDDELAY_REGKEY,
 737                       SPI_SETKEYBOARDDELAY_VALNAME, buf );
 738
 739         rc=SystemParametersInfoA( SPI_GETKEYBOARDDELAY, 0, &delay, 0 );
 740         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 741         eq( delay, vals[i], "SPI_{GET,SET}KEYBOARDDELAY", "%d" );
 742     }
 743
 744     rc=SystemParametersInfoA( SPI_SETKEYBOARDDELAY, old_delay, 0, SPIF_UPDATEINIFILE );
 745     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 746 }
 747
 748 static void test_SPI_ICONVERTICALSPACING( void )       /*     24 */
 749 {
 750     BOOL rc;
 751     INT old_spacing;
 752     INT spacing;
 753     INT curr_val;
 754
 755     trace("testing SPI_ICONVERTICALSPACING\n");
 756     SetLastError(0xdeadbeef);
 757     /* default value: 75 */
 758     rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &old_spacing, 0 );
 759     if (!test_error_msg(rc,"SPI_ICONVERTICALSPACING"))
 760         return;
 761
 762     /* do not increase the value as it would upset the user's icon layout */
 763     curr_val = old_spacing-1;
 764     rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, curr_val, 0,
 765                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 766     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 767     test_change_message( SPI_ICONVERTICALSPACING, 0 );
 768     /* The registry keys depend on the Windows version and the values too
 769      * => don't test them
 770      */
 771
 772     rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &spacing, 0 );
 773     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 774     eq( spacing, curr_val, "ICONVERTICALSPACING", "%d" );
 775     eq( GetSystemMetrics( SM_CYICONSPACING ), curr_val, "SM_CYICONSPACING", "%d" );
 776
 777     curr_val = 10;
 778     rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, curr_val, 0,
 779                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 780     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 781     curr_val = 32;      /*min value*/
 782     test_change_message( SPI_ICONVERTICALSPACING, 0 );
 783
 784     rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, 0, &spacing, 0 );
 785     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 786     eq( spacing, curr_val, "ICONVERTICALSPACING", "%d" );
 787     eq( GetSystemMetrics( SM_CYICONSPACING ), curr_val, "SM_CYICONSPACING", "%d" );
 788
 789     rc=SystemParametersInfoA( SPI_ICONVERTICALSPACING, old_spacing, 0,
 790                               SPIF_UPDATEINIFILE );
 791     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 792 }
 793
 794 static void test_SPI_SETICONTITLEWRAP( void )          /*     26 */
 795 {
 796     BOOL rc;
 797     BOOL old_b;
 798     const UINT vals[]={TRUE,FALSE};
 799     unsigned int i;
 800
 801     /* These tests hang when XFree86 4.0 for Windows is running (tested on
 802      * WinNT, SP2, Cygwin/XFree 4.1.0. Skip the test when XFree86 is
 803      * running.
 804      */
 805     if (FindWindowA( NULL, "Cygwin/XFree86" ))
 806         return;
 807
 808     trace("testing SPI_{GET,SET}ICONTITLEWRAP\n");
 809     SetLastError(0xdeadbeef);
 810     rc=SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &old_b, 0 );
 811     if (!test_error_msg(rc,"SPI_{GET,SET}ICONTITLEWRAP"))
 812         return;
 813
 814     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 815     {
 816         UINT v;
 817
 818         rc=SystemParametersInfoA( SPI_SETICONTITLEWRAP, vals[i], 0,
 819                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 820         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 821         test_change_message( SPI_SETICONTITLEWRAP, 1 );
 822         test_reg_key_ex( SPI_SETICONTITLEWRAP_REGKEY1,
 823                          SPI_SETICONTITLEWRAP_REGKEY2,
 824                          SPI_SETICONTITLEWRAP_VALNAME,
 825                          vals[i] ? "1" : "0" );
 826
 827         rc=SystemParametersInfoA( SPI_GETICONTITLEWRAP, 0, &v, 0 );
 828         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 829         eq( v, vals[i], "SPI_{GET,SET}ICONTITLEWRAP", "%d" );
 830     }
 831
 832     rc=SystemParametersInfoA( SPI_SETICONTITLEWRAP, old_b, 0, SPIF_UPDATEINIFILE );
 833     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 834 }
 835
 836 static void test_SPI_SETMENUDROPALIGNMENT( void )      /*     28 */
 837 {
 838     BOOL rc;
 839     BOOL old_b;
 840     const UINT vals[]={TRUE,FALSE};
 841     unsigned int i;
 842
 843     trace("testing SPI_{GET,SET}MENUDROPALIGNMENT\n");
 844     SetLastError(0xdeadbeef);
 845     rc=SystemParametersInfoA( SPI_GETMENUDROPALIGNMENT, 0, &old_b, 0 );
 846     if (!test_error_msg(rc,"SPI_{GET,SET}MENUDROPALIGNMENT"))
 847         return;
 848
 849     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 850     {
 851         UINT v;
 852
 853         rc=SystemParametersInfoA( SPI_SETMENUDROPALIGNMENT, vals[i], 0,
 854                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 855         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 856         test_change_message( SPI_SETMENUDROPALIGNMENT, 0 );
 857         test_reg_key_ex( SPI_SETMENUDROPALIGNMENT_REGKEY1,
 858                          SPI_SETMENUDROPALIGNMENT_REGKEY2,
 859                          SPI_SETMENUDROPALIGNMENT_VALNAME,
 860                          vals[i] ? "1" : "0" );
 861
 862         rc=SystemParametersInfoA( SPI_GETMENUDROPALIGNMENT, 0, &v, 0 );
 863         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
 864         eq( v, vals[i], "SPI_{GET,SET}MENUDROPALIGNMENT", "%d" );
 865         eq( GetSystemMetrics( SM_MENUDROPALIGNMENT ), (int)vals[i],
 866             "SM_MENUDROPALIGNMENT", "%d" );
 867     }
 868
 869     rc=SystemParametersInfoA( SPI_SETMENUDROPALIGNMENT, old_b, 0,
 870                               SPIF_UPDATEINIFILE );
 871     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 872 }
 873
 874 static void test_SPI_SETDOUBLECLKWIDTH( void )         /*     29 */
 875 {
 876     BOOL rc;
 877     INT old_width;
 878     const UINT vals[]={0,10000};
 879     unsigned int i;
 880
 881     trace("testing SPI_{GET,SET}DOUBLECLKWIDTH\n");
 882     old_width = GetSystemMetrics( SM_CXDOUBLECLK );
 883
 884     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 885     {
 886         char buf[10];
 887
 888         SetLastError(0xdeadbeef);
 889         rc=SystemParametersInfoA( SPI_SETDOUBLECLKWIDTH, vals[i], 0,
 890                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 891         if (!test_error_msg(rc,"SPI_{GET,SET}DOUBLECLKWIDTH"))
 892             return;
 893
 894         test_change_message( SPI_SETDOUBLECLKWIDTH, 0 );
 895         sprintf( buf, "%d", vals[i] );
 896         test_reg_key_ex( SPI_SETDOUBLECLKWIDTH_REGKEY1,
 897                          SPI_SETDOUBLECLKWIDTH_REGKEY2,
 898                          SPI_SETDOUBLECLKWIDTH_VALNAME, buf );
 899         eq( GetSystemMetrics( SM_CXDOUBLECLK ), (int)vals[i],
 900             "SM_CXDOUBLECLK", "%d" );
 901     }
 902
 903     rc=SystemParametersInfoA( SPI_SETDOUBLECLKWIDTH, old_width, 0,
 904                               SPIF_UPDATEINIFILE );
 905     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 906 }
 907
 908 static void test_SPI_SETDOUBLECLKHEIGHT( void )        /*     30 */
 909 {
 910     BOOL rc;
 911     INT old_height;
 912     const UINT vals[]={0,10000};
 913     unsigned int i;
 914
 915     trace("testing SPI_{GET,SET}DOUBLECLKHEIGHT\n");
 916     old_height = GetSystemMetrics( SM_CYDOUBLECLK );
 917
 918     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
 919     {
 920         char buf[10];
 921
 922         SetLastError(0xdeadbeef);
 923         rc=SystemParametersInfoA( SPI_SETDOUBLECLKHEIGHT, vals[i], 0,
 924                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 925         if (!test_error_msg(rc,"SPI_{GET,SET}DOUBLECLKHEIGHT"))
 926             return;
 927
 928         test_change_message( SPI_SETDOUBLECLKHEIGHT, 0 );
 929         sprintf( buf, "%d", vals[i] );
 930         test_reg_key_ex( SPI_SETDOUBLECLKHEIGHT_REGKEY1,
 931                          SPI_SETDOUBLECLKHEIGHT_REGKEY2,
 932                          SPI_SETDOUBLECLKHEIGHT_VALNAME, buf );
 933         eq( GetSystemMetrics( SM_CYDOUBLECLK ), (int)vals[i],
 934             "SM_CYDOUBLECLK", "%d" );
 935     }
 936
 937     rc=SystemParametersInfoA( SPI_SETDOUBLECLKHEIGHT, old_height, 0,
 938                               SPIF_UPDATEINIFILE );
 939     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 940 }
 941
 942 static void test_SPI_SETDOUBLECLICKTIME( void )        /*     32 */
 943 {
 944     BOOL rc;
 945     UINT curr_val;
 946     UINT saved_val;
 947     UINT old_time;
 948     char buf[10];
 949
 950     trace("testing SPI_{GET,SET}DOUBLECLICKTIME\n");
 951     old_time = GetDoubleClickTime();
 952
 953     curr_val = 0;
 954     SetLastError(0xdeadbeef);
 955     rc=SystemParametersInfoA( SPI_SETDOUBLECLICKTIME, curr_val, 0,
 956                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 957     if (!test_error_msg(rc,"SPI_{GET,SET}DOUBLECLICKTIME"))
 958         return;
 959
 960     test_change_message( SPI_SETDOUBLECLICKTIME, 0 );
 961     sprintf( buf, "%d", curr_val );
 962     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 963                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 964     curr_val = 500; /* used value for 0 */
 965     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 966
 967     curr_val = 1000;
 968     rc=SystemParametersInfoA( SPI_SETDOUBLECLICKTIME, curr_val, 0,
 969                              SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
 970     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
 971     test_change_message( SPI_SETDOUBLECLICKTIME, 0 );
 972     sprintf( buf, "%d", curr_val );
 973     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 974                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 975     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 976
 977     saved_val = curr_val;
 978
 979     curr_val = 0;
 980     SetDoubleClickTime( curr_val );
 981     sprintf( buf, "%d", saved_val );
 982     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 983                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 984     curr_val = 500; /* used value for 0 */
 985     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 986
 987     curr_val = 1000;
 988     SetDoubleClickTime( curr_val );
 989     sprintf( buf, "%d", saved_val );
 990     test_reg_key( SPI_SETDOUBLECLICKTIME_REGKEY,
 991                   SPI_SETDOUBLECLICKTIME_VALNAME, buf );
 992     eq( GetDoubleClickTime(), curr_val, "GetDoubleClickTime", "%d" );
 993
 994     rc=SystemParametersInfoA(SPI_SETDOUBLECLICKTIME, old_time, 0, SPIF_UPDATEINIFILE);
 995     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
 996 }
 997
 998 static void test_SPI_SETMOUSEBUTTONSWAP( void )        /*     33 */
 999 {
1000     BOOL rc;
1001     BOOL old_b;
1002     const UINT vals[]={TRUE,FALSE};
1003     unsigned int i;
1004
1005     trace("testing SPI_{GET,SET}MOUSEBUTTONSWAP\n");
1006     old_b = GetSystemMetrics( SM_SWAPBUTTON );
1007
1008     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1009     {
1010         SetLastError(0xdeadbeef);
1011         rc=SystemParametersInfoA( SPI_SETMOUSEBUTTONSWAP, vals[i], 0,
1012                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1013         if (!test_error_msg(rc,"SPI_{GET,SET}MOUSEBUTTONSWAP"))
1014             return;
1015
1016         test_change_message( SPI_SETMOUSEBUTTONSWAP, 0 );
1017         test_reg_key( SPI_SETMOUSEBUTTONSWAP_REGKEY,
1018                       SPI_SETMOUSEBUTTONSWAP_VALNAME,
1019                       vals[i] ? "1" : "0" );
1020         eq( GetSystemMetrics( SM_SWAPBUTTON ), (int)vals[i],
1021             "SM_SWAPBUTTON", "%d" );
1022     }
1023
1024     rc=SystemParametersInfoA( SPI_SETMOUSEBUTTONSWAP, old_b, 0,
1025                               SPIF_UPDATEINIFILE );
1026     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1027 }
1028
1029 static void test_SPI_SETFASTTASKSWITCH( void )         /*     36 */
1030 {
1031     BOOL rc;
1032     BOOL v;
1033
1034     trace("testing SPI_GETFASTTASKSWITCH\n");
1035     SetLastError(0xdeadbeef);
1036     rc=SystemParametersInfoA( SPI_GETFASTTASKSWITCH, 0, &v, 0 );
1037     if (!test_error_msg(rc,"SPI_{GET,SET}FASTTASKSWITCH"))
1038         return;
1039
1040     /* there is not a single Windows platform on which SPI_GETFASTTASKSWITCH
1041      * works. That sure simplifies testing!
1042      */
1043 }
1044
1045 static void test_SPI_SETDRAGFULLWINDOWS( void )        /*     37 */
1046 {
1047     BOOL rc;
1048     BOOL old_b;
1049     const UINT vals[]={TRUE,FALSE};
1050     unsigned int i;
1051
1052     trace("testing SPI_{GET,SET}DRAGFULLWINDOWS\n");
1053     SetLastError(0xdeadbeef);
1054     rc=SystemParametersInfoA( SPI_GETDRAGFULLWINDOWS, 0, &old_b, 0 );
1055
1056     /* SPI_{GET,SET}DRAGFULLWINDOWS is not implemented on Win95 */
1057     if (!test_error_msg(rc,"SPI_{GET,SET}DRAGFULLWINDOWS"))
1058         return;
1059
1060     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1061     {
1062         UINT v;
1063
1064         rc=SystemParametersInfoA( SPI_SETDRAGFULLWINDOWS, vals[i], 0,
1065                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1066         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1067         test_change_message( SPI_SETDRAGFULLWINDOWS, 0 );
1068         test_reg_key( SPI_SETDRAGFULLWINDOWS_REGKEY,
1069                       SPI_SETDRAGFULLWINDOWS_VALNAME,
1070                       vals[i] ? "1" : "0" );
1071
1072         rc=SystemParametersInfoA( SPI_GETDRAGFULLWINDOWS, 0, &v, 0 );
1073         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1074         eq( v, vals[i], "SPI_{GET,SET}DRAGFULLWINDOWS", "%d" );
1075     }
1076
1077     rc=SystemParametersInfoA( SPI_SETDRAGFULLWINDOWS, old_b, 0, SPIF_UPDATEINIFILE );
1078     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1079 }
1080
1081 static void test_SPI_SETMINIMIZEDMETRICS( void )               /*     44 */
1082 {
1083     BOOL rc;
1084     MINIMIZEDMETRICS lpMm_orig;
1085     MINIMIZEDMETRICS lpMm_new;
1086     MINIMIZEDMETRICS lpMm_cur;
1087
1088     lpMm_orig.cbSize = sizeof(MINIMIZEDMETRICS);
1089     lpMm_new.cbSize = sizeof(MINIMIZEDMETRICS);
1090     lpMm_cur.cbSize = sizeof(MINIMIZEDMETRICS);
1091
1092     trace("testing SPI_{GET,SET}MINIMIZEDMETRICS\n");
1093     SetLastError(0xdeadbeef);
1094     rc=SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_orig, FALSE );
1095     if (!test_error_msg(rc,"SPI_{GET,SET}MINIMIZEDMETRICS"))
1096         return;
1097
1098     lpMm_cur.iWidth = 180;
1099     lpMm_cur.iHorzGap = 1;
1100     lpMm_cur.iVertGap = 1;
1101     lpMm_cur.iArrange = 5;
1102
1103     rc=SystemParametersInfoA( SPI_SETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_cur, FALSE );
1104     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1105
1106     rc=SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_new, FALSE );
1107     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1108
1109     eq( lpMm_new.iWidth,   lpMm_cur.iWidth,   "iWidth",   "%d" );
1110     eq( lpMm_new.iHorzGap, lpMm_cur.iHorzGap, "iHorzGap", "%d" );
1111     eq( lpMm_new.iVertGap, lpMm_cur.iVertGap, "iVertGap", "%d" );
1112     eq( lpMm_new.iArrange, lpMm_cur.iArrange, "iArrange", "%d" );
1113
1114     eq( GetSystemMetrics( SM_CXMINIMIZED ) - 6,
1115         lpMm_new.iWidth,   "iWidth",   "%d" );
1116     eq( GetSystemMetrics( SM_CXMINSPACING ) - GetSystemMetrics( SM_CXMINIMIZED ),
1117         lpMm_new.iHorzGap, "iHorzGap", "%d" );
1118     eq( GetSystemMetrics( SM_CYMINSPACING ) - GetSystemMetrics( SM_CYMINIMIZED ),
1119         lpMm_new.iVertGap, "iVertGap", "%d" );
1120     eq( GetSystemMetrics( SM_ARRANGE ),
1121         lpMm_new.iArrange, "iArrange", "%d" );
1122
1123     rc=SystemParametersInfoA( SPI_SETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_orig, FALSE );
1124     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1125
1126     rc=SystemParametersInfoA( SPI_GETMINIMIZEDMETRICS, sizeof(MINIMIZEDMETRICS), &lpMm_new, FALSE );
1127     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1128
1129     eq( lpMm_new.iWidth,   lpMm_orig.iWidth,   "iWidth",   "%d" );
1130     eq( lpMm_new.iHorzGap, lpMm_orig.iHorzGap, "iHorzGap", "%d" );
1131     eq( lpMm_new.iVertGap, lpMm_orig.iVertGap, "iVertGap", "%d" );
1132     eq( lpMm_new.iArrange, lpMm_orig.iArrange, "iArrange", "%d" );
1133 }
1134
1135 static void test_SPI_SETICONMETRICS( void )               /*     46 */
1136 {
1137     BOOL rc;
1138     ICONMETRICSA im_orig;
1139     ICONMETRICSA im_new;
1140     ICONMETRICSA im_cur;
1141
1142     im_orig.cbSize = sizeof(ICONMETRICSA);
1143     im_new.cbSize = sizeof(ICONMETRICSA);
1144     im_cur.cbSize = sizeof(ICONMETRICSA);
1145
1146     trace("testing SPI_{GET,SET}ICONMETRICS\n");
1147     SetLastError(0xdeadbeef);
1148     rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im_orig, FALSE );
1149     if (!test_error_msg(rc,"SPI_{GET,SET}ICONMETRICS"))
1150         return;
1151
1152     im_cur.iHorzSpacing = 65;
1153     im_cur.iVertSpacing = 65;
1154     im_cur.iTitleWrap = 0;
1155     im_cur.lfFont.lfHeight = 1;
1156     im_cur.lfFont.lfWidth = 1;
1157     im_cur.lfFont.lfEscapement = 1;
1158     im_cur.lfFont.lfWeight = 1;
1159     im_cur.lfFont.lfItalic = 1;
1160     im_cur.lfFont.lfStrikeOut = 1;
1161     im_cur.lfFont.lfUnderline = 1;
1162     im_cur.lfFont.lfCharSet = 1;
1163     im_cur.lfFont.lfOutPrecision = 1;
1164     im_cur.lfFont.lfClipPrecision = 1;
1165     im_cur.lfFont.lfPitchAndFamily = 1;
1166     im_cur.lfFont.lfQuality = 1;
1167
1168     rc=SystemParametersInfoA( SPI_SETICONMETRICS, sizeof(ICONMETRICSA), &im_cur, FALSE );
1169     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1170
1171     rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im_new, FALSE );
1172     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1173
1174     eq( im_new.iHorzSpacing, im_cur.iHorzSpacing, "iHorzSpacing", "%d" );
1175     eq( im_new.iVertSpacing, im_cur.iVertSpacing, "iVertSpacing", "%d" );
1176     eq( im_new.iTitleWrap,   im_cur.iTitleWrap,   "iTitleWrap",   "%d" );
1177
1178     eq( im_new.lfFont.lfHeight,         im_cur.lfFont.lfHeight,         "lfHeight",         "%ld" );
1179     eq( im_new.lfFont.lfWidth,          im_cur.lfFont.lfWidth,          "lfWidth",          "%ld" );
1180     eq( im_new.lfFont.lfEscapement,     im_cur.lfFont.lfEscapement,     "lfEscapement",     "%ld" );
1181     eq( im_new.lfFont.lfWeight,         im_cur.lfFont.lfWeight,         "lfWeight",         "%ld" );
1182     eq( im_new.lfFont.lfItalic,         im_cur.lfFont.lfItalic,         "lfItalic",         "%d" );
1183     eq( im_new.lfFont.lfStrikeOut,      im_cur.lfFont.lfStrikeOut,      "lfStrikeOut",      "%d" );
1184     eq( im_new.lfFont.lfUnderline,      im_cur.lfFont.lfUnderline,      "lfUnderline",      "%d" );
1185     eq( im_new.lfFont.lfCharSet,        im_cur.lfFont.lfCharSet,        "lfCharSet",        "%d" );
1186     eq( im_new.lfFont.lfOutPrecision,   im_cur.lfFont.lfOutPrecision,   "lfOutPrecision",   "%d" );
1187     eq( im_new.lfFont.lfClipPrecision,  im_cur.lfFont.lfClipPrecision,  "lfClipPrecision",  "%d" );
1188     eq( im_new.lfFont.lfPitchAndFamily, im_cur.lfFont.lfPitchAndFamily, "lfPitchAndFamily", "%d" );
1189     eq( im_new.lfFont.lfQuality,        im_cur.lfFont.lfQuality,        "lfQuality",        "%d" );
1190
1191     eq( GetSystemMetrics( SM_CXICONSPACING ),
1192         im_new.iHorzSpacing, "iHorzSpacing", "%d" );
1193     eq( GetSystemMetrics( SM_CYICONSPACING ),
1194         im_new.iVertSpacing, "iVertSpacing", "%d" );
1195
1196     rc=SystemParametersInfoA( SPI_SETICONMETRICS, sizeof(ICONMETRICSA), &im_orig, FALSE );
1197     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1198
1199     rc=SystemParametersInfoA( SPI_GETICONMETRICS, sizeof(ICONMETRICSA), &im_new, FALSE );
1200     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1201
1202     eq( im_new.iHorzSpacing, im_orig.iHorzSpacing, "iHorzSpacing", "%d" );
1203     eq( im_new.iVertSpacing, im_orig.iVertSpacing, "iVertSpacing", "%d" );
1204     eq( im_new.iTitleWrap,   im_orig.iTitleWrap,   "iTitleWrap",   "%d" );
1205 }
1206
1207 static void test_SPI_SETWORKAREA( void )               /*     47 */
1208 {
1209     BOOL rc;
1210     RECT old_area;
1211     RECT area;
1212     RECT curr_val;
1213
1214     trace("testing SPI_{GET,SET}WORKAREA\n");
1215     SetLastError(0xdeadbeef);
1216     rc=SystemParametersInfoA(SPI_GETWORKAREA, 0, &old_area, 0);
1217     if (!test_error_msg(rc,"SPI_{GET,SET}WORKAREA"))
1218         return;
1219
1220     /* Modify the work area only minimally as this causes the icons that
1221      * fall outside it to be moved around thus requiring the user to
1222      * reposition them manually one by one.
1223      * Changing the work area by just one pixel should make this occurrence
1224      * reasonably unlikely.
1225      */
1226     curr_val.left = old_area.left;
1227     curr_val.top = old_area.top;
1228     curr_val.right = old_area.right-1;
1229     curr_val.bottom = old_area.bottom-1;
1230     rc=SystemParametersInfoA( SPI_SETWORKAREA, 0, &curr_val,
1231                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1232     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1233     test_change_message( SPI_SETWORKAREA, 0 );
1234     rc=SystemParametersInfoA( SPI_GETWORKAREA, 0, &area, 0 );
1235     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1236     eq( area.left,   curr_val.left,   "left",   "%ld" );
1237     eq( area.top,    curr_val.top,    "top",    "%ld" );
1238     eq( area.right,  curr_val.right,  "right",  "%ld" );
1239     eq( area.bottom, curr_val.bottom, "bottom", "%ld" );
1240
1241     rc=SystemParametersInfoA( SPI_SETWORKAREA, 0, &old_area,
1242                               SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1243     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1244     test_change_message( SPI_SETWORKAREA, 0 );
1245     rc=SystemParametersInfoA( SPI_GETWORKAREA, 0, &area, 0 );
1246     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1247     eq( area.left,   old_area.left,   "left",   "%ld" );
1248     eq( area.top,    old_area.top,    "top",    "%ld" );
1249     eq( area.right,  old_area.right,  "right",  "%ld" );
1250     eq( area.bottom, old_area.bottom, "bottom", "%ld" );
1251 }
1252
1253 static void test_SPI_SETSHOWSOUNDS( void )             /*     57 */
1254 {
1255     BOOL rc;
1256     BOOL old_b;
1257     const UINT vals[]={TRUE,FALSE};
1258     unsigned int i;
1259
1260     trace("testing SPI_{GET,SET}SHOWSOUNDS\n");
1261     SetLastError(0xdeadbeef);
1262     rc=SystemParametersInfoA( SPI_GETSHOWSOUNDS, 0, &old_b, 0 );
1263     /* SPI_{GET,SET}SHOWSOUNDS is completely broken on Win9x */
1264     if (!test_error_msg(rc,"SPI_{GET,SET}SHOWSOUNDS"))
1265         return;
1266
1267     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1268     {
1269         UINT v;
1270
1271         rc=SystemParametersInfoA( SPI_SETSHOWSOUNDS, vals[i], 0,
1272                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1273         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1274         test_change_message( SPI_SETSHOWSOUNDS, 0 );
1275         test_reg_key( SPI_SETSHOWSOUNDS_REGKEY,
1276                       SPI_SETSHOWSOUNDS_VALNAME,
1277                       vals[i] ? "1" : "0" );
1278
1279         rc=SystemParametersInfoA( SPI_GETSHOWSOUNDS, 0, &v, 0 );
1280         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1281         eq( v, vals[i], "SPI_GETSHOWSOUNDS", "%d" );
1282         eq( GetSystemMetrics( SM_SHOWSOUNDS ), (int)vals[i],
1283             "SM_SHOWSOUNDS", "%d" );
1284     }
1285
1286     rc=SystemParametersInfoA( SPI_SETSHOWSOUNDS, old_b, 0, SPIF_UPDATEINIFILE );
1287     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1288 }
1289
1290 static void test_SPI_SETKEYBOARDPREF( void )           /*     69 */
1291 {
1292     BOOL rc;
1293     BOOL old_b;
1294     const UINT vals[]={TRUE,FALSE};
1295     unsigned int i;
1296
1297     trace("testing SPI_{GET,SET}KEYBOARDPREF\n");
1298     SetLastError(0xdeadbeef);
1299     rc=SystemParametersInfoA( SPI_GETKEYBOARDPREF, 0, &old_b, 0 );
1300     if (!test_error_msg(rc,"SPI_{GET,SET}KEYBOARDPREF"))
1301         return;
1302
1303     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1304     {
1305         BOOL v;
1306
1307         rc=SystemParametersInfoA( SPI_SETKEYBOARDPREF, vals[i], 0,
1308                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1309         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1310         test_change_message( SPI_SETKEYBOARDPREF, 0 );
1311         test_reg_key_ex2( SPI_SETKEYBOARDPREF_REGKEY, SPI_SETKEYBOARDPREF_REGKEY_LEGACY,
1312                           SPI_SETKEYBOARDPREF_VALNAME, SPI_SETKEYBOARDPREF_VALNAME_LEGACY,
1313                           vals[i] ? "1" : "0" );
1314
1315         rc=SystemParametersInfoA( SPI_GETKEYBOARDPREF, 0, &v, 0 );
1316         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1317         eq( v, vals[i], "SPI_GETKEYBOARDPREF", "%d" );
1318     }
1319
1320     rc=SystemParametersInfoA( SPI_SETKEYBOARDPREF, old_b, 0, SPIF_UPDATEINIFILE );
1321     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1322 }
1323
1324 static void test_SPI_SETSCREENREADER( void )           /*     71 */
1325 {
1326     BOOL rc;
1327     BOOL old_b;
1328     const UINT vals[]={TRUE,FALSE};
1329     unsigned int i;
1330
1331     trace("testing SPI_{GET,SET}SCREENREADER\n");
1332     SetLastError(0xdeadbeef);
1333     rc=SystemParametersInfoA( SPI_GETSCREENREADER, 0, &old_b, 0 );
1334     if (!test_error_msg(rc,"SPI_{GET,SET}SCREENREADER"))
1335         return;
1336
1337     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1338     {
1339         BOOL v;
1340
1341         rc=SystemParametersInfoA( SPI_SETSCREENREADER, vals[i], 0,
1342                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1343         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1344         test_change_message( SPI_SETSCREENREADER, 0 );
1345         test_reg_key_ex2( SPI_SETSCREENREADER_REGKEY, SPI_SETSCREENREADER_REGKEY_LEGACY,
1346                       SPI_SETSCREENREADER_VALNAME, SPI_SETSCREENREADER_VALNAME_LEGACY,
1347                       vals[i] ? "1" : "0" );
1348
1349         rc=SystemParametersInfoA( SPI_GETSCREENREADER, 0, &v, 0 );
1350         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1351         eq( v, vals[i], "SPI_GETSCREENREADER", "%d" );
1352     }
1353
1354     rc=SystemParametersInfoA( SPI_SETSCREENREADER, old_b, 0, SPIF_UPDATEINIFILE );
1355     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1356 }
1357
1358 static void test_SPI_SETLOWPOWERACTIVE( void )         /*     85 */
1359 {
1360     BOOL rc;
1361     BOOL old_b;
1362     const UINT vals[]={TRUE,FALSE};
1363     unsigned int i;
1364
1365     trace("testing SPI_{GET,SET}LOWPOWERACTIVE\n");
1366     SetLastError(0xdeadbeef);
1367     rc=SystemParametersInfoA( SPI_GETLOWPOWERACTIVE, 0, &old_b, 0 );
1368     if (!test_error_msg(rc,"SPI_{GET,SET}LOWPOWERACTIVE"))
1369         return;
1370
1371     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1372     {
1373         UINT v;
1374
1375         rc=SystemParametersInfoA( SPI_SETLOWPOWERACTIVE, vals[i], 0,
1376                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1377         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1378         test_change_message( SPI_SETLOWPOWERACTIVE, 0 );
1379         test_reg_key( SPI_SETLOWPOWERACTIVE_REGKEY,
1380                       SPI_SETLOWPOWERACTIVE_VALNAME,
1381                       vals[i] ? "1" : "0" );
1382
1383         rc=SystemParametersInfoA( SPI_GETLOWPOWERACTIVE, 0, &v, 0 );
1384         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1385         eq( v, vals[i], "SPI_GETLOWPOWERACTIVE", "%d" );
1386     }
1387
1388     rc=SystemParametersInfoA( SPI_SETLOWPOWERACTIVE, old_b, 0, SPIF_UPDATEINIFILE );
1389     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1390 }
1391
1392 static void test_SPI_SETPOWEROFFACTIVE( void )         /*     86 */
1393 {
1394     BOOL rc;
1395     BOOL old_b;
1396     const UINT vals[]={TRUE,FALSE};
1397     unsigned int i;
1398
1399     trace("testing SPI_{GET,SET}POWEROFFACTIVE\n");
1400     SetLastError(0xdeadbeef);
1401     rc=SystemParametersInfoA( SPI_GETPOWEROFFACTIVE, 0, &old_b, 0 );
1402     if (!test_error_msg(rc,"SPI_{GET,SET}POWEROFFACTIVE"))
1403         return;
1404
1405     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1406     {
1407         UINT v;
1408
1409         rc=SystemParametersInfoA( SPI_SETPOWEROFFACTIVE, vals[i], 0,
1410                                   SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1411         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1412         test_change_message( SPI_SETPOWEROFFACTIVE, 0 );
1413         test_reg_key( SPI_SETPOWEROFFACTIVE_REGKEY,
1414                       SPI_SETPOWEROFFACTIVE_VALNAME,
1415                       vals[i] ? "1" : "0" );
1416
1417         rc=SystemParametersInfoA( SPI_GETPOWEROFFACTIVE, 0, &v, 0 );
1418         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1419         eq( v, vals[i], "SPI_GETPOWEROFFACTIVE", "%d" );
1420     }
1421
1422     rc=SystemParametersInfoA( SPI_SETPOWEROFFACTIVE, old_b, 0, SPIF_UPDATEINIFILE );
1423     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1424 }
1425
1426 static void test_SPI_SETMOUSEHOVERWIDTH( void )      /*     99 */
1427 {
1428     BOOL rc;
1429     UINT old_width;
1430     const UINT vals[]={0,32767};
1431     unsigned int i;
1432
1433     trace("testing SPI_{GET,SET}MOUSEHOVERWIDTH\n");
1434     SetLastError(0xdeadbeef);
1435     rc=SystemParametersInfoA( SPI_GETMOUSEHOVERWIDTH, 0, &old_width, 0 );
1436     /* SPI_{GET,SET}MOUSEHOVERWIDTH does not seem to be supported on Win9x despite
1437     * what MSDN states (Verified on Win98SE)
1438     */
1439     if (!test_error_msg(rc,"SPI_{GET,SET}MOUSEHOVERWIDTH"))
1440         return;
1441
1442     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1443     {
1444         UINT v;
1445         char buf[10];
1446
1447         rc=SystemParametersInfoA( SPI_SETMOUSEHOVERWIDTH, vals[i], 0,
1448                                SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1449         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1450         test_change_message( SPI_SETMOUSEHOVERWIDTH, 0 );
1451         sprintf( buf, "%d", vals[i] );
1452         test_reg_key( SPI_SETMOUSEHOVERWIDTH_REGKEY,
1453                       SPI_SETMOUSEHOVERWIDTH_VALNAME, buf );
1454
1455         SystemParametersInfoA( SPI_GETMOUSEHOVERWIDTH, 0, &v, 0 );
1456         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1457         eq( v, vals[i], "SPI_{GET,SET}MOUSEHOVERWIDTH", "%d" );
1458     }
1459
1460     rc=SystemParametersInfoA( SPI_SETMOUSEHOVERWIDTH, old_width, 0,
1461                               SPIF_UPDATEINIFILE );
1462     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1463 }
1464
1465 static void test_SPI_SETMOUSEHOVERHEIGHT( void )      /*     101 */
1466 {
1467     BOOL rc;
1468     UINT old_height;
1469     const UINT vals[]={0,32767};
1470     unsigned int i;
1471
1472     trace("testing SPI_{GET,SET}MOUSEHOVERHEIGHT\n");
1473     SetLastError(0xdeadbeef);
1474     rc=SystemParametersInfoA( SPI_GETMOUSEHOVERHEIGHT, 0, &old_height, 0 );
1475     /* SPI_{GET,SET}MOUSEHOVERWIDTH does not seem to be supported on Win9x despite
1476      * what MSDN states (Verified on Win98SE)
1477      */
1478     if (!test_error_msg(rc,"SPI_{GET,SET}MOUSEHOVERHEIGHT"))
1479         return;
1480
1481     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1482     {
1483         UINT v;
1484         char buf[10];
1485
1486         rc=SystemParametersInfoA( SPI_SETMOUSEHOVERHEIGHT, vals[i], 0,
1487                                SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1488         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1489         test_change_message( SPI_SETMOUSEHOVERHEIGHT, 0 );
1490         sprintf( buf, "%d", vals[i] );
1491         test_reg_key( SPI_SETMOUSEHOVERHEIGHT_REGKEY,
1492                       SPI_SETMOUSEHOVERHEIGHT_VALNAME, buf );
1493
1494         SystemParametersInfoA( SPI_GETMOUSEHOVERHEIGHT, 0, &v, 0 );
1495         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1496         eq( v, vals[i], "SPI_{GET,SET}MOUSEHOVERHEIGHT", "%d" );
1497     }
1498
1499     rc=SystemParametersInfoA( SPI_SETMOUSEHOVERHEIGHT, old_height, 0,
1500                               SPIF_UPDATEINIFILE );
1501     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1502 }
1503
1504 static void test_SPI_SETMOUSEHOVERTIME( void )      /*     103 */
1505 {
1506     BOOL rc;
1507     UINT old_time;
1508
1509     /* Windows XP accepts 10 as the minimum hover time. Any value below will be
1510      * defaulted to a value of 10 automatically.
1511      */
1512     const UINT vals[]={10,32767};
1513     unsigned int i;
1514
1515     trace("testing SPI_{GET,SET}MOUSEHOVERTIME\n");
1516     SetLastError(0xdeadbeef);
1517     rc=SystemParametersInfoA( SPI_GETMOUSEHOVERTIME, 0, &old_time, 0 );
1518     /* SPI_{GET,SET}MOUSEHOVERWIDTH does not seem to be supported on Win9x despite
1519      * what MSDN states (Verified on Win98SE)
1520      */
1521     if (!test_error_msg(rc,"SPI_{GET,SET}MOUSEHOVERTIME"))
1522         return;
1523
1524     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1525     {
1526         UINT v;
1527         char buf[10];
1528
1529         rc=SystemParametersInfoA( SPI_SETMOUSEHOVERTIME, vals[i], 0,
1530                                SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1531         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1532         test_change_message( SPI_SETMOUSEHOVERTIME, 0 );
1533         sprintf( buf, "%d", vals[i] );
1534         test_reg_key( SPI_SETMOUSEHOVERTIME_REGKEY,
1535                       SPI_SETMOUSEHOVERTIME_VALNAME, buf );
1536
1537         SystemParametersInfoA( SPI_GETMOUSEHOVERTIME, 0, &v, 0 );
1538         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1539         eq( v, vals[i], "SPI_{GET,SET}MOUSEHOVERTIME", "%d" );
1540     }
1541
1542     rc=SystemParametersInfoA( SPI_SETMOUSEHOVERTIME, old_time, 0,
1543                               SPIF_UPDATEINIFILE );
1544     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1545 }
1546
1547 static void test_SPI_SETWHEELSCROLLLINES( void )      /*     105 */
1548 {
1549     BOOL rc;
1550     UINT old_lines;
1551     const UINT vals[]={0,32767};
1552     unsigned int i;
1553
1554     trace("testing SPI_{GET,SET}WHEELSCROLLLINES\n");
1555     SetLastError(0xdeadbeef);
1556     rc=SystemParametersInfoA( SPI_GETWHEELSCROLLLINES, 0, &old_lines, 0 );
1557
1558     /* SPI_{GET,SET}WHEELSCROLLLINES not supported on Windows 95 */
1559     if (!test_error_msg(rc,"SPI_{GET,SET}WHEELSCROLLLINES"))
1560         return;
1561
1562     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1563     {
1564         UINT v;
1565         char buf[10];
1566
1567         rc=SystemParametersInfoA( SPI_SETWHEELSCROLLLINES, vals[i], 0,
1568                                SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1569         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1570         test_change_message( SPI_SETWHEELSCROLLLINES, 0 );
1571         sprintf( buf, "%d", vals[i] );
1572         test_reg_key( SPI_SETMOUSESCROLLLINES_REGKEY,
1573                       SPI_SETMOUSESCROLLLINES_VALNAME, buf );
1574
1575         SystemParametersInfoA( SPI_GETWHEELSCROLLLINES, 0, &v, 0 );
1576         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1577         eq( v, vals[i], "SPI_{GET,SET}WHEELSCROLLLINES", "%d" );
1578     }
1579
1580     rc=SystemParametersInfoA( SPI_SETWHEELSCROLLLINES, old_lines, 0,
1581                               SPIF_UPDATEINIFILE );
1582     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1583 }
1584
1585 static void test_SPI_SETMENUSHOWDELAY( void )      /*     107 */
1586 {
1587     BOOL rc;
1588     UINT old_delay;
1589     const UINT vals[]={0,32767};
1590     unsigned int i;
1591
1592     trace("testing SPI_{GET,SET}MENUSHOWDELAY\n");
1593     SetLastError(0xdeadbeef);
1594     rc=SystemParametersInfoA( SPI_GETMENUSHOWDELAY, 0, &old_delay, 0 );
1595
1596     /* SPI_{GET,SET}MENUSHOWDELAY not supported on Windows 95 */
1597     if (!test_error_msg(rc,"SPI_{GET,SET}MENUSHOWDELAY"))
1598         return;
1599
1600     for (i=0;i<sizeof(vals)/sizeof(*vals);i++)
1601     {
1602         UINT v;
1603         char buf[10];
1604
1605         rc=SystemParametersInfoA( SPI_SETMENUSHOWDELAY, vals[i], 0,
1606                                SPIF_UPDATEINIFILE | SPIF_SENDCHANGE );
1607         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1608         test_change_message( SPI_SETMENUSHOWDELAY, 0 );
1609         sprintf( buf, "%d", vals[i] );
1610         test_reg_key( SPI_SETMENUSHOWDELAY_REGKEY,
1611                       SPI_SETMENUSHOWDELAY_VALNAME, buf );
1612
1613         SystemParametersInfoA( SPI_GETMENUSHOWDELAY, 0, &v, 0 );
1614         ok(rc!=0,"%d: rc=%d err=%ld\n",i,rc,GetLastError());
1615         eq( v, vals[i], "SPI_{GET,SET}MENUSHOWDELAY", "%d" );
1616     }
1617
1618     rc=SystemParametersInfoA( SPI_SETMENUSHOWDELAY, old_delay, 0,
1619                               SPIF_UPDATEINIFILE );
1620     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1621 }
1622
1623 static void test_SPI_SETWALLPAPER( void )              /*   115 */
1624 {
1625     BOOL rc;
1626     char oldval[260];
1627     char newval[260];
1628
1629     trace("testing SPI_{GET,SET}DESKWALLPAPER\n");
1630     SetLastError(0xdeadbeef);
1631     rc=SystemParametersInfoA(SPI_GETDESKWALLPAPER, 260, oldval, 0);
1632     /* SPI_{GET,SET}DESKWALLPAPER is completely broken on Win9x and
1633      * unimplemented on NT4
1634      */
1635     if (!test_error_msg(rc,"SPI_{GET,SET}DESKWALLPAPER"))
1636         return;
1637
1638     strcpy(newval, "");
1639     rc=SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, newval, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
1640     ok(rc!=0,"SystemParametersInfoA: rc=%d err=%ld\n",rc,GetLastError());
1641     test_change_message(SPI_SETDESKWALLPAPER, 0);
1642
1643     rc=SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, oldval, SPIF_UPDATEINIFILE);
1644     ok(rc!=0,"***warning*** failed to restore the original value: rc=%d err=%ld\n",rc,GetLastError());
1645
1646     test_reg_key(SPI_SETDESKWALLPAPER_REGKEY, SPI_SETDESKWALLPAPER_VALNAME, oldval);
1647 }
1648
1649 /*
1650  * Registry entries for the system parameters.
1651  * Names are created by 'SET' flags names.
1652  * We assume that corresponding 'GET' entries use the same registry keys.
1653  */
1654 static DWORD WINAPI SysParamsThreadFunc( LPVOID lpParam )
1655 {
1656     test_SPI_SETBEEP();                         /*      1 */
1657     test_SPI_SETMOUSE();                        /*      4 */
1658     /* Messes up systems settings on Win9x */
1659     /*test_SPI_SETBORDER();*/                   /*      6 */
1660     test_SPI_SETKEYBOARDSPEED();                /*     10 */
1661     test_SPI_ICONHORIZONTALSPACING();           /*     13 */
1662     test_SPI_SETSCREENSAVETIMEOUT();            /*     14 */
1663     test_SPI_SETSCREENSAVEACTIVE();             /*     17 */
1664     test_SPI_SETGRIDGRANULARITY();              /*     19 */
1665     test_SPI_SETKEYBOARDDELAY();                /*     23 */
1666     test_SPI_ICONVERTICALSPACING();             /*     24 */
1667     test_SPI_SETICONTITLEWRAP();                /*     26 */
1668     test_SPI_SETMENUDROPALIGNMENT();            /*     28 */
1669     test_SPI_SETDOUBLECLKWIDTH();               /*     29 */
1670     test_SPI_SETDOUBLECLKHEIGHT();              /*     30 */
1671     test_SPI_SETDOUBLECLICKTIME();              /*     32 */
1672     test_SPI_SETMOUSEBUTTONSWAP();              /*     33 */
1673     test_SPI_SETFASTTASKSWITCH();               /*     36 */
1674     test_SPI_SETDRAGFULLWINDOWS();              /*     37 */
1675     test_SPI_SETMINIMIZEDMETRICS();             /*     44 */
1676     test_SPI_SETICONMETRICS();                  /*     46 */
1677     test_SPI_SETWORKAREA();                     /*     47 */
1678     test_SPI_SETSHOWSOUNDS();                   /*     57 */
1679     test_SPI_SETKEYBOARDPREF();                 /*     69 */
1680     test_SPI_SETSCREENREADER();                 /*     71 */
1681     test_SPI_SETLOWPOWERACTIVE();               /*     85 */
1682     test_SPI_SETPOWEROFFACTIVE();               /*     86 */
1683     test_SPI_SETMOUSEHOVERWIDTH();              /*     99 */
1684     test_SPI_SETMOUSEHOVERHEIGHT();             /*    101 */
1685     test_SPI_SETMOUSEHOVERTIME();               /*    103 */
1686     test_SPI_SETWHEELSCROLLLINES();             /*    105 */
1687     test_SPI_SETMENUSHOWDELAY();                /*    107 */
1688     test_SPI_SETWALLPAPER();                    /*    115 */
1689     SendMessageA( ghTestWnd, WM_DESTROY, 0, 0 );
1690     return 0;
1691 }
1692
1693 START_TEST(sysparams)
1694 {
1695     int argc;
1696     char** argv;
1697     WNDCLASSA wc;
1698     MSG msg;
1699     HANDLE hThread;
1700     DWORD dwThreadId;
1701     HANDLE hInstance = GetModuleHandleA( NULL );
1702
1703     /* This test requires interactivity, if we don't have it, give up */
1704     if (!SystemParametersInfoA( SPI_SETBEEP, TRUE, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE ) &&
1705         GetLastError()==ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION) return;
1706
1707     argc = winetest_get_mainargs(&argv);
1708     strict=(argc >= 3 && strcmp(argv[2],"strict")==0);
1709     trace("strict=%d\n",strict);
1710
1711     change_counter = 0;
1712     change_last_param = 0;
1713
1714     wc.lpszClassName = "SysParamsTestClass";
1715     wc.lpfnWndProc = SysParamsTestWndProc;
1716     wc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;
1717     wc.hInstance = hInstance;
1718     wc.hIcon = LoadIconA( 0, (LPSTR)IDI_APPLICATION );
1719     wc.hCursor = LoadCursorA( 0, (LPSTR)IDC_ARROW );
1720     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1 );
1721     wc.lpszMenuName = 0;
1722     wc.cbClsExtra = 0;
1723     wc.cbWndExtra = 0;
1724     RegisterClassA( &wc );
1725
1726     ghTestWnd = CreateWindowA( "SysParamsTestClass", "Test System Parameters Application",
1727                                WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, hInstance, NULL );
1728
1729     hThread = CreateThread( NULL, 0, SysParamsThreadFunc, 0, 0, &dwThreadId );
1730     assert( hThread );
1731     CloseHandle( hThread );
1732
1733     while( GetMessageA( &msg, 0, 0, 0 )) {
1734         TranslateMessage( &msg );
1735         DispatchMessageA( &msg );
1736     }
1737 }