zjgcjy/pykd
1
0
Fork 0
mirror of https://github.com/ivellioscolin/pykd.git synced 2025-04-20 03:23:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[0.3.x] updared: tests

Browse Source 
git-svn-id: https://pykd.svn.codeplex.com/svn@83833 9b283d60-5439-405e-af05-b73fd8c4d996
This commit is contained in:
SND\kernelnet_cp 2013-05-27 10:18:13 +00:00 committed by Mikhail I. Izmestev
parent c5b9a4ca93
commit 624d678245
5 changed files with 69 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
pykd/pymod.cpp
View File

@ -148,19 +148,19 @@ BOOST_PYTHON_MODULE( pykd )
python::class_<kdlib::DbgIn, boost::noncopyable>( "din", "din", python::no_init ) python::class_<kdlib::DbgIn, boost::noncopyable>( "din", "din", python::no_init )
.def( "readline", &kdlib::DbgIn::readline ); .def( "readline", &kdlib::DbgIn::readline );
// // system properties // system properties
// python::def( "ptrSize", &ptrSize, python::def( "ptrSize", &kdlib::ptrSize,
// "Return effective pointer size" ); "Return effective pointer size" );
// python::def( "is64bitSystem", &is64bitSystem, python::def( "is64bitSystem", &kdlib::is64bitSystem,
// "Check if target system has 64 address space" ); "Check if target system has 64 address space" );
// python::def( "pageSize", &getPageSize, python::def( "pageSize", &kdlib::getPageSize,
// "Get the page size for the currently executing processor context" ); "Get the page size for the currently executing processor context" );
// python::def( "systemUptime", &getSystemUptime, python::def( "systemUptime", &kdlib::getSystemUptime,
// "Return the number of seconds the computer has been running" ); "Return the number of seconds the computer has been running" );
// python::def( "currentTime", &getCurrentTime, python::def( "currentTime", &kdlib::getCurrentTime,
// "Return the number of seconds since the beginning of 1970" ); "Return the number of seconds since the beginning of 1970" );
// python::def("getSystemVersion", &getSystemVersion, //python::def("getSystemVersion", &getSystemVersion,
// "Return systemVersion"); // "Return systemVersion");
// Manage target memory access // Manage target memory access
python::def( "addr64", &kdlib::addr64, python::def( "addr64", &kdlib::addr64,
@ -249,8 +249,8 @@ BOOST_PYTHON_MODULE( pykd )
// "Find symbol by the target virtual memory offset" ) ); // "Find symbol by the target virtual memory offset" ) );
// python::def("findSymbolAndDisp", &pysupport::findSymbolAndDisp, // python::def("findSymbolAndDisp", &pysupport::findSymbolAndDisp,
// "Return tuple(symbol_name, displacement) by virtual address" ); // "Return tuple(symbol_name, displacement) by virtual address" );
// python::def( "sizeof", &TypeInfo::getSymbolSize, python::def( "sizeof", &kdlib::getSymbolSize,
// "Return a size of the type or variable" ); "Return a size of the type or variable" );
// python::def("typedVarList", &getTypedVarListByTypeName, // python::def("typedVarList", &getTypedVarListByTypeName,
// "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ); // "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" );
// python::def("typedVarList", &getTypedVarListByType, // python::def("typedVarList", &getTypedVarListByType,
@ -394,8 +394,8 @@ BOOST_PYTHON_MODULE( pykd )
"Return tuple(symbol_name, displacement) by virtual address" ) "Return tuple(symbol_name, displacement) by virtual address" )
.def("rva", &kdlib::Module::getSymbolRva, .def("rva", &kdlib::Module::getSymbolRva,
"Return rva of the symbol" ) "Return rva of the symbol" )
//.def("sizeof", &Module::getSymbolSize, .def("sizeof", &kdlib::Module::getSymbolSize,
// "Return a size of the type or variable" ) "Return a size of the type or variable" )
.def("type", &kdlib::Module::getTypeByName, .def("type", &kdlib::Module::getTypeByName,
"Return typeInfo class by type name" ) "Return typeInfo class by type name" )
//.def("getUdts", &Module::getUdts, //.def("getUdts", &Module::getUdts,
@ -460,8 +460,8 @@ BOOST_PYTHON_MODULE( pykd )
// "Return pointer to the type" ) // "Return pointer to the type" )
//.def( "arrayOf", &kdlib::TypeInfo::arrayOf, //.def( "arrayOf", &kdlib::TypeInfo::arrayOf,
// "Return array of the type" ) // "Return array of the type" )
//.def( "__str__", &TypeInfo::print, .def( "__str__", &TypeInfoAdapter::print,
// "Return typa as a printable string" ) "Return typa as a printable string" )
.def( "__getattr__", TypeInfoAdapter::getElementByName ) .def( "__getattr__", TypeInfoAdapter::getElementByName )
.def("__len__", &kdlib::TypeInfo::getElementCount ) .def("__len__", &kdlib::TypeInfo::getElementCount )
.def("__getitem__", TypeInfoAdapter::getElementByIndex ) .def("__getitem__", TypeInfoAdapter::getElementByIndex )
@ -488,7 +488,7 @@ BOOST_PYTHON_MODULE( pykd )
"Return typeInfo instance" )*/ "Return typeInfo instance" )*/
.def("__getattr__", TypedVarAdapter::getField, .def("__getattr__", TypedVarAdapter::getField,
"Return field of structure as an object attribute" ) "Return field of structure as an object attribute" )
//.def( "__str__", &kdlib::TypedVar::print ) .def( "__str__", &TypedVarAdapter::print )
.def("__len__", &kdlib::TypedVar::getElementCount ) .def("__len__", &kdlib::TypedVar::getElementCount )
.def("__getitem__", &TypedVarAdapter::getElementByIndex ) .def("__getitem__", &TypedVarAdapter::getElementByIndex )
//.def("__getitem__", &kdlib::TypedVar::getElementByIndexPtr ) //.def("__getitem__", &kdlib::TypedVar::getElementByIndexPtr )

