source3/script/tests/test_net_registry.sh

   1 #!/bin/sh
   2
   3 # tests for the "net registry" command - local access to the registry db
   4
   5
   6 NET="$VALGRIND ${NET:-$BINDIR/net} $CONFIGURATION"
   7
   8 NETREG="${NET} registry"
   9
  10 incdir=`dirname $0`
  11 . $incdir/test_functions.sh
  12
  13 failed=0
  14
  15 test_enumerate()
  16 {
  17         KEY="$1"
  18
  19         ${NETREG} enumerate ${KEY}
  20 }
  21
  22 test_getsd()
  23 {
  24         KEY="$1"
  25
  26         ${NETREG} getsd ${KEY}
  27 }
  28
  29 test_enumerate_nonexisting()
  30 {
  31         KEY="$1"
  32         ${NETREG} enumerate ${KEY}
  33         if test "x$?" = "x0" ; then
  34                 echo "ERROR: enumerate succeeded with key '${KEY}'"
  35                 false
  36         else
  37                 true
  38         fi
  39 }
  40
  41 test_enumerate_no_key()
  42 {
  43         ${NETREG} enumerate
  44         if test "x$?" = "x0" ; then
  45                 echo "ERROR: enumerate succeeded without any key spcified"
  46                 false
  47         else
  48                 true
  49         fi
  50 }
  51
  52 test_create_existing()
  53 {
  54         KEY="HKLM"
  55         EXPECTED="createkey opened existing ${KEY}"
  56         OUTPUT=`${NETREG} createkey ${KEY}`
  57         if test "x$?" = "x0" ; then
  58                 if test "$OUTPUT" = "$EXPECTED" ; then
  59                         true
  60                 else
  61                         echo "got '$OUTPUT', expected '$EXPECTED'"
  62                         false;
  63                 fi
  64         else
  65                 printf "%s" "$OUTPUT"
  66                 false
  67         fi
  68 }
  69
  70 test_createkey()
  71 {
  72         KEY="$1"
  73         BASEKEY=`dirname $KEY`
  74         SUBKEY=`basename $KEY`
  75
  76         ${NETREG} createkey ${KEY}
  77         if test "x$?" != "x0" ; then
  78                 false
  79                 return
  80         fi
  81
  82         # check enumerate of basekey lists new key:
  83         OUTPUT=`${NETREG} enumerate ${BASEKEY}`
  84         if test "x$?" != "x0" ; then
  85                 echo "ERROR: failed to enumerate key '${BASEKEY}'"
  86                 echo "output:"
  87                 printf "%s" "$OUTPUT"
  88                 false
  89                 return
  90         fi
  91
  92         EXPECTED="Keyname = ${SUBKEY}"
  93         printf "%s" "$OUTPUT" | grep ^Keyname | grep ${SUBKEY}
  94         if test "x$?" != "x0" ; then
  95                 echo "ERROR: did not find expexted '$EXPECTED' in output"
  96                 echo "output:"
  97                 printf "%s" "$OUTPUT"
  98                 false
  99         fi
 100
 101         # check enumerate of new key works:
 102         ${NETREG} enumerate ${KEY}
 103 }
 104
 105 test_deletekey()
 106 {
 107         KEY="$1"
 108         BASEKEY=`dirname ${KEY}`
 109         SUBKEY=`basename ${KEY}`
 110
 111         test_createkey "${KEY}"
 112
 113         if test "x$?" != "x0" ; then
 114                 false
 115                 return
 116         fi
 117
 118         ${NETREG} deletekey ${KEY}
 119
 120         # check enumerate of basekey does not show key anymore:
 121         OUTPUT=`${NETREG} enumerate ${BASEKEY}`
 122         if test "x$?" != "x0" ; then
 123                 printf "%s" "$OUTPUT"
 124                 false
 125                 return
 126         fi
 127
 128         UNEXPECTED="Keyname = ${SUBKEY}"
 129         printf "%s" "$OUTPUT" | grep ^Keyname | grep ${SUBKEY}
 130         if test "x$?" = "x0" ; then
 131                 echo "ERROR: found '$UNEXPECTED' after delete in output"
 132                 echo "output:"
 133                 printf "%s" "$OUTPUT"
 134                 false
 135         fi
 136
 137         # check enumerate of key itself does not work anymore:
 138         ${NETREG} enumerate ${KEY}
 139         if test "x$?" = "x0" ; then
 140                 echo "ERROR: 'enumerate ${KEY}' works after 'deletekey ${KEY}'"
 141                 false
 142         else
 143                 true
 144         fi
 145 }
 146
 147 test_deletekey_nonexisting()
 148 {
 149         KEY="$1"
 150
 151         test_deletekey "${KEY}"
 152
 153         if test "x$?" != "x0" ; then
 154                 false
 155                 return
 156         fi
 157
 158         ${NETREG} deletekey "${KEY}"
 159         if test "x$?" = "x0" ; then
 160                 echo "ERROR: delete after delete succeeded for key '${KEY}'"
 161                 false
 162         fi
 163 }
 164
 165 test_createkey_with_subkey()
 166 {
 167         KEY="$1"
 168         KEY2=`dirname ${KEY}`
 169         SUBKEYNAME2=`basename ${KEY}`
 170         BASENAME=`dirname ${KEY2}`
 171         SUBKEYNAME1=`basename ${KEY2}`
 172
 173         ${NETREG} createkey ${KEY}
 174
 175         if test "x$?" != "x0" ; then
 176                 false
 177                 return
 178         fi
 179
 180         # check we can enumerate to level key
 181         ${NETREG} enumerate ${KEY}
 182         if test "x$?" != "x0" ; then
 183                 echo "ERROR: failed to enumerate '${KEY}' after creation"
 184                 false
 185                 return
 186         fi
 187
 188         # clear:
 189         ${NETREG} deletekey ${KEY} && ${NETREG} deletekey ${KEY2}
 190 }
 191
 192 test_deletekey_with_subkey()
 193 {
 194         KEY="$1"
 195         KEY2=`dirname ${KEY}`
 196
 197         ${NETREG} createkey ${KEY}
 198
 199         if test "x$?" != "x0" ; then
 200                 false
 201                 return
 202         fi
 203
 204         OUTPUT=`${NETREG} deletekey ${KEY2}`
 205
 206         if test "x$?" = "x0" ; then
 207                 echo "ERROR: delete of key with subkey succeeded"
 208                 echo "output:"
 209                 printf "%s" "$OUTPUT"
 210                 false
 211                 return
 212         fi
 213
 214         ${NETREG} deletekey ${KEY} && ${NETREG} deletekey ${KEY2}
 215 }
 216
 217 test_setvalue()
 218 {
 219         KEY="$1"
 220         VALNAME="$2"
 221         VALTYPE="$3"
 222         VALVALUE="$4"
 223
 224         test_createkey ${KEY}
 225         if test "x$?" != "x0" ; then
 226                 false
 227                 return
 228         fi
 229
 230         ${NETREG} setvalue ${KEY} ${VALNAME} ${VALTYPE} ${VALVALUE}
 231         if test "x$?" != "x0" ; then
 232                 echo "ERROR: failed to set value testval in key ${KEY}"
 233                 false
 234                 return
 235         fi
 236
 237         OUTPUT=`${NETREG} enumerate ${KEY}`
 238         if test "x$?" != "x0" ; then
 239                 echo "ERROR: failure calling enumerate for key ${KEY}"
 240                 echo output:
 241                 printf "%s" "${OUTPUT}"
 242                 false
 243                 return
 244         fi
 245
 246         printf "%s" "$OUTPUT" | {
 247         FOUND=0
 248         while read LINE ; do
 249                 SEARCH1=`echo $LINE | grep ^Valuename | grep ${VALNAME}`
 250                 if test "x$?" = "x0" ; then
 251                         read LINE
 252                         read LINE
 253                         SEARCH2=`echo $LINE | grep "^Value " | grep ${VALVALUE}`
 254                         if test "x$?" = "x0" ; then
 255                                 FOUND=1
 256                                 break
 257                         fi
 258                 fi
 259         done
 260
 261         if test "x$FOUND" != "x1" ; then
 262                 echo "ERROR: did not find value '${VALNAME}' with enumerate"
 263                 echo "enumerate output:"
 264                 printf "%s" "$OUTPUT"
 265                 false
 266                 return
 267         fi
 268         }
 269 }
 270
 271 test_deletevalue()
 272 {
 273         KEY="$1"
 274         VALNAME="$2"
 275
 276         ${NETREG} deletevalue ${KEY} ${VALNAME}
 277 }
 278
 279 test_deletevalue_nonexisting()
 280 {
 281         KEY="$1"
 282         VALNAME="$2"
 283
 284         ${NETREG} deletevalue ${KEY} ${VALNAME}
 285         if test "x$?" = "x0" ; then
 286                 echo "ERROR: succeeded deleting value ${VALNAME}"
 287                 false
 288         else
 289                 true
 290         fi
 291 }
 292
 293 test_setvalue_twice()
 294 {
 295         KEY="$1"
 296         VALNAME="$2"
 297         VALTYPE1="$3"
 298         VALVALUE1="$4"
 299         VALTYPE2="$5"
 300         VALVALUE2="$6"
 301
 302         OUTPUT=`test_setvalue ${KEY} ${VALNAME} ${VALTYPE1} ${VALVALUE1}`
 303         if test "x$?" != "x0" ; then
 304                 printf "%s" "$OUTPUT"
 305                 false
 306                 return
 307         fi
 308
 309         ${NETREG} setvalue ${KEY} ${VALNAME} ${VALTYPE2} ${VALVALUE2}
 310 }
 311
 312
 313 testit "enumerate HKLM" \
 314         test_enumerate HKLM || \
 315         failed=`expr $failed + 1`
 316
 317 testit "enumerate nonexisting hive" \
 318         test_enumerate_nonexisting XYZ || \
 319         failed=`expr $failed + 1`
 320
 321 testit "enumerate without key" \
 322         test_enumerate_no_key || \
 323         failed=`expr $failed + 1`
 324
 325 testit "getsd HKLM" \
 326         test_getsd HKLM || \
 327         failed=`expr $failed + 1`
 328
 329 testit "create existing HKLM" \
 330         test_create_existing || \
 331         failed=`expr $failed + 1`
 332
 333 testit "create key" \
 334         test_createkey HKLM/testkey || \
 335         failed=`expr $failed + 1`
 336
 337 testit "delete key" \
 338         test_deletekey HKLM/testkey || \
 339         failed=`expr $failed + 1`
 340
 341 testit "delete^2 key" \
 342         test_deletekey_nonexisting HKLM/testkey || \
 343         failed=`expr $failed + 1`
 344
 345 testit "enumerate nonexisting key" \
 346         test_enumerate_nonexisting HKLM/testkey || \
 347         failed=`expr $failed +1`
 348
 349 testit "create key with subkey" \
 350         test_createkey_with_subkey HKLM/testkey/subkey || \
 351         failed=`expr $failed + 1`
 352
 353 testit "delete key with subkey" \
 354         test_deletekey_with_subkey HKLM/testkey/subkey || \
 355         failed=`expr $failed + 1`
 356
 357 testit "set value" \
 358         test_setvalue HKLM/testkey testval sz moin || \
 359         failed=`expr $failed + 1`
 360
 361 testit "delete value" \
 362         test_deletevalue HKLM/testkey testval || \
 363         failed=`expr $failed + 1`
 364
 365 testit "delete nonexisting value" \
 366         test_deletevalue_nonexisting HKLM/testkey testval || \
 367         failed=`expr $failed + 1`
 368
 369 testit "set value to different type"
 370         test_setvalue_twice HKLM/testkey testval sz moin dword 42 || \
 371         failed=`expr $failed + 1`
 372
 373 testit "delete key with value" \
 374         test_deletekey HKLM/testkey || \
 375         failed=`expr $failed + 1`
 376
 377 testok $0 $failed
 378