Paul Prescod <paul@prescod.net>:

Regression test for the new winreg.py module.

[Could a Windows person someone please review this?]

Lib/test/test_winreg2.py

+from winreg import hives, createKey, openKey, flags, deleteKey, regtypes
+import sys, traceback
+import time
+
+def testHives():
+    hivenames = ["HKEY_CLASSES_ROOT","HKEY_CURRENT_USER","HKEY_LOCAL_MACHINE",
+                "HKEY_USERS","HKEY_CURRENT_CONFIG"] #, # 
+    for hivename in hivenames:
+        hive = hives[ hivename ]
+        print hive.name
+        assert hive.handle
+        assert hive.getSubkeys()
+    for hivename in ["HKEY_DYN_DATA", "HKEY_PERFORMANCE_DATA"]:
+        hive =  hives[ hivename ]
+        print hive.name
+        assert hive.handle
+        assert not hive.getValues()
+        assert not hive.getSubkeys()
+
+def testNonZero():
+    key=hives["HKLM"].openSubkey( "SOFTWARE" )
+    assert key.openSubkey( "Microsoft" )
+    assert key
+    key.close()
+    assert not key
+    try:
+        key.openSubkey( "Microsoft" )
+        assert 0
+    except EnvironmentError:
+        pass
+
+def testCmp():
+    HKLM=hives["HKLM"]
+    assert (openKey("HKLM\\SOFTWARE")==\
+                        HKLM.openSubkey("SOFTWARE"))
+    assert not HKLM.openSubkey("SYSTEM")!=HKLM.openSubkey("SYSTEM")
+    assert HKLM.openSubkey("SOFTWARE")!=HKLM.openSubkey("SYSTEM")
+    assert not HKLM.openSubkey("SOFTWARE")==HKLM.openSubkey("SYSTEM")
+    assert not HKLM.openSubkey("SOFTWARE")=="spam"
+    assert ((HKLM.openSubkey("SOFTWARE")<"spam") !=
+                        (HKLM.openSubkey("SOFTWARE")>"spam"))
+
+def testClose(): 
+    key=hives["HKLM"].openSubkey( "SOFTWARE" )
+    assert key
+    key.close()
+    assert not key
+
+def testOpen():
+    assert openKey( r"HKLM" )
+    assert openKey( r"HKLM\HARDWARE" )
+    assert openKey( r"HKLM\HARDWARE\DESCRIPTION\System" )
+
+def testOpenFailure():
+    try:
+        print openKey( r"HKCU\Software\Python\A\B\C\D" )
+        assert 0 #
+    except EnvironmentError:
+        pass
+
+def testDeleteKey():
+    createKey( r"HKCU\Software\Python\A\B\C\D" )
+    deleteKey( r"HKCU\Software\Python\A\B\C\D" )
+    deleteKey( r"HKCU\Software\Python\A\B\C" )
+    deleteKey( r"HKCU\Software\Python\A\B" )
+    assert "A" in \
+            openKey(r"HKCU\Software\Python").getSubkeys().keys()
+    openKey( r"HKCU\Software\Python" ).deleteSubkey( r"A" )
+    assert "A" not in \
+            openKey(r"HKCU\Software\Python").getSubkeys().keys()
+
+def testDeleteValue():
+    key=createKey( r"HKCU\Software\Python\A" )
+    key.setValue( "abcde", "fghij" )
+    assert key.getValueData( "abcde" )=="fghij"
+    assert "abcde" in key.getValues().keys()
+    assert "fghij" in map( lambda x:x[1], key.getValues().values() )
+    assert "abcde" in key.getValues().keys()
+    key.deleteValue( "abcde" )
+    assert "abcde" not in key.getValues().keys()
+    assert "fghij" not in map( lambda x:x[1], key.getValues().values() )
+    deleteKey( r"HKCU\Software\Python\A" )
+
+def testCreateKey():
+    key=createKey( r"HKCU\Software\Python\A" )
+    assert openKey( r"HKCU\Software\Python").getSubkeys().has_key( "A" )
+    deleteKey( r"HKCU\Software\Python\A" )
+    assert not openKey( r"HKCU\Software\Python").getSubkeys().\
+                        has_key( "A" )
+    key=openKey( r"HKCU\Software\Python" ).createSubkey( "A" )
+
+def testOpenKeyWithFlags():
+    assert openKey( r"HKCU\Software\Python", 
+                                flags["KEY_READ"])
+    assert openKey( r"HKCU\Software\Python", 
+                                flags["KEY_ALL_ACCESS"])
+
+def testGetSubkeys():
+    keys=openKey( r"HKCU\Software" ).getSubkeys()
+    assert keys
+    index=0
+    for i in keys:
+        index=index+1
+    assert index==len( keys )
+
+def testGetValueNameDataAndType(): pass
+
+def testGetSubkeyNames():
+    subkeyNames=hives["HKLM"].getSubkeyNames()
+    assert len( subkeyNames )==len(hives["HKLM"].getSubkeys())
+    for name in subkeyNames:
+        assert type( name )==type("")
+
+def testGetValueNames(): 
+    valNames=hives["HKLM"].getValueNames()
+    assert len( valNames )==len(hives["HKLM"].getValues())
+    for name in valNames:
+        assert type( name )==type("")
+
+def testRepr():
+    assert repr(hives["HKCU"])==str(hives["HKCU"])
+
+def testSetStringValue():
+    hives["HKCU"].setValue( "Blah", "abc" )
+    assert hives["HKCU"].getValueData( "Blah" )=="abc"
+    assert hives["HKCU"].getValues().has_key( "Blah" )
+    del hives["HKCU"].getValues()[ "Blah" ]
+    assert not hives["HKCU"].getValues().has_key( "Blah" )
+
+def testDeleteValue():
+    hives["HKCU"].setValue( "Blah", "abc" )
+    assert hives["HKCU"].getValues().has_key( "Blah" )
+    del hives["HKCU"].getValues()[ "Blah" ]
+    assert not hives["HKCU"].getValues().has_key( "Blah" )
+    hives["HKCU"].setValue( "Blah", "abc" )
+    hives["HKCU"].deleteValue( "Blah" )
+    assert not hives["HKCU"].getValues().has_key( "Blah" )
+
+def testKeyDict_ClearKeys():
+    createKey( "HKLM\\Software\\a\\b\\c\\d\\e" )
+    createKey( "HKLM\\Software\\a\\b\\c\\d\\f" )
+    createKey( "HKLM\\Software\\a\\b\\c\\d\\g" )
+    createKey( "HKLM\\Software\\a\\b\\c\\d\\h" )
+    createKey( "HKLM\\Software\\a\\b\\c\\d\\i" )
+    key=openKey( "HKLM\\Software\\a\\b\\c\\d" )
+    assert key.getSubkeys()
+    key.getSubkeys().clear()
+    assert not key.getSubkeys()
+    assert not openKey( "HKLM\\Software\\a\\b\\c\\d").getSubkeys()
+    deleteKey( "HKLM\\Software\\a\\b\\c\\d" )
+    deleteKey( "HKLM\\Software\\a\\b\\c" )
+    deleteKey( "HKLM\\Software\\a\\b" )
+    deleteKey( "HKLM\\Software\\a" )
+
+def testUnicodeKeyName(): pass
+
+def testUnicodeValueName(): pass
+
+def testGetValueDataFromEnum(): pass
+
+def testGetValueDataFromName(): pass
+
+def testGetBinaryData(): pass
+
+
+def testSetIntValue():
+    key=createKey( "HKLM\\Software\\a\\b")
+    key.setValue( "abcd", 5 )
+    assert key.getValueData( "abcd" )==5
+    assert key.getValues()[ "abcd" ][1]==5
+    key.deleteValue( "abcd" )
+    key.getValues()["abcd"]=5
+    assert key.getValues()[ "abcd" ][1]==5
+    key.deleteValue( "abcd" )
+    key.getValues()["abcd"]=(5,regtypes["REG_DWORD"])
+    assert key.getValues()[ "abcd" ][1]==5
+    key.deleteValue( "abcd" )
+    key.deleteKey( "HKLM\\Software\\a\\b")
+    key.deleteKey( "HKLM\\Software\\a")
+
+def testSetBinaryValue(): 
+    key=createKey( "HKLM\\Software\\a\\b")
+    key.setValue( "abcd", array.array( 'c', "PPPPPPPPPPPPPPP") )
+    key.setValue( "abcde", array.array( 'c', "PPPPPPPPPPPPPPP"), 
+                       regtypes["REG_BINARY"] )
+    assert key.getValues()["abcd"]==key.getValues()["abcde"]
+    key.deleteKey( "HKLM\\Software\\a\\b")
+    key.deleteKey( "HKLM\\Software\\a")
+
+def testSetNone(): pass
+
+def testSetString(): pass
+
+def testSetExpandString(): pass
+
+def testSetBinaryData(): pass
+
+def testSetDword(): pass
+
+def testSetDwordBigEndian(): pass
+
+def testSetLink(): pass
+
+def testSetMultiSz(): pass
+
+def testSetResourceList(): pass
+
+def testSetFullResourceDescription(): pass
+
+def testSetResourceRequirementsList(): pass
+
+
+
+def testFlush(): pass
+
+def testSave(): pass
+
+def testLoad(): pass
+
+
+
+
+
+def testNoneType(): pass
+
+def testStringType(): pass
+
+def testExpandStringType(): pass
+
+def testDWordType(): pass
+
+def testDWordBigEndianType(): pass
+
+def testLinkType(): pass
+
+def testMultiStringType(): pass
+
+def testResourceLinkType(): pass
+
+def testResourceDescriptionType(): pass
+
+def testResourceRequirementsListType(): pass
+
+
+def getSubkeysDict(): pass
+
+def testKeyDict_Get(): pass
+
+def testKeyDict_HasKey(): pass
+
+def testKeyDict_Keys(): pass
+
+def testKeyDict_Values(): pass
+
+def testKeyDict_Items(): pass
+
+def testKeyDict_Length(): pass
+
+def testKeyDict_Map(): pass
+
+def testKeyDict_GetItem(): pass
+
+def testKeyDict_DelItem(): pass
+
+def testRemote(): pass
+
+def testShortcuts(): pass
+
+
+
+def getValues(): pass
+
+def testValueDict_ClearKeys(): pass
+
+def testValueDict_Get(): pass
+
+def testValueDict_HasKey(): pass
+
+def testValueDict_Keys(): pass
+
+def testValueDict_Values(): pass
+
+def testValueDict_Items(): pass
+
+def testValueDict_Length(): pass
+
+def testValueDict_Map(): pass
+
+def testValueDict_GetItem(): pass
+
+def testValueDict_DelItem(): pass
+
+for name in globals().keys():
+    if name[0:4]=="test":
+        func=globals()[ name ]
+        try:
+            func()
+            print "Test Passed: %s" % name
+        except Exception, e:
+            print "Test Failed: %s" % name
+            traceback.print_exc()
+
+j=[0]*len( regtypes )
+
+k=0
+
+def test1( basekey ):
+    global k
+    for (name, data, type) in basekey.getValues():
+        j[type.intval]=j[type.intval]+1
+        if j[type.intval]==1:
+            pass
+            #print "[[%s]] %s [%s] = %s "% (type.msname, name, basekey, value)
+    keys=basekey.getSubkeys()
+    index=0
+    k=k+1
+    if(k%2500)==0:
+        dump()
+    while 1:
+        try:
+            test1( keys[index] )
+            index=index+1
+        except IndexError:
+            break
+            print "Done", basekey, index
+        except (WindowsError, EnvironmentError):
+            index=index+1
+            dumpfile.write( "Skipping %s %s"% (basekey, index))
+
+def dump(dumpfile):
+    for i in range( len( j )):
+        dumpfile.write( "%s %s\n" %( i,j[i] ))
+
+def testRecursive():
+    dumpfile=open( "foo.txt", "w" )
+    start=time.time()
+    for hive in hives.values():
+        dumpfile.write( "Hive: %s\n" % hive )
+        test1( hive )
+        dump(dumpfile)
+    print time.time()-start