4
pykd/typedvar.h
View File

@ -32,6 +32,10 @@ struct TypedVarAdapter {
return typedVar.getElement( index ); return typedVar.getElement( index );
} }
static std::wstring print( kdlib::TypedVar& typedVar ) {
return L"TYPEDVAR STR";
}
}; };
} // end namespace pykd } // end namespace pykd

4
pykd/typeinfo.h
View File

@ -30,6 +30,10 @@ struct TypeInfoAdapter : public kdlib::TypeInfo {
return typeInfo.getElement(index); return typeInfo.getElement(index);
} }
static std::wstring print( kdlib::TypeInfo &typeInfo ) {
return L"TYPEINFO STR";
}
}; };
} // end namespace pykd } // end namespace pykd

61
test/scripts/typedvar.py
View File

@ -22,23 +22,20 @@ class TypedVarTest( unittest.TestCase ):
tv = pykd.typedVar( target.moduleName + "!g_structTest" ) tv = pykd.typedVar( target.moduleName + "!g_structTest" )
def testBaseTypes(self): def testBaseTypes(self):
self.assertEqual( 1, target.module.typedVar( "g_ucharValue" ) ) self.assertEqual( 1, target.module.typedVar( "ucharVar" ) )
self.assertEqual( 2, target.module.typedVar( "g_ushortValue" ) ) self.assertEqual( 2, target.module.typedVar( "ushortVar" ) )
self.assertEqual( 4, target.module.typedVar( "g_ulongValue" ) ) self.assertEqual( 4, target.module.typedVar( "ulongVar" ) )
self.assertEqual( 8, target.module.typedVar( "g_ulonglongValue" ) ) self.assertEqual( 8, target.module.typedVar( "ulonglongVar" ) )
self.assertEqual( -1, target.module.typedVar( "g_charValue" ) ) self.assertEqual( -1, target.module.typedVar( "charVar" ) )
self.assertEqual( -2, target.module.typedVar( "g_shortValue" ) ) self.assertEqual( -2, target.module.typedVar( "shortVar" ) )
self.assertEqual( -4, target.module.typedVar( "g_longValue" ) ) self.assertEqual( -4, target.module.typedVar( "longVar" ) )
self.assertEqual( -8, target.module.typedVar( "g_longlongValue" ) ) self.assertEqual( -8, target.module.typedVar( "longlongVar" ) )
def testPtrTo(self): def testPtrTo(self):
tvBaseType = pykd.typedVar( pykd.typeInfo("UInt8B").ptrTo(), tvBaseType = pykd.typedVar( pykd.typeInfo("UInt8B").ptrTo(), target.module.offset("pbigValue") )
target.module.offset("g_pUlonglongValue") ) self.assertEqual( target.module.typedVar( "g_ulonglongValue" ), tvBaseType.deref() )
self.assertEqual( target.module.typedVar( "g_ulonglongValue" ),
tvBaseType.deref() )
tvDiaStruct = pykd.typedVar( target.module.type("structTest").ptrTo(), tvDiaStruct = pykd.typedVar( target.module.type("structTest").ptrTo(), target.module.offset("g_structTestPtr") )
target.module.offset("g_structTestPtr") )
self.assertEqual( 500, tvDiaStruct.deref().m_field1 ) self.assertEqual( 500, tvDiaStruct.deref().m_field1 )
customStructTest = pykd.typeBuilder().createStruct("customStructTest", 4) customStructTest = pykd.typeBuilder().createStruct("customStructTest", 4)
@ -77,7 +74,7 @@ class TypedVarTest( unittest.TestCase ):
self.assertEqual( pykd.sizeof("g_structTest"), tv1.sizeof() ) self.assertEqual( pykd.sizeof("g_structTest"), tv1.sizeof() )
self.assertEqual( pykd.sizeof("g_testArray"), tv2.sizeof() ) self.assertEqual( pykd.sizeof("g_testArray"), tv2.sizeof() )
self.assertEqual( pykd.sizeof("g_ucharValue"), 1 ) self.assertEqual( pykd.sizeof("ucharVar"), 1 )
def testByAddress( self ): def testByAddress( self ):
tv1 = target.module.typedVar( "structTest", target.module.g_structTest ) tv1 = target.module.typedVar( "structTest", target.module.g_structTest )
@ -126,11 +123,11 @@ class TypedVarTest( unittest.TestCase ):
# self.assertEqual( 2, tv.m_arrayField[-1] ) # self.assertEqual( 2, tv.m_arrayField[-1] )
def testGlobalVar(self): def testGlobalVar(self):
self.assertEqual( 4, target.module.typedVar( "g_ulongValue" ) ) self.assertEqual( 10002000, target.module.typedVar( "ulongVar" ) )
self.assertEqual( 0x80000000, target.module.typedVar( "ulongArray" )[3] ) self.assertEqual( 0x80000000, target.module.typedVar( "ulongArray" )[3] )
self.assertEqual( 0x8000000000000000, target.module.typedVar( "ulonglongArray" )[3] ) self.assertEqual( 0x8000000000000000, target.module.typedVar( "ulonglongArray" )[3] )
self.assertEqual( -100000, target.module.typedVar( "longArray" )[3]) self.assertEqual( 0x7FFFFFFF, target.module.typedVar( "longArray" )[3])
self.assertEqual( -10000000000, target.module.typedVar( "longlongArray" )[4]) self.assertEqual( -1, target.module.typedVar( "longlongArray" )[4])
self.assertEqual( target.module.g_structTest, target.module.typedVar( "g_structTestPtr" ) ) self.assertEqual( target.module.g_structTest, target.module.typedVar( "g_structTestPtr" ) )
def testContainingRecord(self): def testContainingRecord(self):
@ -200,12 +197,12 @@ class TypedVarTest( unittest.TestCase ):
self.assertEqual( tv1.m_field3, tv2[0][1] ) self.assertEqual( tv1.m_field3, tv2[0][1] )
def testEnum(self): def testEnum(self):
tv = target.module.typedVar("g_classChild") tv = target.module.typedVar("g_constEnumThree")
self.assertEqual( 3, tv.m_enumField ) self.assertEqual( 3, tv )
self.assertEqual( target.module.type("enumType").THREE, tv.m_enumField ) self.assertEqual( target.module.type("enumType").THREE, tv )
def testIndex(self): def testIndex(self):
ind = target.module.typedVar( "g_ucharValue" ) ind = target.module.typedVar( "ucharVar" )
self.assertEqual( 5, [0,5,10][ind] ) self.assertEqual( 5, [0,5,10][ind] )
self.assertTrue( ind in [0,1,2] ) self.assertTrue( ind in [0,1,2] )
@ -213,7 +210,7 @@ class TypedVarTest( unittest.TestCase ):
tv = target.module.typedVar( "g_structWithArray" ) tv = target.module.typedVar( "g_structWithArray" )
self.assertEqual( 2, tv.m_arrayField[ind] ) self.assertEqual( 2, tv.m_arrayField[ind] )
ind = target.module.typedVar( "g_ulongValue" ) ind = target.module.typedVar( "ulongValue" )
self.assertEqual( 4, ind ) self.assertEqual( 4, ind )
self.assertTrue( ind in { 1 : "1", 4 : "2" } ) self.assertTrue( ind in { 1 : "1", 4 : "2" } )
self.assertEqual( "2", { 1 : "1", 4 : "2" }[ind] ) self.assertEqual( "2", { 1 : "1", 4 : "2" }[ind] )
@ -228,7 +225,7 @@ class TypedVarTest( unittest.TestCase ):
try: try:
tv.m_field1.deref() tv.m_field1.deref()
self.assertTrue(False) self.assertTrue(False)
except pykd.BaseException: except pykd.TypeException:
pass pass
def testSkipDeref(self): def testSkipDeref(self):
@ -260,10 +257,10 @@ class TypedVarTest( unittest.TestCase ):
self.assertTrue( tv1 ) self.assertTrue( tv1 )
def testPrint(self): def testPrint(self):
self.assertTrue( str(target.module.typedVar( "g_ucharValue" ) ) ) self.assertTrue( str(target.module.typedVar( "ucharVar" ) ) )
self.assertTrue( str(target.module.typedVar( "g_ushortValue" ) ) ) self.assertTrue( str(target.module.typedVar( "ushortVar" ) ) )
self.assertTrue( str(target.module.typedVar( "g_ulongValue" ) ) ) self.assertTrue( str(target.module.typedVar( "ulongVar" ) ) )
self.assertTrue( str(target.module.typedVar( "g_ulonglongValue" ) ) ) self.assertTrue( str(target.module.typedVar( "ulonglongVar" ) ) )
self.assertTrue( str(target.module.typedVar( "g_structWithBits" ) ) ) self.assertTrue( str(target.module.typedVar( "g_structWithBits" ) ) )
self.assertTrue( str(target.module.typedVar( "g_structTest" ) ) ) self.assertTrue( str(target.module.typedVar( "g_structTest" ) ) )
self.assertTrue( str(target.module.typedVar( "g_structTest1" ) ) ) self.assertTrue( str(target.module.typedVar( "g_structTest1" ) ) )
@ -319,7 +316,7 @@ class TypedVarTest( unittest.TestCase ):
entry = entry.deref().Flink entry = entry.deref().Flink
def testWrongArgs(self): def testWrongArgs(self):
self.assertRaises( pykd.BaseException, pykd.typedVar, None, 0 ) self.assertRaises( pykd.TypeException, pykd.typedVar, None, 0 )
self.assertRaises( pykd.BaseException, pykd.typedVarList, target.module.g_listHead1, None, "next" ) self.assertRaises( pykd.TypeException, pykd.typedVarList, target.module.g_listHead1, None, "next" )
self.assertRaises( pykd.BaseException, pykd.typedVarArray, target.module.g_testArray, None, 2 ) self.assertRaises( pykd.TypeException, pykd.typedVarArray, target.module.g_testArray, None, 2 )
self.assertRaises( pykd.BaseException, pykd.containingRecord, target.module.offset( "g_structTest" ), None, "m_field2" ) self.assertRaises( pykd.TypeException, pykd.containingRecord, target.module.offset( "g_structTest" ), None, "m_field2" )

