git.oblomov.eu Git - wine/blob - programs/regtest/regtest.c

   1 /*
   2  * Registry testing program
   3  *
   4  * The return codes were generated in an NT40 environment, using lcc-win32
   5  *
   6  * Copyright 1998 by Matthew Becker (mbecker@glasscity.net)
   7  *
   8 */
   9
  10 #include <stdio.h>
  11 #include <malloc.h>
  12 #include <windows.h>
  13 #include <winreg.h>
  14 #include <winerror.h>
  15
  16 /*
  17  * NOTES: These individual routines are listed in alphabetical order.
  18  */
  19
  20 /******************************************************************************
  21  * TestCloseKey
  22  */
  23 void TestCloseKey()
  24 {
  25     long lSts;
  26     HKEY hkey;
  27     fprintf(stderr, "Testing RegCloseKey...\n");
  28
  29     hkey = (HKEY)0;
  30     lSts = RegCloseKey(hkey);
  31     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
  32
  33     hkey = (HKEY)-2;
  34     lSts = RegCloseKey(hkey);
  35     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 2:%ld\n",lSts);
  36
  37     lSts = RegCloseKey(HKEY_LOCAL_MACHINE);
  38     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
  39
  40     lSts = RegCloseKey(HKEY_LOCAL_MACHINE);
  41     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 4:%ld\n",lSts);
  42 }
  43
  44 /******************************************************************************
  45  * TestConnectRegistry
  46  */
  47 void TestConnectRegistry()
  48 {
  49     long lSts;
  50     HKEY hkey;
  51     fprintf(stderr, "Testing RegConnectRegistry...\n");
  52
  53     lSts = RegConnectRegistry("",0,&hkey);
  54     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 1:%ld\n",lSts);
  55
  56     lSts = RegConnectRegistry("",HKEY_LOCAL_MACHINE,&hkey);
  57     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
  58 }
  59
  60 /******************************************************************************
  61  * TestCreateKey
  62  */
  63 void TestCreateKey()
  64 {
  65     HKEY hKeyIn;
  66     long lSts;
  67     HKEY hkey;
  68
  69     fprintf(stderr, "Testing RegCreateKey...\n");
  70
  71     hKeyIn = (HKEY)1;
  72     lSts = RegCreateKey(hKeyIn,"",&hkey);
  73     if (lSts != ERROR_BADKEY) fprintf(stderr, " 1:%ld\n",lSts);
  74
  75     lSts = RegCreateKey(HKEY_LOCAL_MACHINE,"\\asdf",&hkey);
  76     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 2:%ld\n",lSts);
  77 }
  78
  79 /******************************************************************************
  80  * TestCreateKeyEx
  81  */
  82 void TestCreateKeyEx()
  83 {
  84     HKEY hKeyIn;
  85     long lSts;
  86     HKEY hkey;
  87     DWORD dwDisp;
  88
  89     fprintf(stderr, "Testing RegCreateKeyEx...\n");
  90
  91     hKeyIn = (HKEY)1;
  92     lSts = RegCreateKeyEx(hKeyIn,"",0,"",0,0,NULL,&hkey,&dwDisp);
  93     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 1:%ld\n",lSts);
  94
  95     lSts = RegCreateKeyEx(hKeyIn,"regtest",0,"",0,0,NULL,&hkey,&dwDisp);
  96     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
  97
  98     lSts = RegCreateKeyEx(hKeyIn,"regtest",0,"asdf",0,KEY_ALL_ACCESS,NULL,&hkey,&dwDisp);
  99     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
 100 }
 101
 102 /******************************************************************************
 103  * TestDeleteKey
 104  */
 105 void TestDeleteKey()
 106 {
 107     long lSts;
 108     HKEY hkey;
 109     fprintf(stderr, "Testing RegDeleteKey...\n");
 110
 111     hkey = (HKEY)0;
 112     lSts = RegDeleteKey(hkey, "asdf");
 113     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 114
 115     lSts = RegDeleteKey(HKEY_CURRENT_USER, "asdf");
 116     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 2:%ld\n",lSts);
 117 }
 118
 119 /******************************************************************************
 120  * TestDeleteValue
 121  */
 122 void TestDeleteValue()
 123 {
 124     long lSts;
 125     HKEY hkey;
 126     fprintf(stderr, "Testing RegDeleteValue...\n");
 127
 128     hkey = (HKEY)0;
 129     lSts = RegDeleteValue(hkey, "asdf");
 130     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 131
 132     lSts = RegDeleteValue(HKEY_CURRENT_USER, "asdf");
 133     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 2:%ld\n",lSts);
 134 }
 135
 136 /******************************************************************************
 137  * TestEnumKey
 138  */
 139 void TestEnumKey()
 140 {
 141     long lSts;
 142     char *sVal;
 143     long lVal;
 144     HKEY hkey;
 145
 146     fprintf(stderr, "Testing RegEnumKey...\n");
 147     sVal = (char *)malloc(1 * sizeof(char));
 148     lVal = sizeof(sVal);
 149
 150     hkey = (HKEY)0;
 151     lSts = RegEnumKey(hkey,3,sVal,lVal);
 152     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 153
 154     lSts = RegEnumKey(HKEY_CURRENT_USER,-1,sVal,lVal);
 155     if (lSts != ERROR_NO_MORE_ITEMS) fprintf(stderr, " 2:%ld\n",lSts);
 156
 157     lSts = RegEnumKey(HKEY_CURRENT_USER,0,sVal,lVal);
 158     if (lSts != ERROR_MORE_DATA) fprintf(stderr, " 3:%ld\n",lSts);
 159 }
 160
 161 /******************************************************************************
 162  * TestEnumKeyEx
 163  */
 164 void TestEnumKeyEx()
 165 {
 166     long lSts;
 167     char *sVal;
 168     char *sClass;
 169     unsigned long lLen1;
 170     unsigned long lLen2;
 171     FILETIME ft;
 172
 173     fprintf(stderr, "Testing RegEnumKeyEx...\n");
 174     sVal = (char *)malloc(80 * sizeof(char));
 175     lLen1= sizeof(sVal);
 176     sClass = (char *)malloc(10 * sizeof(char));
 177     lLen2 = sizeof(sClass);
 178
 179     lSts = RegEnumKeyEx(0,0,sVal,&lLen1,0,sClass,&lLen2,&ft);
 180     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 181 }
 182
 183 /******************************************************************************
 184  * TestEnumValue
 185  */
 186 void TestEnumValue()
 187 {
 188     long lSts;
 189     char *sVal;
 190     unsigned long lVal;
 191     unsigned long lType;
 192     unsigned long lLen1;
 193     char *bVal;
 194     HKEY hkey;
 195
 196     fprintf(stderr, "Testing RegEnumValue...\n");
 197     sVal = (char *)malloc(80 * sizeof(char));
 198     bVal = (char *)malloc(80 * sizeof(char));
 199     lVal = sizeof(sVal);
 200     lLen1 = sizeof(bVal);
 201
 202     hkey = (HKEY)0;
 203     lSts = RegEnumValue(hkey,-1,sVal,&lVal,0,&lType,NULL,&lLen1);
 204     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 205
 206     lSts = RegEnumValue(HKEY_LOCAL_MACHINE,-1,sVal,&lVal,0,&lType,NULL,&lLen1);
 207     if (lSts != ERROR_NO_MORE_ITEMS) fprintf(stderr, " 2:%ld\n",lSts);
 208
 209     lSts = RegEnumValue(HKEY_LOCAL_MACHINE,0,sVal,&lVal,0,&lType,NULL,&lLen1);
 210     if (lSts != ERROR_NO_MORE_ITEMS) fprintf(stderr, " 3:%ld\n",lSts);
 211
 212     lSts = RegEnumValue(HKEY_LOCAL_MACHINE,1,sVal,&lVal,0,&lType,bVal,&lLen1);
 213     if (lSts != ERROR_NO_MORE_ITEMS) fprintf(stderr, " 4:%ld\n",lSts);
 214 }
 215
 216 /******************************************************************************
 217  * TestFlushKey
 218  */
 219 void TestFlushKey()
 220 {
 221     long lSts;
 222     fprintf(stderr, "Testing RegFlushKey...\n");
 223
 224     lSts = RegFlushKey(0);
 225     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 226
 227     lSts = RegFlushKey(HKEY_LOCAL_MACHINE);
 228     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
 229 }
 230
 231 /******************************************************************************
 232  * TestGetKeySecurity
 233  */
 234 void TestGetKeySecurity()
 235 {
 236     long lSts;
 237     SECURITY_INFORMATION si;
 238     SECURITY_DESCRIPTOR sd;
 239     unsigned long lLen;
 240     HKEY hkey;
 241
 242     fprintf(stderr, "Testing RegGetKeySecurity...\n");
 243     lLen = sizeof(sd);
 244
 245     hkey = (HKEY)0;
 246     lSts = RegGetKeySecurity(hkey,si,&sd,&lLen);
 247     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 248
 249     lSts = RegGetKeySecurity(HKEY_LOCAL_MACHINE,si,&sd,&lLen);
 250     if (lSts != ERROR_INSUFFICIENT_BUFFER) fprintf(stderr, " 2:%ld\n",lSts);
 251
 252 #if 0
 253     si = GROUP_SECURITY_INFORMATION;
 254 #endif
 255     lSts = RegGetKeySecurity(HKEY_LOCAL_MACHINE,si,&sd,&lLen);
 256     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 3:%ld\n",lSts);
 257 }
 258
 259 /******************************************************************************
 260  * TestLoadKey
 261  */
 262 void TestLoadKey()
 263 {
 264     long lSts;
 265     fprintf(stderr, "Testing RegLoadKey...\n");
 266
 267     lSts = RegLoadKey(0,"","");
 268     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 269
 270     lSts = RegLoadKey(HKEY_CURRENT_USER,"","");
 271     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 272
 273     lSts = RegLoadKey(HKEY_CURRENT_USER,"regtest","");
 274     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 3:%ld\n",lSts);
 275
 276     lSts = RegLoadKey(HKEY_CURRENT_USER,"regtest","regtest.dat");
 277     if (lSts != ERROR_PRIVILEGE_NOT_HELD) fprintf(stderr, " 4:%ld\n",lSts);
 278 }
 279
 280 /******************************************************************************
 281  * TestNotifyChangeKeyValue
 282  */
 283 void TestNotifyChangeKeyValue()
 284 {
 285     long lSts;
 286     HANDLE hEvent;
 287     HKEY hkey;
 288
 289     fprintf(stderr, "Testing RegNotifyChangeKeyValue...\n");
 290     hEvent = 0;
 291
 292     hkey = (HKEY)2;
 293     lSts = RegNotifyChangeKeyValue(hkey, TRUE, REG_NOTIFY_CHANGE_NAME, 0, 0);
 294     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 295
 296     lSts = RegNotifyChangeKeyValue(HKEY_CURRENT_USER, TRUE, REG_NOTIFY_CHANGE_NAME, 0, 1);
 297     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 2:%ld\n",lSts);
 298
 299     lSts = RegNotifyChangeKeyValue(HKEY_CURRENT_USER, TRUE, REG_NOTIFY_CHANGE_NAME, hEvent, 1);
 300     if (lSts != ERROR_INVALID_PARAMETER) fprintf(stderr, " 3:%ld\n",lSts);
 301 }
 302
 303 /******************************************************************************
 304  * TestOpenKey
 305  */
 306 void TestOpenKey()
 307 {
 308     long lSts;
 309     HKEY hkey;
 310     fprintf(stderr, "Testing RegOpenKey...\n");
 311
 312     lSts = RegOpenKey(0, "",&hkey);
 313     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 1:%ld\n",lSts);
 314
 315     lSts = RegOpenKey(0, "regtest",&hkey);
 316     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 2:%ld\n",lSts);
 317
 318     lSts = RegOpenKey(HKEY_CURRENT_USER, "regtest1",&hkey);
 319     if (lSts != ERROR_FILE_NOT_FOUND) fprintf(stderr, " 3:%ld\n",lSts);
 320
 321     lSts = RegOpenKey(HKEY_CURRENT_USER, "\\regtest",&hkey);
 322     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 4:%ld\n",lSts);
 323 }
 324
 325 /******************************************************************************
 326  * TestOpenKeyEx
 327  */
 328 void TestOpenKeyEx()
 329 {
 330     long lSts;
 331     HKEY hkeyIn;
 332     HKEY hkey;
 333     fprintf(stderr, "Testing RegOpenKeyEx...\n");
 334
 335     hkeyIn = (HKEY)0;
 336     lSts = RegOpenKeyEx(hkeyIn,"",0,KEY_ALL_ACCESS,&hkey);
 337     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 338
 339     lSts = RegOpenKeyEx(HKEY_CURRENT_USER,"\\regtest",0,KEY_ALL_ACCESS,&hkey);
 340     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 2:%ld\n",lSts);
 341 }
 342
 343 /******************************************************************************
 344  * TestQueryInfoKey
 345  */
 346 void TestQueryInfoKey()
 347 {
 348     fprintf(stderr, "Testing RegQueryInfoKey...\n");
 349 }
 350
 351 /******************************************************************************
 352  * TestQueryValue
 353  */
 354 void TestQueryValue()
 355 {
 356     long lSts;
 357     HKEY hkey;
 358     long lLen;
 359     char *sVal;
 360
 361     fprintf(stderr, "Testing RegQueryValue...\n");
 362     hkey = (HKEY)0;
 363     sVal = (char *)malloc(80 * sizeof(char));
 364     lLen = strlen(sVal);
 365
 366     lSts = RegQueryValue(hkey,"",NULL,&lLen);
 367     if (lSts != ERROR_INVALID_HANDLE) fprintf(stderr, " 1:%ld\n",lSts);
 368
 369     lSts = RegQueryValue(HKEY_CURRENT_USER,"",NULL,&lLen);
 370     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 2:%ld\n",lSts);
 371
 372     lSts = RegQueryValue(HKEY_CURRENT_USER,"\\regtest",NULL,&lLen);
 373     if (lSts != ERROR_BAD_PATHNAME) fprintf(stderr, " 3:%ld\n",lSts);
 374
 375     lSts = RegQueryValue(HKEY_CURRENT_USER,"",sVal,&lLen);
 376     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 4:%ld\n",lSts);
 377 }
 378
 379 /******************************************************************************
 380  * TestQueryValueEx
 381  */
 382 void TestQueryValueEx()
 383 {
 384     fprintf(stderr, "Testing RegQueryValueEx...\n");
 385 }
 386
 387 /******************************************************************************
 388  * TestReplaceKey
 389  */
 390 void TestReplaceKey()
 391 {
 392     fprintf(stderr, "Testing RegReplaceKey...\n");
 393 }
 394
 395 /******************************************************************************
 396  * TestRestoreKey
 397  */
 398 void TestRestoreKey()
 399 {
 400     fprintf(stderr, "Testing RegRestoreKey...\n");
 401 }
 402
 403 void TestSequence1()
 404 {
 405     HKEY hkey;
 406     long lSts;
 407
 408     fprintf(stderr, "Testing Sequence1...\n");
 409
 410     lSts = RegCreateKey(HKEY_CURRENT_USER,"regtest",&hkey);
 411     if (lSts != ERROR_SUCCESS) fprintf(stderr, " 1:%ld\n",lSts);
 412 }
 413
 414
 415 int PASCAL WinMain (HANDLE inst, HANDLE prev, LPSTR cmdline, int show)
 416 {
 417
 418     /* These can be in any order */
 419     TestCloseKey();
 420     TestConnectRegistry();
 421     TestCreateKey();
 422     TestCreateKeyEx();
 423     TestDeleteKey();
 424     TestDeleteValue();
 425     TestEnumKey();
 426     TestEnumKeyEx();
 427     TestEnumValue();
 428     TestFlushKey();
 429     TestGetKeySecurity();
 430     TestLoadKey();
 431     TestNotifyChangeKeyValue();
 432     TestOpenKey();
 433     TestOpenKeyEx();
 434     TestQueryInfoKey();
 435     TestQueryValue();
 436     TestQueryValueEx();
 437     TestReplaceKey();
 438     TestRestoreKey();
 439 /*
 440     TestSaveKey();
 441     TestSetKeySecurity();
 442     TestSetValue();
 443     TestSetValueEx();
 444     TestUnloadKey();
 445 */
 446
 447     /* Now we have some sequence testing */
 448     TestSequence1();
 449
 450     return 0;
 451 }
 452