programs/regtest/regtest.c

   1 /*
   2  * Registry testing program
   3  *
   4  * Copyright 1998 Matthew Becker
   5  *
   6  * The return codes were generated in an NT40 environment, using lcc-win32
   7  *
   8  * NOTES
   9  *    When compiling under lcc-win32, I get three (3) warning, but they all
  10  *    seem to be issues with lcc.
  11  *
  12  *    If creating a new testing sequence, please try to clean up any
  13  *    registry changes that are made.
  14  */
  15
  16 #include <stdio.h>
  17 #include <malloc.h>
  18 #include <windows.h>
  19 #include <winreg.h>
  20 #include <winerror.h>
  21 #include <winnt.h>
  22
  23 /* True this when security is implemented */
  24 #define CHECK_SAM FALSE
  25
  26 /*
  27  * NOTES: These individual routines are listed in alphabetical order.
  28  *
  29  * They are meant to test error conditions.  Success conditions are
  30  * tested in the sequences found at the end.
  31  */
  32
  33 /******************************************************************************
  34  * TestCloseKey
  35  */
  36 void TestCloseKey()
  37 {
  38     long lSts;
  39     fprintf(stderr, "Testing RegCloseKey...\n");
  40
  41     lSts = RegCloseKey((HKEY)2);
  42     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
  43
  44     lSts = RegCloseKey(HKEY_LOCAL_MACHINE);
  45     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
  46
  47     /* Check twice just for kicks */
  48     lSts = RegCloseKey(HKEY_LOCAL_MACHINE);
  49     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
  50 }
  51
  52 /******************************************************************************
  53  * TestConnectRegistry
  54  */
  55 void TestConnectRegistry()
  56 {
  57     long lSts;
  58     HKEY hkey;
  59     fprintf(stderr, "Testing RegConnectRegistry...\n");
  60
  61     lSts = RegConnectRegistry("",(HKEY)2,&hkey);
  62     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 1:%ld\n",lSts);
  63
  64     lSts = RegConnectRegistry("",HKEY_LOCAL_MACHINE,&hkey);
  65     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
  66
  67 #if TOO_SLOW
  68     lSts = RegConnectRegistry("\\\\regtest",HKEY_LOCAL_MACHINE,&hkey);
  69     if (lSts != ERROR_BAD_NETPATH) fprintf(stderr, " 3:%ld\n",lSts);
  70 #endif
  71 }
  72
  73 /******************************************************************************
  74  * TestCreateKey
  75  */
  76 void TestCreateKey()
  77 {
  78     long lSts;
  79     HKEY hkey;
  80
  81     fprintf(stderr, "Testing RegCreateKey...\n");
  82
  83     lSts = RegCreateKey((HKEY)2,"",&hkey);
  84     if (lSts != ERROR_BADKEY) fprintf(stderr, " 1:%ld\n",lSts);
  85
  86     lSts = RegCreateKey(HKEY_LOCAL_MACHINE,"",&hkey);
  87     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
  88     RegCloseKey(hkey);
  89
  90     lSts = RegCreateKey(HKEY_LOCAL_MACHINE,"\\asdf",&hkey);
  91     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 3:%ld\n",lSts);
  92
  93 #if 0
  94     lSts = RegCreateKey(HKEY_LOCAL_MACHINE,"asdf\\",&hkey);
  95     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 4:%ld\n",lSts);
  96 #endif
  97
  98     lSts = RegCreateKey(HKEY_LOCAL_MACHINE,"\\asdf\\",&hkey);
  99     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 5:%ld\n",lSts);
 100 }
 101
 102 /******************************************************************************
 103  * TestCreateKeyEx
 104  */
 105 void TestCreateKeyEx()
 106 {
 107     long lSts;
 108     HKEY hkey;
 109     DWORD dwDisp;
 110
 111     fprintf(stderr, "Testing RegCreateKeyEx...\n");
 112
 113     lSts = RegCreateKeyEx((HKEY)2,"",0,"",0,0,NULL,&hkey,&dwDisp);
 114     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 115
 116     lSts = RegCreateKeyEx(HKEY_LOCAL_MACHINE,"regtest",0,"",0,0,NULL,&hkey,
 117                           &dwDisp);
 118     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 119
 120     lSts = RegCreateKeyEx(HKEY_LOCAL_MACHINE,"regtest",0,"asdf",0,
 121                           KEY_ALL_ACCESS,NULL,&hkey,&dwDisp);
 122     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 3:%ld\n",lSts);
 123
 124     lSts = RegCreateKeyEx(HKEY_LOCAL_MACHINE,"regtest",0,"",0,
 125                           KEY_ALL_ACCESS,NULL,&hkey,&dwDisp);
 126     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 4:%ld\n",lSts);
 127
 128 }
 129
 130 /******************************************************************************
 131  * TestDeleteKey
 132  */
 133 void TestDeleteKey()
 134 {
 135     long lSts;
 136     fprintf(stderr, "Testing RegDeleteKey...\n");
 137
 138     lSts = RegDeleteKey((HKEY)2, "asdf");
 139     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 140
 141     lSts = RegDeleteKey(HKEY_CURRENT_USER, "asdf");
 142     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 2:%ld\n",lSts);
 143
 144 #if CHECK_SAM
 145     lSts = RegDeleteKey(HKEY_CURRENT_USER, "");
 146     if (lSts != ERROR_ACCESS_DENIED) fprintf(stderr, " 3:%ld\n",lSts);
 147 #endif
 148 }
 149
 150 /******************************************************************************
 151  * TestDeleteValue
 152  */
 153 void TestDeleteValue()
 154 {
 155     long lSts;
 156     fprintf(stderr, "Testing RegDeleteValue...\n");
 157
 158     lSts = RegDeleteValue((HKEY)2, "asdf");
 159     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 160
 161     lSts = RegDeleteValue(HKEY_CURRENT_USER, "");
 162     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 2:%ld\n",lSts);
 163
 164     lSts = RegDeleteValue(HKEY_CURRENT_USER, "asdf");
 165     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 3:%ld\n",lSts);
 166
 167     lSts = RegDeleteValue(HKEY_CURRENT_USER, "\\asdf");
 168     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 4:%ld\n",lSts);
 169 }
 170
 171 /******************************************************************************
 172  * TestEnumKey
 173  */
 174 void TestEnumKey()
 175 {
 176     long lSts;
 177     char *sVal;
 178     long lVal;
 179
 180     fprintf(stderr, "Testing RegEnumKey...\n");
 181     lVal = 1;
 182     sVal = (char *)malloc(lVal * sizeof(char));
 183
 184     lSts = RegEnumKey((HKEY)2,3,sVal,lVal);
 185     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 186
 187     lSts = RegEnumKey(HKEY_CURRENT_USER,-1,sVal,lVal);
 188     if (lSts != ERROR_NO_MORE_ITEMS) fprintf(stderr, " 2:%ld\n",lSts);
 189
 190     lSts = RegEnumKey(HKEY_CURRENT_USER,0,sVal,lVal);
 191     if (lSts != ERROR_MORE_DATA) fprintf(stderr, " 3:%ld\n",lSts);
 192 }
 193
 194 /******************************************************************************
 195  * TestEnumKeyEx
 196  */
 197 void TestEnumKeyEx()
 198 {
 199     long lSts;
 200     char *sVal;
 201     char *sClass;
 202     unsigned long lLen1;
 203     unsigned long lLen2;
 204     FILETIME ft;
 205
 206     fprintf(stderr, "Testing RegEnumKeyEx...\n");
 207     lLen1 = 1;
 208     sVal = (char *)malloc(lLen1 * sizeof(char));
 209     lLen2 = 1;
 210     sClass = (char *)malloc(lLen2 * sizeof(char));
 211
 212     lSts = RegEnumKeyEx((HKEY)2,0,sVal,&lLen1,0,sClass,&lLen2,&ft);
 213     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 214
 215     lSts = RegEnumKeyEx(HKEY_LOCAL_MACHINE,0,sVal,&lLen1,0,sClass,&lLen2,&ft);
 216     if (lSts != ERROR_MORE_DATA) fprintf(stderr, " 2:%ld\n",lSts);
 217
 218     lSts = RegEnumKeyEx(HKEY_LOCAL_MACHINE,0,sVal,&lLen1,0,sClass,&lLen2,&ft);
 219     if (lSts != ERROR_MORE_DATA) fprintf(stderr, " 3:%ld\n",lSts);
 220 }
 221
 222 /******************************************************************************
 223  * TestEnumValue
 224  */
 225 void TestEnumValue()
 226 {
 227     long lSts;
 228     char *sVal;
 229     unsigned long lVal;
 230     unsigned long lType;
 231     unsigned long lLen1;
 232     char *bVal;
 233
 234     fprintf(stderr, "Testing RegEnumValue...\n");
 235     lVal = 1;
 236     sVal = (char *)malloc(lVal * sizeof(char));
 237     lLen1 = 1;
 238     bVal = (char *)malloc(lLen1 * sizeof(char));
 239
 240     lSts = RegEnumValue((HKEY)2,-1,sVal,&lVal,0,&lType,NULL,&lLen1);
 241     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 242
 243     lSts = RegEnumValue(HKEY_LOCAL_MACHINE,-1,sVal,&lVal,0,&lType,NULL,&lLen1);
 244     if (lSts != ERROR_NO_MORE_ITEMS) fprintf(stderr, " 2:%ld\n",lSts);
 245
 246     lSts = RegEnumValue(HKEY_LOCAL_MACHINE,0,sVal,&lVal,0,&lType,NULL,&lLen1);
 247     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
 248
 249     lSts = RegEnumValue(HKEY_LOCAL_MACHINE,1,sVal,&lVal,0,&lType,bVal,&lLen1);
 250     if (lSts != ERROR_NO_MORE_ITEMS) fprintf(stderr, " 4:%ld\n",lSts);
 251 }
 252
 253 /******************************************************************************
 254  * TestFlushKey
 255  */
 256 void TestFlushKey()
 257 {
 258     long lSts;
 259     fprintf(stderr, "Testing RegFlushKey...\n");
 260
 261     lSts = RegFlushKey((HKEY)2);
 262     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 263
 264     lSts = RegFlushKey(HKEY_LOCAL_MACHINE);
 265     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
 266 }
 267
 268 /******************************************************************************
 269  * TestGetKeySecurity
 270  */
 271 void TestGetKeySecurity()
 272 {
 273     long lSts;
 274     SECURITY_INFORMATION si;
 275     SECURITY_DESCRIPTOR sd;
 276     unsigned long lLen;
 277
 278     fprintf(stderr, "Testing RegGetKeySecurity...\n");
 279     lLen = sizeof(sd);
 280
 281     lSts = RegGetKeySecurity((HKEY)2,si,&sd,&lLen);
 282     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 283
 284     lSts = RegGetKeySecurity(HKEY_LOCAL_MACHINE,si,&sd,&lLen);
 285     if (lSts != ERROR_INSUFFICIENT_BUFFER) fprintf(stderr, " 2:%ld\n",lSts);
 286
 287     si = GROUP_SECURITY_INFORMATION;
 288     lSts = RegGetKeySecurity(HKEY_LOCAL_MACHINE,si,&sd,&lLen);
 289     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
 290 }
 291
 292 /******************************************************************************
 293  * TestLoadKey
 294  */
 295 void TestLoadKey()
 296 {
 297     long lSts;
 298     fprintf(stderr, "Testing RegLoadKey...\n");
 299
 300     lSts = RegLoadKey((HKEY)2,"","");
 301     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 1:%ld\n",lSts);
 302
 303     lSts = RegLoadKey(HKEY_CURRENT_USER,"","");
 304     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 305
 306     lSts = RegLoadKey(HKEY_CURRENT_USER,"regtest","");
 307     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 3:%ld\n",lSts);
 308
 309     lSts = RegLoadKey(HKEY_CURRENT_USER,"\\regtest","");
 310     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 4:%ld\n",lSts);
 311
 312 #if CHECK_SAM
 313     lSts = RegLoadKey(HKEY_CURRENT_USER,"regtest","regtest.dat");
 314     if (lSts != ERROR_PRIVILEGE_NOT_HELD) fprintf(stderr, " 5:%ld\n",lSts);
 315
 316     lSts = RegLoadKey(HKEY_CURRENT_USER,"\\regtest","regtest.dat");
 317     if (lSts != ERROR_PRIVILEGE_NOT_HELD) fprintf(stderr, " 6:%ld\n",lSts);
 318 #endif
 319 }
 320
 321 /******************************************************************************
 322  * TestNotifyChangeKeyValue
 323  */
 324 void TestNotifyChangeKeyValue()
 325 {
 326     long lSts;
 327     HANDLE hEvent;
 328
 329     fprintf(stderr, "Testing RegNotifyChangeKeyValue...\n");
 330     hEvent = (HANDLE)0;
 331
 332     lSts = RegNotifyChangeKeyValue((HKEY)2, TRUE, REG_NOTIFY_CHANGE_NAME, 0, 0);
 333     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 334
 335     lSts = RegNotifyChangeKeyValue(HKEY_CURRENT_USER, TRUE, REG_NOTIFY_CHANGE_NAME, 0, 1);
 336     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 337
 338     hEvent = (HANDLE)HKEY_CURRENT_USER;
 339     lSts = RegNotifyChangeKeyValue(HKEY_CURRENT_USER, TRUE, REG_NOTIFY_CHANGE_NAME, hEvent, 1);
 340     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 3:%ld\n",lSts);
 341 }
 342
 343 /******************************************************************************
 344  * TestOpenKey
 345  */
 346 void TestOpenKey()
 347 {
 348     long lSts;
 349     HKEY hkey;
 350     fprintf(stderr, "Testing RegOpenKey...\n");
 351
 352     lSts = RegOpenKey((HKEY)72, "",&hkey);
 353     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 1:%ld\n",lSts);
 354     RegCloseKey(hkey);
 355
 356     lSts = RegOpenKey((HKEY)2, "regtest",&hkey);
 357     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 2:%ld\n",lSts);
 358
 359     lSts = RegOpenKey(HKEY_CURRENT_USER, "regtest",&hkey);
 360     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 3:%ld\n",lSts);
 361
 362     lSts = RegOpenKey(HKEY_CURRENT_USER, "\\regtest",&hkey);
 363     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 4:%ld\n",lSts);
 364 }
 365
 366 /******************************************************************************
 367  * TestOpenKeyEx
 368  */
 369 void TestOpenKeyEx()
 370 {
 371     long lSts;
 372     HKEY hkey;
 373     fprintf(stderr, "Testing RegOpenKeyEx...\n");
 374
 375     lSts = RegOpenKeyEx((HKEY)2,"",0,KEY_ALL_ACCESS,&hkey);
 376     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 377
 378     lSts = RegOpenKeyEx(HKEY_CURRENT_USER,"\\regtest",0,KEY_ALL_ACCESS,&hkey);
 379     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 2:%ld\n",lSts);
 380
 381     lSts = RegOpenKeyEx(HKEY_CURRENT_USER,"regtest",0,0,&hkey);
 382     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 3:%ld\n",lSts);
 383
 384     lSts = RegOpenKeyEx(HKEY_CURRENT_USER,"regtest\\",0,0,&hkey);
 385     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 3:%ld\n",lSts);
 386 }
 387
 388 /******************************************************************************
 389  * TestQueryInfoKey
 390  */
 391 void TestQueryInfoKey()
 392 {
 393     long lSts;
 394     char *sClass;
 395     unsigned long lClass;
 396     unsigned long lSubKeys;
 397     unsigned long lMaxSubLen;
 398     unsigned long lMaxClassLen;
 399     unsigned long lValues;
 400     unsigned long lMaxValNameLen;
 401     unsigned long lMaxValLen;
 402     unsigned long lSecDescLen;
 403     FILETIME ft;
 404     fprintf(stderr, "Testing RegQueryInfoKey...\n");
 405
 406     lClass = 1;
 407     sClass = (char *)malloc(lClass * sizeof(char));
 408
 409     lSts = RegQueryInfoKey((HKEY)2,sClass,&lClass,0,&lSubKeys,&lMaxSubLen,
 410                            &lMaxClassLen,&lValues,&lMaxValNameLen,&lMaxValLen,
 411                            &lSecDescLen, &ft);
 412     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 413
 414     lSts = RegQueryInfoKey(HKEY_CURRENT_USER,sClass,&lClass,0,&lSubKeys,
 415                            &lMaxSubLen,&lMaxClassLen,&lValues,&lMaxValNameLen,
 416                            &lMaxValLen,&lSecDescLen, &ft);
 417     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
 418 }
 419
 420 /******************************************************************************
 421  * TestQueryValue
 422  */
 423 void TestQueryValue()
 424 {
 425     long lSts;
 426     long lLen;
 427     char *sVal;
 428
 429     fprintf(stderr, "Testing RegQueryValue...\n");
 430     sVal = (char *)malloc(80 * sizeof(char));
 431     lLen = strlen(sVal);
 432
 433     lSts = RegQueryValue((HKEY)2,"",NULL,&lLen);
 434     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 435
 436     lSts = RegQueryValue(HKEY_CURRENT_USER,"",NULL,&lLen);
 437     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
 438
 439     lSts = RegQueryValue(HKEY_CURRENT_USER,"\\regtest",NULL,&lLen);
 440     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 3:%ld\n",lSts);
 441
 442     lSts = RegQueryValue(HKEY_CURRENT_USER,"",sVal,&lLen);
 443     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 4:%ld\n",lSts);
 444 }
 445
 446 /******************************************************************************
 447  * TestQueryValueEx
 448  */
 449 void TestQueryValueEx()
 450 {
 451     char *sVal;
 452     long lSts;
 453     unsigned long lType;
 454     unsigned long lLen;
 455
 456     fprintf(stderr, "Testing RegQueryValueEx...\n");
 457     lLen = 80;
 458     sVal = (char *)malloc(lLen * sizeof(char));
 459
 460     lSts = RegQueryValueEx((HKEY)2,"",0,&lType,sVal,&lLen);
 461     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 462
 463     lSts = RegQueryValueEx(HKEY_CURRENT_USER,"",(LPDWORD)1,&lType,sVal,&lLen);
 464     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 465
 466     lSts = RegQueryValueEx(HKEY_LOCAL_MACHINE,"",0,&lType,sVal,&lLen);
 467     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
 468 }
 469
 470 /******************************************************************************
 471  * TestReplaceKey
 472  */
 473 void TestReplaceKey()
 474 {
 475     long lSts;
 476
 477     fprintf(stderr, "Testing RegReplaceKey...\n");
 478
 479     lSts = RegReplaceKey((HKEY)2,"","","");
 480     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 481
 482 #if CHECK_SAM
 483     lSts = RegReplaceKey(HKEY_LOCAL_MACHINE,"","","");
 484     if (lSts != ERROR_ACCESS_DENIED) fprintf(stderr, " 2:%ld\n",lSts);
 485
 486     lSts = RegReplaceKey(HKEY_LOCAL_MACHINE,"Software","","");
 487     if (lSts != ERROR_ACCESS_DENIED) fprintf(stderr, " 3:%ld\n",lSts);
 488 #endif
 489 }
 490
 491 /******************************************************************************
 492  * TestRestoreKey
 493  */
 494 void TestRestoreKey()
 495 {
 496     long lSts;
 497     fprintf(stderr, "Testing RegRestoreKey...\n");
 498
 499     lSts = RegRestoreKey((HKEY)2,"",0);
 500     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 1:%ld\n",lSts);
 501
 502     lSts = RegRestoreKey(HKEY_LOCAL_MACHINE,"",0);
 503     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 504
 505     lSts = RegRestoreKey(HKEY_LOCAL_MACHINE,"a.a",0);
 506     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 3:%ld\n",lSts);
 507 }
 508
 509 /******************************************************************************
 510  * TestSaveKey
 511  */
 512 void TestSaveKey()
 513 {
 514     long lSts;
 515     fprintf(stderr, "Testing RegSaveKey...\n");
 516
 517     lSts = RegSaveKey((HKEY)2,"",NULL);
 518     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 1:%ld\n",lSts);
 519
 520     lSts = RegSaveKey(HKEY_LOCAL_MACHINE,"",NULL);
 521     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 522
 523 #if CHECK_SAM
 524     lSts = RegSaveKey(HKEY_LOCAL_MACHINE,"a.a",NULL);
 525     if (lSts != ERROR_PRIVILEGE_NOT_HELD) fprintf(stderr, " 3:%ld\n",lSts);
 526 #endif
 527 }
 528
 529 /******************************************************************************
 530  * TestSetKeySecurity
 531  */
 532 void TestSetKeySecurity()
 533 {
 534     long lSts;
 535     SECURITY_DESCRIPTOR sd;
 536     fprintf(stderr, "Testing RegSetKeySecurity...\n");
 537
 538     lSts = RegSetKeySecurity((HKEY)2,0,NULL);
 539     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 1:%ld\n",lSts);
 540
 541     lSts = RegSetKeySecurity(HKEY_LOCAL_MACHINE,0,NULL);
 542     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 543
 544     lSts = RegSetKeySecurity(HKEY_LOCAL_MACHINE,OWNER_SECURITY_INFORMATION,NULL);
 545     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 3:%ld\n",lSts);
 546
 547     lSts = RegSetKeySecurity(HKEY_LOCAL_MACHINE,OWNER_SECURITY_INFORMATION,&sd);
 548     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 4:%ld\n",lSts);
 549 }
 550
 551 /******************************************************************************
 552  * TestSetValue
 553  */
 554 void TestSetValue()
 555 {
 556     long lSts;
 557     fprintf(stderr, "Testing RegSetValue...\n");
 558
 559 #if MAKE_NT_CRASH
 560     lSts = RegSetValue((HKEY)2,"",0,NULL,0);
 561     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 1:%ld\n",lSts);
 562 #endif
 563
 564 #if MAKE_NT_CRASH
 565     lSts = RegSetValue((HKEY)2,"regtest",0,NULL,0);
 566     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 567 #endif
 568
 569 #if MAKE_NT_CRASH
 570     lSts = RegSetValue((HKEY)2,"regtest",REG_SZ,NULL,0);
 571     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 3:%ld\n",lSts);
 572 #endif
 573
 574 #if MAKE_NT_CRASH
 575     lSts = RegSetValue(HKEY_LOCAL_MACHINE,"regtest",REG_SZ,NULL,0);
 576     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 4:%ld\n",lSts);
 577 #endif
 578 }
 579
 580 /******************************************************************************
 581  * TestSetValueEx
 582  */
 583 void TestSetValueEx()
 584 {
 585     long lSts;
 586     fprintf(stderr, "Testing RegSetValueEx...\n");
 587
 588     lSts = RegSetValueEx((HKEY)2,"",0,0,NULL,0);
 589     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 590
 591     lSts = RegSetValueEx(HKEY_LOCAL_MACHINE,"",0,0,NULL,0);
 592     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
 593 }
 594
 595 /******************************************************************************
 596  * TestUnLoadKey
 597  */
 598 void TestUnLoadKey()
 599 {
 600     long lSts;
 601     fprintf(stderr, "Testing RegUnloadKey...\n");
 602
 603 #if CHECK_SAM
 604     lSts = RegUnLoadKey((HKEY)2,"");
 605     if (lSts != ERROR_PRIVILEGE_NOT_HELD) fprintf(stderr, " 1:%ld\n",lSts);
 606
 607     lSts = RegUnLoadKey(HKEY_LOCAL_MACHINE,"");
 608     if (lSts != ERROR_PRIVILEGE_NOT_HELD) fprintf(stderr, " 2:%ld\n",lSts);
 609
 610     lSts = RegUnLoadKey(HKEY_LOCAL_MACHINE,"\\regtest");
 611     if (lSts != ERROR_PRIVILEGE_NOT_HELD) fprintf(stderr, " 3:%ld\n",lSts);
 612 #endif
 613 }
 614
 615 /******************************************************************************
 616  * TestSequence1
 617  */
 618 void TestSequence1()
 619 {
 620     HKEY hkey;
 621     long lSts;
 622
 623     fprintf(stderr, "Testing Sequence1...\n");
 624
 625     lSts = RegCreateKey(HKEY_CURRENT_USER,"regtest",&hkey);
 626     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 1:%ld\n",lSts);
 627
 628     fprintf(stderr, " hkey=0x%x\n", hkey);
 629
 630     lSts = RegDeleteKey(HKEY_CURRENT_USER, "regtest");
 631     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
 632     lSts = RegCloseKey(hkey);
 633     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
 634 }
 635
 636
 637 int PASCAL WinMain (HANDLE inst, HANDLE prev, LPSTR cmdline, int show)
 638 {
 639
 640     /* These can be in any order */
 641     TestCloseKey();
 642     TestConnectRegistry();
 643     TestCreateKey();
 644     TestCreateKeyEx();
 645     TestDeleteKey();
 646     TestDeleteValue();
 647     TestEnumKey();
 648     TestEnumKeyEx();
 649     TestEnumValue();
 650     TestFlushKey();
 651     TestGetKeySecurity();
 652     TestLoadKey();
 653     TestNotifyChangeKeyValue();
 654     TestOpenKey();
 655     TestOpenKeyEx();
 656     TestQueryInfoKey();
 657     TestQueryValue();
 658     TestQueryValueEx();
 659     TestReplaceKey();
 660     TestRestoreKey();
 661     TestSaveKey();
 662     TestSetKeySecurity();
 663     TestSetValue();
 664     TestSetValueEx();
 665     TestUnLoadKey();
 666
 667     /* Now we have some sequence testing */
 668     TestSequence1();
 669
 670     return 0;
 671 }
 672