21
test/scripts/typeinfo.py
View File

@ -107,9 +107,12 @@ class TypeInfoTest( unittest.TestCase ):
self.assertEqual( 12, ti1.fieldOffset("m_field2") ) self.assertEqual( 12, ti1.fieldOffset("m_field2") )
self.assertEqual( 14, ti1.fieldOffset("m_field3") ) self.assertEqual( 14, ti1.fieldOffset("m_field3") )
ti2 = target.module.type( "struct2" ) ti2 = target.module.type( "unionTest" )
self.assertTrue( ti2.fieldOffset("m_union") >= ti2.m_struct.size() ) self.assertEqual( 0, ti2.fieldOffset("m_value") )
self.assertEqual( 0, ti2.m_union.fieldOffset("m_value") ) self.assertEqual( 0, ti2.fieldOffset("m_structValue") )
ti3 = target.module.type( "structWithNested" )
self.assertEqual( ti3.fieldOffset( "m_unnameStruct"), ti3.fieldOffset( "m_unnameStruct.m_field2" ) )
def testSize( self ): def testSize( self ):
ti1 = target.module.type( "structTest" ) ti1 = target.module.type( "structTest" )
@ -165,19 +168,19 @@ class TypeInfoTest( unittest.TestCase ):
self.assertRaises( pykd.BaseException, ti.deref ); self.assertRaises( pykd.BaseException, ti.deref );
def testNestedStruct( self ): def testNestedStruct( self ):
ti = target.module.type("StructWithNested") ti = target.module.type("structWithNested")
self.assertTrue( hasattr( ti, "m_field" ) ) self.assertTrue( hasattr( ti, "m_field" ) )
self.assertTrue( hasattr( ti, "m_field2" ) ) self.assertTrue( hasattr( ti, "m_field2" ) )
self.assertFalse( hasattr( ti, "m_nestedFiled" ) ) self.assertFalse( hasattr( ti, "m_nestedFiled" ) )
ti = target.module.type("StructWithNested::Nested") ti = target.module.type("structWithNested::Nested")
self.assertTrue( hasattr( ti, "m_nestedFiled" ) ) self.assertTrue( hasattr( ti, "m_nestedFiled" ) )
def testPrint(self): def testPrint(self):
self.assertTrue( str(target.module.type( "g_ucharValue" ) ) ) self.assertTrue( str(target.module.type( "ucharVar" ) ) )
self.assertTrue( str(target.module.type( "g_ushortValue" ) ) ) self.assertTrue( str(target.module.type( "ushortVar" ) ) )
self.assertTrue( str(target.module.type( "g_ulongValue" ) ) ) self.assertTrue( str(target.module.type( "ulongVar" ) ) )
self.assertTrue( str(target.module.type( "g_ulonglongValue" ) ) ) self.assertTrue( str(target.module.type( "ulonglongVar" ) ) )
self.assertTrue( str(target.module.type( "g_structWithBits" ) ) ) self.assertTrue( str(target.module.type( "g_structWithBits" ) ) )
self.assertTrue( str(target.module.type( "g_structTest" ) ) ) self.assertTrue( str(target.module.type( "g_structTest" ) ) )
self.assertTrue( str(target.module.type( "g_structTest1" ) ) ) self.assertTrue( str(target.module.type( "g_structTest1" ) ) )