From 624d67824570ba7b55cec7c9bf0b13ede38b2dd8 Mon Sep 17 00:00:00 2001 From: "SND\\kernelnet_cp" Date: Mon, 27 May 2013 10:18:13 +0000 Subject: [PATCH] [0.3.x] updared: tests git-svn-id: https://pykd.svn.codeplex.com/svn@83833 9b283d60-5439-405e-af05-b73fd8c4d996 --- pykd/pymod.cpp | 40 +++++++++++++------------- pykd/typedvar.h | 4 +++ pykd/typeinfo.h | 4 +++ test/scripts/typedvar.py | 61 +++++++++++++++++++--------------------- test/scripts/typeinfo.py | 21 ++++++++------ 5 files changed, 69 insertions(+), 61 deletions(-) diff --git a/pykd/pymod.cpp b/pykd/pymod.cpp index 025390e..6f518f6 100644 --- a/pykd/pymod.cpp +++ b/pykd/pymod.cpp @@ -148,19 +148,19 @@ BOOST_PYTHON_MODULE( pykd ) python::class_( "din", "din", python::no_init ) .def( "readline", &kdlib::DbgIn::readline ); - // // system properties - // python::def( "ptrSize", &ptrSize, - // "Return effective pointer size" ); - // python::def( "is64bitSystem", &is64bitSystem, - // "Check if target system has 64 address space" ); - // python::def( "pageSize", &getPageSize, - // "Get the page size for the currently executing processor context" ); - // python::def( "systemUptime", &getSystemUptime, - // "Return the number of seconds the computer has been running" ); - // python::def( "currentTime", &getCurrentTime, - // "Return the number of seconds since the beginning of 1970" ); - // python::def("getSystemVersion", &getSystemVersion, - // "Return systemVersion"); + // system properties + python::def( "ptrSize", &kdlib::ptrSize, + "Return effective pointer size" ); + python::def( "is64bitSystem", &kdlib::is64bitSystem, + "Check if target system has 64 address space" ); + python::def( "pageSize", &kdlib::getPageSize, + "Get the page size for the currently executing processor context" ); + python::def( "systemUptime", &kdlib::getSystemUptime, + "Return the number of seconds the computer has been running" ); + python::def( "currentTime", &kdlib::getCurrentTime, + "Return the number of seconds since the beginning of 1970" ); + //python::def("getSystemVersion", &getSystemVersion, + // "Return systemVersion"); // Manage target memory access python::def( "addr64", &kdlib::addr64, @@ -249,8 +249,8 @@ BOOST_PYTHON_MODULE( pykd ) // "Find symbol by the target virtual memory offset" ) ); // python::def("findSymbolAndDisp", &pysupport::findSymbolAndDisp, // "Return tuple(symbol_name, displacement) by virtual address" ); - // python::def( "sizeof", &TypeInfo::getSymbolSize, - // "Return a size of the type or variable" ); + python::def( "sizeof", &kdlib::getSymbolSize, + "Return a size of the type or variable" ); // 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" ); // python::def("typedVarList", &getTypedVarListByType, @@ -394,8 +394,8 @@ BOOST_PYTHON_MODULE( pykd ) "Return tuple(symbol_name, displacement) by virtual address" ) .def("rva", &kdlib::Module::getSymbolRva, "Return rva of the symbol" ) - //.def("sizeof", &Module::getSymbolSize, - // "Return a size of the type or variable" ) + .def("sizeof", &kdlib::Module::getSymbolSize, + "Return a size of the type or variable" ) .def("type", &kdlib::Module::getTypeByName, "Return typeInfo class by type name" ) //.def("getUdts", &Module::getUdts, @@ -460,8 +460,8 @@ BOOST_PYTHON_MODULE( pykd ) // "Return pointer to the type" ) //.def( "arrayOf", &kdlib::TypeInfo::arrayOf, // "Return array of the type" ) - //.def( "__str__", &TypeInfo::print, - // "Return typa as a printable string" ) + .def( "__str__", &TypeInfoAdapter::print, + "Return typa as a printable string" ) .def( "__getattr__", TypeInfoAdapter::getElementByName ) .def("__len__", &kdlib::TypeInfo::getElementCount ) .def("__getitem__", TypeInfoAdapter::getElementByIndex ) @@ -488,7 +488,7 @@ BOOST_PYTHON_MODULE( pykd ) "Return typeInfo instance" )*/ .def("__getattr__", TypedVarAdapter::getField, "Return field of structure as an object attribute" ) - //.def( "__str__", &kdlib::TypedVar::print ) + .def( "__str__", &TypedVarAdapter::print ) .def("__len__", &kdlib::TypedVar::getElementCount ) .def("__getitem__", &TypedVarAdapter::getElementByIndex ) //.def("__getitem__", &kdlib::TypedVar::getElementByIndexPtr ) diff --git a/pykd/typedvar.h b/pykd/typedvar.h index e95e334..4f90542 100644 --- a/pykd/typedvar.h +++ b/pykd/typedvar.h @@ -32,6 +32,10 @@ struct TypedVarAdapter { return typedVar.getElement( index ); } + static std::wstring print( kdlib::TypedVar& typedVar ) { + return L"TYPEDVAR STR"; + } + }; } // end namespace pykd diff --git a/pykd/typeinfo.h b/pykd/typeinfo.h index 93b8ac2..e5b6c08 100644 --- a/pykd/typeinfo.h +++ b/pykd/typeinfo.h @@ -30,6 +30,10 @@ struct TypeInfoAdapter : public kdlib::TypeInfo { return typeInfo.getElement(index); } + static std::wstring print( kdlib::TypeInfo &typeInfo ) { + return L"TYPEINFO STR"; + } + }; } // end namespace pykd diff --git a/test/scripts/typedvar.py b/test/scripts/typedvar.py index 9f07f8e..ae7ae1d 100644 --- a/test/scripts/typedvar.py +++ b/test/scripts/typedvar.py @@ -22,23 +22,20 @@ class TypedVarTest( unittest.TestCase ): tv = pykd.typedVar( target.moduleName + "!g_structTest" ) def testBaseTypes(self): - self.assertEqual( 1, target.module.typedVar( "g_ucharValue" ) ) - self.assertEqual( 2, target.module.typedVar( "g_ushortValue" ) ) - self.assertEqual( 4, target.module.typedVar( "g_ulongValue" ) ) - self.assertEqual( 8, target.module.typedVar( "g_ulonglongValue" ) ) - self.assertEqual( -1, target.module.typedVar( "g_charValue" ) ) - self.assertEqual( -2, target.module.typedVar( "g_shortValue" ) ) - self.assertEqual( -4, target.module.typedVar( "g_longValue" ) ) - self.assertEqual( -8, target.module.typedVar( "g_longlongValue" ) ) + self.assertEqual( 1, target.module.typedVar( "ucharVar" ) ) + self.assertEqual( 2, target.module.typedVar( "ushortVar" ) ) + self.assertEqual( 4, target.module.typedVar( "ulongVar" ) ) + self.assertEqual( 8, target.module.typedVar( "ulonglongVar" ) ) + self.assertEqual( -1, target.module.typedVar( "charVar" ) ) + self.assertEqual( -2, target.module.typedVar( "shortVar" ) ) + self.assertEqual( -4, target.module.typedVar( "longVar" ) ) + self.assertEqual( -8, target.module.typedVar( "longlongVar" ) ) def testPtrTo(self): - tvBaseType = pykd.typedVar( pykd.typeInfo("UInt8B").ptrTo(), - target.module.offset("g_pUlonglongValue") ) - self.assertEqual( target.module.typedVar( "g_ulonglongValue" ), - tvBaseType.deref() ) + tvBaseType = pykd.typedVar( pykd.typeInfo("UInt8B").ptrTo(), target.module.offset("pbigValue") ) + self.assertEqual( target.module.typedVar( "g_ulonglongValue" ), tvBaseType.deref() ) - tvDiaStruct = pykd.typedVar( target.module.type("structTest").ptrTo(), - target.module.offset("g_structTestPtr") ) + tvDiaStruct = pykd.typedVar( target.module.type("structTest").ptrTo(), target.module.offset("g_structTestPtr") ) self.assertEqual( 500, tvDiaStruct.deref().m_field1 ) 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_testArray"), tv2.sizeof() ) - self.assertEqual( pykd.sizeof("g_ucharValue"), 1 ) + self.assertEqual( pykd.sizeof("ucharVar"), 1 ) def testByAddress( self ): tv1 = target.module.typedVar( "structTest", target.module.g_structTest ) @@ -126,11 +123,11 @@ class TypedVarTest( unittest.TestCase ): # self.assertEqual( 2, tv.m_arrayField[-1] ) 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( 0x8000000000000000, target.module.typedVar( "ulonglongArray" )[3] ) - self.assertEqual( -100000, target.module.typedVar( "longArray" )[3]) - self.assertEqual( -10000000000, target.module.typedVar( "longlongArray" )[4]) + self.assertEqual( 0x7FFFFFFF, target.module.typedVar( "longArray" )[3]) + self.assertEqual( -1, target.module.typedVar( "longlongArray" )[4]) self.assertEqual( target.module.g_structTest, target.module.typedVar( "g_structTestPtr" ) ) def testContainingRecord(self): @@ -200,12 +197,12 @@ class TypedVarTest( unittest.TestCase ): self.assertEqual( tv1.m_field3, tv2[0][1] ) def testEnum(self): - tv = target.module.typedVar("g_classChild") - self.assertEqual( 3, tv.m_enumField ) - self.assertEqual( target.module.type("enumType").THREE, tv.m_enumField ) + tv = target.module.typedVar("g_constEnumThree") + self.assertEqual( 3, tv ) + self.assertEqual( target.module.type("enumType").THREE, tv ) def testIndex(self): - ind = target.module.typedVar( "g_ucharValue" ) + ind = target.module.typedVar( "ucharVar" ) self.assertEqual( 5, [0,5,10][ind] ) self.assertTrue( ind in [0,1,2] ) @@ -213,7 +210,7 @@ class TypedVarTest( unittest.TestCase ): tv = target.module.typedVar( "g_structWithArray" ) self.assertEqual( 2, tv.m_arrayField[ind] ) - ind = target.module.typedVar( "g_ulongValue" ) + ind = target.module.typedVar( "ulongValue" ) self.assertEqual( 4, ind ) self.assertTrue( ind in { 1 : "1", 4 : "2" } ) self.assertEqual( "2", { 1 : "1", 4 : "2" }[ind] ) @@ -228,7 +225,7 @@ class TypedVarTest( unittest.TestCase ): try: tv.m_field1.deref() self.assertTrue(False) - except pykd.BaseException: + except pykd.TypeException: pass def testSkipDeref(self): @@ -260,10 +257,10 @@ class TypedVarTest( unittest.TestCase ): self.assertTrue( tv1 ) def testPrint(self): - self.assertTrue( str(target.module.typedVar( "g_ucharValue" ) ) ) - self.assertTrue( str(target.module.typedVar( "g_ushortValue" ) ) ) - self.assertTrue( str(target.module.typedVar( "g_ulongValue" ) ) ) - self.assertTrue( str(target.module.typedVar( "g_ulonglongValue" ) ) ) + self.assertTrue( str(target.module.typedVar( "ucharVar" ) ) ) + self.assertTrue( str(target.module.typedVar( "ushortVar" ) ) ) + self.assertTrue( str(target.module.typedVar( "ulongVar" ) ) ) + self.assertTrue( str(target.module.typedVar( "ulonglongVar" ) ) ) self.assertTrue( str(target.module.typedVar( "g_structWithBits" ) ) ) self.assertTrue( str(target.module.typedVar( "g_structTest" ) ) ) self.assertTrue( str(target.module.typedVar( "g_structTest1" ) ) ) @@ -319,7 +316,7 @@ class TypedVarTest( unittest.TestCase ): entry = entry.deref().Flink def testWrongArgs(self): - self.assertRaises( pykd.BaseException, pykd.typedVar, None, 0 ) - self.assertRaises( pykd.BaseException, pykd.typedVarList, target.module.g_listHead1, None, "next" ) - self.assertRaises( pykd.BaseException, 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.typedVar, None, 0 ) + self.assertRaises( pykd.TypeException, pykd.typedVarList, target.module.g_listHead1, None, "next" ) + self.assertRaises( pykd.TypeException, pykd.typedVarArray, target.module.g_testArray, None, 2 ) + self.assertRaises( pykd.TypeException, pykd.containingRecord, target.module.offset( "g_structTest" ), None, "m_field2" ) diff --git a/test/scripts/typeinfo.py b/test/scripts/typeinfo.py index 7b4cbf3..bf2670d 100644 --- a/test/scripts/typeinfo.py +++ b/test/scripts/typeinfo.py @@ -107,9 +107,12 @@ class TypeInfoTest( unittest.TestCase ): self.assertEqual( 12, ti1.fieldOffset("m_field2") ) self.assertEqual( 14, ti1.fieldOffset("m_field3") ) - ti2 = target.module.type( "struct2" ) - self.assertTrue( ti2.fieldOffset("m_union") >= ti2.m_struct.size() ) - self.assertEqual( 0, ti2.m_union.fieldOffset("m_value") ) + ti2 = target.module.type( "unionTest" ) + self.assertEqual( 0, ti2.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 ): ti1 = target.module.type( "structTest" ) @@ -165,19 +168,19 @@ class TypeInfoTest( unittest.TestCase ): self.assertRaises( pykd.BaseException, ti.deref ); def testNestedStruct( self ): - ti = target.module.type("StructWithNested") + ti = target.module.type("structWithNested") self.assertTrue( hasattr( ti, "m_field" ) ) self.assertTrue( hasattr( ti, "m_field2" ) ) self.assertFalse( hasattr( ti, "m_nestedFiled" ) ) - ti = target.module.type("StructWithNested::Nested") + ti = target.module.type("structWithNested::Nested") self.assertTrue( hasattr( ti, "m_nestedFiled" ) ) def testPrint(self): - self.assertTrue( str(target.module.type( "g_ucharValue" ) ) ) - self.assertTrue( str(target.module.type( "g_ushortValue" ) ) ) - self.assertTrue( str(target.module.type( "g_ulongValue" ) ) ) - self.assertTrue( str(target.module.type( "g_ulonglongValue" ) ) ) + self.assertTrue( str(target.module.type( "ucharVar" ) ) ) + self.assertTrue( str(target.module.type( "ushortVar" ) ) ) + self.assertTrue( str(target.module.type( "ulongVar" ) ) ) + self.assertTrue( str(target.module.type( "ulonglongVar" ) ) ) self.assertTrue( str(target.module.type( "g_structWithBits" ) ) ) self.assertTrue( str(target.module.type( "g_structTest" ) ) ) self.assertTrue( str(target.module.type( "g_structTest1" ) ) )