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