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