zjgcjy/pykd
1
0
Fork 0
Code Actions Releases Wiki Activity

[0.3.x] reworked : test scripts python3 compatible

Browse Source 
git-svn-id: https://pykd.svn.codeplex.com/svn@90961 9b283d60-5439-405e-af05-b73fd8c4d996
This commit is contained in:
SND\kernelnet_cp 2016-03-16 08:18:26 +00:00 committed by Mikhail I. Izmestev
parent d36bd37032
commit 2f192bbd01
13 changed files with 71 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pykd/pykdver.h
View File

@ -1,8 +1,8 @@
#define PYKD_VERSION_MAJOR 0 #define PYKD_VERSION_MAJOR 0
#define PYKD_VERSION_MINOR 3 #define PYKD_VERSION_MINOR 3
#define PYKD_VERSION_SUBVERSION 0 #define PYKD_VERSION_SUBVERSION 1
#define PYKD_VERSION_BUILDNO 38 #define PYKD_VERSION_BUILDNO 1
#define __VER_STR2__(x) #x #define __VER_STR2__(x) #x
#define __VER_STR1__(x) __VER_STR2__(x) #define __VER_STR1__(x) __VER_STR2__(x)

5
pykd/pymod.cpp
View File

@ -780,6 +780,11 @@ BOOST_PYTHON_MODULE( pykd )
.def( "__len__", TypeInfoAdapter::getElementCount ) .def( "__len__", TypeInfoAdapter::getElementCount )
.def( "__getitem__", TypeInfoAdapter::getElementByIndex ) .def( "__getitem__", TypeInfoAdapter::getElementByIndex )
.def( "__dir__", TypeInfoAdapter::getElementDir ) .def( "__dir__", TypeInfoAdapter::getElementDir )
#if PY_VERSION_HEX >= 0x03000000
.def("__bool__", TypeInfoAdapter::isZero )
#else
.def("__iszero__", TypeInfoAdapter::isZero )
#endif
; ;
python::class_<kdlib::TypedVar, kdlib::TypedVarPtr, python::bases<kdlib::NumBehavior>, boost::noncopyable >("typedVar", python::class_<kdlib::TypedVar, kdlib::TypedVarPtr, python::bases<kdlib::NumBehavior>, boost::noncopyable >("typedVar",

4
pykd/pytypeinfo.h
View File

@ -228,6 +228,10 @@ struct TypeInfoAdapter : public kdlib::TypeInfo {
static python::list getElementDir(kdlib::TypeInfo &typeInfo); static python::list getElementDir(kdlib::TypeInfo &typeInfo);
static bool isZero(kdlib::TypeInfo &typeInfo) {
return false;
}
}; };
struct BaseTypesEnum { struct BaseTypesEnum {

2
test/scripts/breakpoint.py
View File

@ -145,7 +145,7 @@ class BreakpointTest( unittest.TestCase ):
b3 = pykd.setBp( self.targetModule.CdeclFunc + 2) b3 = pykd.setBp( self.targetModule.CdeclFunc + 2)
self.assertEqual(3, pykd.getNumberBreakpoints()); self.assertEqual(3, pykd.getNumberBreakpoints());
bpLst = [pykd.getBp(i) for i in xrange(3)] bpLst = [pykd.getBp(i) for i in range(3)]
self.assertEqual(3, len(bpLst)) self.assertEqual(3, len(bpLst))
map( lambda bp: bp.remove(), bpLst) map( lambda bp: bp.remove(), bpLst)
self.assertEqual(0, pykd.getNumberBreakpoints()); self.assertEqual(0, pykd.getNumberBreakpoints());

2
test/scripts/intbase.py
View File

@ -29,7 +29,7 @@ class IntBaseTest( unittest.TestCase ):
self.assertTrue( -0x7FFFFFFF == numVariant(-0x7FFFFFFF) ) self.assertTrue( -0x7FFFFFFF == numVariant(-0x7FFFFFFF) )
self.assertTrue( -20000000000 == numVariant(-20000000000) ) self.assertTrue( -20000000000 == numVariant(-20000000000) )
self.assertTrue( -0x8000000000000000 == numVariant(-0x8000000000000000) ) self.assertTrue( -0x8000000000000000 == numVariant(-0x8000000000000000) )
self.assertTrue( numVariant(0x20L) == numVariant(0x20) ) #self.assertTrue( numVariant(0x20L) == numVariant(0x20) )
self.assertTrue( True == numVariant(True) ) self.assertTrue( True == numVariant(True) )
self.assertTrue( False == numVariant(0) ) self.assertTrue( False == numVariant(0) )
self.assertTrue( True == numVariant(1) ) self.assertTrue( True == numVariant(1) )

18
test/scripts/memtest.py
View File

@ -21,49 +21,49 @@ class MemoryTest( unittest.TestCase ):
ucharArray = pykd.loadBytes( target.module.ucharArray, 5 ) ucharArray = pykd.loadBytes( target.module.ucharArray, 5 )
testArray = [ 0, 10, 0x78, 128, 0xFF ] testArray = [ 0, 10, 0x78, 128, 0xFF ]
self.assertEqual( 5, len(ucharArray) ) self.assertEqual( 5, len(ucharArray) )
self.assertEqual( 0, len( [ ucharArray[i] for i in xrange(5) if ucharArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ ucharArray[i] for i in range(5) if ucharArray[i] != testArray[i] ] ) )
def testLoadWords( self ): def testLoadWords( self ):
loadArray = pykd.loadWords( target.module.ushortArray, 5 ) loadArray = pykd.loadWords( target.module.ushortArray, 5 )
testArray = [ 0, 10, 0xFF, 0x8000, 0xFFFF ] testArray = [ 0, 10, 0xFF, 0x8000, 0xFFFF ]
self.assertEqual( len(testArray), len(loadArray) ) self.assertEqual( len(testArray), len(loadArray) )
self.assertEqual( 0, len( [ loadArray[i] for i in xrange(len(testArray)) if loadArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ loadArray[i] for i in range(len(testArray)) if loadArray[i] != testArray[i] ] ) )
def testLoadDWords( self ): def testLoadDWords( self ):
loadArray = pykd.loadDWords( target.module.ulongArray, 5 ) loadArray = pykd.loadDWords( target.module.ulongArray, 5 )
testArray = [ 0, 0xFF, 0x8000, 0x80000000, 0xFFFFFFFF ] testArray = [ 0, 0xFF, 0x8000, 0x80000000, 0xFFFFFFFF ]
self.assertEqual( len(testArray), len(loadArray) ) self.assertEqual( len(testArray), len(loadArray) )
self.assertEqual( 0, len( [ loadArray[i] for i in xrange(len(testArray)) if loadArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ loadArray[i] for i in range(len(testArray)) if loadArray[i] != testArray[i] ] ) )
def testLoadQWords( self ): def testLoadQWords( self ):
loadArray = pykd.loadQWords( target.module.ulonglongArray, 5 ) loadArray = pykd.loadQWords( target.module.ulonglongArray, 5 )
testArray = [ 0, 0xFF, 0xFFFFFFFF, 0x8000000000000000, 0xFFFFFFFFFFFFFFFF ] testArray = [ 0, 0xFF, 0xFFFFFFFF, 0x8000000000000000, 0xFFFFFFFFFFFFFFFF ]
self.assertEqual( len(testArray), len(loadArray) ) self.assertEqual( len(testArray), len(loadArray) )
self.assertEqual( 0, len( [ loadArray[i] for i in xrange(len(testArray)) if loadArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ loadArray[i] for i in range(len(testArray)) if loadArray[i] != testArray[i] ] ) )
def testLoadSignBytes( self ): def testLoadSignBytes( self ):
charArray = pykd.loadSignBytes( target.module.ucharArray, 5 ) charArray = pykd.loadSignBytes( target.module.ucharArray, 5 )
testArray = [ 0, 10, 0x78, -128, -1 ] testArray = [ 0, 10, 0x78, -128, -1 ]
self.assertEqual( 5, len(charArray) ) self.assertEqual( 5, len(charArray) )
self.assertEqual( 0, len( [ charArray[i] for i in xrange(len(testArray)) if charArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ charArray[i] for i in range(len(testArray)) if charArray[i] != testArray[i] ] ) )
def testLoadSignWords( self ): def testLoadSignWords( self ):
loadArray = pykd.loadSignWords( target.module.ushortArray, 5 ) loadArray = pykd.loadSignWords( target.module.ushortArray, 5 )
testArray = [ 0, 10, 255, -32768, -1 ] testArray = [ 0, 10, 255, -32768, -1 ]
self.assertEqual( len(testArray), len(loadArray) ) self.assertEqual( len(testArray), len(loadArray) )
self.assertEqual( 0, len( [ loadArray[i] for i in xrange(len(testArray)) if loadArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ loadArray[i] for i in range(len(testArray)) if loadArray[i] != testArray[i] ] ) )
def testLoadSignDWords( self ): def testLoadSignDWords( self ):
loadArray = pykd.loadSignDWords( target.module.ulongArray, 5 ) loadArray = pykd.loadSignDWords( target.module.ulongArray, 5 )
testArray = [0, 255, 32768, -2147483648, -1] testArray = [0, 255, 32768, -2147483648, -1]
self.assertEqual( len(testArray), len(loadArray) ) self.assertEqual( len(testArray), len(loadArray) )
self.assertEqual( 0, len( [ loadArray[i] for i in xrange(len(testArray)) if loadArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ loadArray[i] for i in range(len(testArray)) if loadArray[i] != testArray[i] ] ) )
def testLoadSignQWords( self ): def testLoadSignQWords( self ):
loadArray = pykd.loadSignQWords( target.module.ulonglongArray, 5 ) loadArray = pykd.loadSignQWords( target.module.ulonglongArray, 5 )
testArray = [0, 255, 4294967295L, -9223372036854775808L, -1] testArray = [0, 255, 4294967295, -9223372036854775808, -1]
self.assertEqual( len(testArray), len(loadArray) ) self.assertEqual( len(testArray), len(loadArray) )
self.assertEqual( 0, len( [ loadArray[i] for i in xrange(len(testArray)) if loadArray[i] != testArray[i] ] ) ) self.assertEqual( 0, len( [ loadArray[i] for i in range(len(testArray)) if loadArray[i] != testArray[i] ] ) )
def testPtrRead( self ): def testPtrRead( self ):
self.assertEqual( 0x80, pykd.ptrByte( target.module.bigValue ) ) self.assertEqual( 0x80, pykd.ptrByte( target.module.bigValue ) )

14
test/scripts/moduletest.py
View File

@ -123,3 +123,17 @@ class ModuleTest( unittest.TestCase ):
# lst2 = target.module.getEnums() # lst2 = target.module.getEnums()
# self.assertNotEqual( 0, len(lst2) ) # self.assertNotEqual( 0, len(lst2) )
# self.assertTrue( "enumType" in lst2 ) # self.assertTrue( "enumType" in lst2 )
def testCompare(self):
self.assertTrue(target.module.begin() == target.module)
self.assertTrue(target.module.begin() + 1 != target.module)
self.assertTrue(target.module.begin() + 1 > target.module)
self.assertTrue(target.module.begin() + 1 >= target.module)
self.assertTrue(target.module.begin() - 1 < target.module)
self.assertTrue(target.module.begin() - 1 <= target.module)
self.assertTrue( True if target.module else False )
self.assertTrue( False if not target.module else True )
self.assertFalse(target.module==None)
self.assertTrue(target.module!=None)

6
test/scripts/mspdbtest.py
View File

@ -22,7 +22,7 @@ class MsPdbTest(unittest.TestCase):
"""Lookup symbol by name/address""" """Lookup symbol by name/address"""
with PeFileAsDumpLoader( os.path.join(os.environ["WINDIR"], r"System32\ole32.dll") ): with PeFileAsDumpLoader( os.path.join(os.environ["WINDIR"], r"System32\ole32.dll") ):
mod = pykd.module("ole32") mod = pykd.module("ole32")
print "\n" + str( mod ) print( "\n" + str( mod ) )
targetSymAddr = mod.offset("CPackagerMoniker::Create") targetSymAddr = mod.offset("CPackagerMoniker::Create")
self.assertNotEqual( 0, targetSymAddr ) self.assertNotEqual( 0, targetSymAddr )
@ -34,7 +34,7 @@ class MsPdbTest(unittest.TestCase):
with PeFileAsDumpLoader( os.path.join(os.environ["WINDIR"], r"System32\authz.dll") ): with PeFileAsDumpLoader( os.path.join(os.environ["WINDIR"], r"System32\authz.dll") ):
mod = pykd.module("authz") mod = pykd.module("authz")
print "\n" + str( mod ) print("\n" + str( mod ))
targetSymAddr = mod.offset("AuthzpDefaultAccessCheck") targetSymAddr = mod.offset("AuthzpDefaultAccessCheck")
self.assertNotEqual( 0, targetSymAddr ) self.assertNotEqual( 0, targetSymAddr )
@ -46,6 +46,6 @@ class MsPdbTest(unittest.TestCase):
with PeFileAsDumpLoader( os.path.join(os.environ["WINDIR"], r"System32\ntdll.dll") ): with PeFileAsDumpLoader( os.path.join(os.environ["WINDIR"], r"System32\ntdll.dll") ):
mod = pykd.module("ntdll") mod = pykd.module("ntdll")
print "\n" + str( mod ) print( "\n" + str( mod ))
self.assertNotEqual( 0, len( mod.enumSymbols("Zw*") ) ) self.assertNotEqual( 0, len( mod.enumSymbols("Zw*") ) )

13
test/scripts/pykdtest.py
View File

@ -71,20 +71,23 @@ def getTestSuite( singleName = "" ):
else: else:
return unittest.TestSuite( return unittest.TestSuite(
[ [
#unittest.TestLoader().loadTestsFromTestCase( StartProcessWithoutParamsTest ), unittest.TestLoader().loadTestsFromTestCase( StartProcessWithoutParamsTest ),
unittest.TestLoader().loadTestsFromName( singleName ), unittest.TestLoader().loadTestsFromName( singleName ),
#unittest.TestLoader().loadTestsFromTestCase( TerminateProcessTest ) unittest.TestLoader().loadTestsFromTestCase( TerminateProcessTest )
] ) ] )
if __name__ == "__main__": if __name__ == "__main__":
print "\nTesting PyKd ver.", pykd.__version__ print( "\nTesting PyKd ver. %s" % pykd.__version__ )
print "Directory:", os.path.dirname(pykd.__file__) print( "Directory: %s" % os.path.dirname(pykd.__file__) )
target.appPath = os.path.join( os.path.dirname(pykd.__file__), "targetapp.exe" ) target.appPath = os.path.join( os.path.dirname(pykd.__file__), "targetapp.exe" )
target.moduleName = os.path.splitext(os.path.basename(target.appPath))[0] target.moduleName = os.path.splitext(os.path.basename(target.appPath))[0]
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run( getTestSuite() ) unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run( getTestSuite() )
#unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run( getTestSuite("typeinfo.TypeInfoTest.testCompareWihNone") )
raw_input("Press <ENTER>...") try: input = raw_input
except NameError: pass
input("Press <ENTER>...")

5
test/scripts/stacktest.py
View File

@ -31,11 +31,10 @@ class StackTest(unittest.TestCase):
frame0 = pykd.getFrame() frame0 = pykd.getFrame()
self.assertEqual( ["this", "a", "b"], [ name for name, param in frame0.getParams() ] ) self.assertEqual( ["this", "a", "b"], [ name for name, param in frame0.getParams() ] )
frame1 = pykd.getStack()[1] frame1 = pykd.getStack()[1]
self.assertEqual( ["a", "b", "c"], [ name for name, param in frame1.getParams() ] ) self.assertEqual( ["a", "b", "c"], [ name for name, param in frame1.getParams() ] )
self.assertEqual( 10, frame1.getParam("a").deref() ) self.assertEqual( 10, frame1.getParam("a") )
self.assertEqual( 10, frame1.params["a"].deref() ) self.assertEqual( 10, frame1.params["a"] )
frame2 = pykd.getStack()[2] frame2 = pykd.getStack()[2]
self.assertEqual( 10, frame2.params["a"] ) self.assertEqual( 10, frame2.params["a"] )

6
test/scripts/targetprocess.py
View File

@ -22,14 +22,14 @@ class ProcessTest(unittest.TestCase):
proc = pykd.targetProcess.getCurrent() proc = pykd.targetProcess.getCurrent()
threadNumber = proc.getNumberThreads() threadNumber = proc.getNumberThreads()
self.assertLess(0, threadNumber) self.assertLess(0, threadNumber)
for i in xrange(threadNumber): for i in range(threadNumber):
thread = proc.getThread(i) thread = proc.getThread(i)
self.assertNotEqual(0, thread.systemID ) self.assertNotEqual(0, thread.systemID )
self.assertNotEqual(0, thread.teb ) self.assertNotEqual(0, thread.teb )
def testEnumProcesses(self): def testEnumProcesses(self):
processNumber = pykd.targetProcess.getNumber() processNumber = pykd.targetProcess.getNumber()
for i in xrange(processNumber): for i in range(processNumber):
proc = pykd.targetProcess(i) proc = pykd.targetProcess(i)
self.assertNotEqual(0, proc.systemID) self.assertNotEqual(0, proc.systemID)
self.assertNotEqual(0, proc.peb) self.assertNotEqual(0, proc.peb)
@ -38,7 +38,7 @@ class ProcessTest(unittest.TestCase):
proc = pykd.targetProcess.getCurrent() proc = pykd.targetProcess.getCurrent()
threadNumber = proc.getNumberThreads() threadNumber = proc.getNumberThreads()
self.assertLess(0, threadNumber) self.assertLess(0, threadNumber)
for i in xrange(threadNumber): for i in range(threadNumber):
thread = proc.getThread(i) thread = proc.getThread(i)
thread.setCurrent() thread.setCurrent()

15
test/scripts/typedvar.py
View File

@ -354,3 +354,18 @@ class TypedVarTest( unittest.TestCase ):
self.assertEqual( 0xFFFFFFFF80000000, tv.getAddress() ) self.assertEqual( 0xFFFFFFFF80000000, tv.getAddress() )
self.assertEqual( 0xFFFFFFFF80000000, tv ) self.assertEqual( 0xFFFFFFFF80000000, tv )
def testCompare(self):
self.assertTrue( 10002000 == target.module.typedVar( "ulongVar" ) )
self.assertTrue( 10002001 != target.module.typedVar( "ulongVar" ) )
self.assertTrue( 10002001 > target.module.typedVar( "ulongVar" ) )
self.assertTrue( 10001999 < target.module.typedVar( "ulongVar" ) )
self.assertTrue( 10002001 >= target.module.typedVar( "ulongVar" ) )
self.assertTrue( 10001999 <= target.module.typedVar( "ulongVar" ) )
self.assertTrue( True if target.module.typedVar( "ulongVar" ) else False )
self.assertTrue( False if not target.module.typedVar( "ulongVar" ) else True )
def testCompareWihNone(self):
tv = target.module.typedVar( "structTest", target.module.g_structTest )
self.assertFalse(tv==None)
self.assertTrue(tv!=None)

3
test/scripts/typeinfo.py
View File

@ -325,3 +325,6 @@ class TypeInfoTest( unittest.TestCase ):
lst = target.module.enumTypes("NonExsistType") lst = target.module.enumTypes("NonExsistType")
self.assertEqual([],lst) self.assertEqual([],lst)
def testArrayOverflow(self):
self.assertRaises(pykd.TypeException, pykd.baseTypes.UInt8B.arrayOf, 0xFFFFFFFFFFFFFFFF)