From 238ead92274ab42dc8d543f303cb1e3121811878 Mon Sep 17 00:00:00 2001 From: "SND\\kernelnet_cp" Date: Fri, 17 May 2013 07:47:59 +0000 Subject: [PATCH] [0.3.x] added numVariant class git-svn-id: https://pykd.svn.codeplex.com/svn@83703 9b283d60-5439-405e-af05-b73fd8c4d996 --- pykd/pykd.vcxproj | 1 + pykd/pykd.vcxproj.filters | 3 + pykd/pymod.cpp | 92 ++++++++-------- pykd/variant.h | 206 ++++++++++++++++++++++++++++++++++ test/scripts/intbase.py | 226 +++++++++++++++++++------------------- test/scripts/pykdtest.py | 11 +- 6 files changed, 377 insertions(+), 162 deletions(-) create mode 100644 pykd/variant.h diff --git a/pykd/pykd.vcxproj b/pykd/pykd.vcxproj index 58b0b19..508fce4 100644 --- a/pykd/pykd.vcxproj +++ b/pykd/pykd.vcxproj @@ -125,6 +125,7 @@ + diff --git a/pykd/pykd.vcxproj.filters b/pykd/pykd.vcxproj.filters index 5147b86..5780c98 100644 --- a/pykd/pykd.vcxproj.filters +++ b/pykd/pykd.vcxproj.filters @@ -24,6 +24,9 @@ Header Files + + Header Files + diff --git a/pykd/pymod.cpp b/pykd/pymod.cpp index d3b7dbc..f85e8c8 100644 --- a/pykd/pymod.cpp +++ b/pykd/pymod.cpp @@ -6,6 +6,10 @@ using namespace kdlib; +#include "variant.h" + +using namespace pykd; + // //#include "pykdver.h" @@ -101,8 +105,8 @@ BOOST_PYTHON_MODULE( pykd ) "Start process for debugging" ); python::def( "attachProcess", &attachProcess, "Attach debugger to a exsisting process" ); - //python::def( "detachProcess", &detachProcess, detachProcess_( boost::python::args( "pid" ), - // "Stop process debugging") ); +// python::def( "detachProcess", &detachProcess, detachProcess_( boost::python::args( "pid" ), +// "Stop process debugging") ); python::def( "killProcess", &terminateProcess, "Stop debugging and terminate current process" ); python::def( "loadDump", &loadDump, @@ -321,49 +325,49 @@ BOOST_PYTHON_MODULE( pykd ) // python::def( "setSymbolPath", &setSymbolPath, "Set current symbol path"); // python::def( "appendSymbolPath", &appendSymbolPath, "Append current symbol path"); - // python::class_( "intBase", "intBase", python::no_init ) - // .def( python::init() ) - // .def( "__eq__", &intBase::eq ) - // .def( "__ne__", &intBase::ne) - // .def( "__lt__", &intBase::lt) - // .def( "__gt__", &intBase::gt ) - // .def( "__le__", &intBase::le ) - // .def( "__ge__", &intBase::ge ) - // .def( "__add__", &intBase::add ) - // .def( "__radd__", &intBase::add ) - // .def( "__sub__", &intBase::sub ) - // .def( "__rsub__", &intBase::rsub ) - // .def( "__mul__", &intBase::mul ) - // .def( "__rmul__", &intBase::mul ) - // .def( "__div__", &intBase::div ) - // .def( "__rdiv__", &intBase::rdiv ) - // .def( "__mod__", &intBase::mod ) - // .def( "__rmod__", &intBase::rmod ) - // .def( "__rshift__", &intBase::rshift ) - // .def( "__rrshift__", &intBase::rrshift ) - // .def( "__lshift__", &intBase::lshift ) - // .def( "__rlshift__", &intBase::rlshift ) - // .def( "__and__", &intBase::and ) - // .def( "__rand__", &intBase::and ) - // .def( "__or__", &intBase::or ) - // .def( "__ror__", &intBase::or ) - // .def( "__xor__", &intBase::xor ) - // .def( "__rxor__", &intBase::xor ) - // .def( "__neg__", &intBase::neg ) - // .def( "__pos__", &intBase::pos ) - // .def( "__invert__", &intBase::invert ) - // .def( "__nonzero__", &intBase::nonzero ) - // .def( "__str__", &intBase::str ) - // .def( "__hex__", &intBase::hex ) - // .def( "__long__", &intBase::long_ ) - // .def( "__int__", &intBase::int_ ) - // .def( "__index__", &intBase::long_ ) - // .def( "__hash__", &intBase::long_ ); +python::class_( "numVariant", "numVariant", python::no_init ) + .def( python::init() ) + .def( "__eq__", &pykd::NumVariant::eq ) + .def( "__ne__", &pykd::NumVariant::ne) + .def( "__lt__", &pykd::NumVariant::lt) + .def( "__gt__", &pykd::NumVariant::gt ) + .def( "__le__", &pykd::NumVariant::le ) + .def( "__ge__", &pykd::NumVariant::ge ) + .def( "__add__", &pykd::NumVariant::add ) + .def( "__radd__", &pykd::NumVariant::add ) + .def( "__sub__", &pykd::NumVariant::sub ) + .def( "__rsub__", &pykd::NumVariant::rsub ) + .def( "__mul__", &pykd::NumVariant::mul ) + .def( "__rmul__", &pykd::NumVariant::mul ) + .def( "__div__", &pykd::NumVariant::div ) + .def( "__rdiv__", &pykd::NumVariant::rdiv ) + .def( "__mod__", &pykd::NumVariant::mod ) + .def( "__rmod__", &pykd::NumVariant::rmod ) + .def( "__rshift__", &pykd::NumVariant::rshift ) + .def( "__rrshift__", &pykd::NumVariant::rrshift ) + .def( "__lshift__", &pykd::NumVariant::lshift ) + .def( "__rlshift__", &pykd::NumVariant::rlshift ) + .def( "__and__", &pykd::NumVariant::and ) + .def( "__rand__", &pykd::NumVariant::and ) + .def( "__or__", &pykd::NumVariant::or ) + .def( "__ror__", &pykd::NumVariant::or ) + .def( "__xor__", &pykd::NumVariant::xor ) + .def( "__rxor__", &pykd::NumVariant::xor ) + .def( "__neg__", &pykd::NumVariant::neg ) + .def( "__pos__", &pykd::NumVariant::pos ) + .def( "__invert__", &pykd::NumVariant::invert ) + .def( "__nonzero__", &pykd::NumVariant::nonzero ) + //.def( "__str__", &pykd::NumVariant::str ) + //.def( "__hex__", &pykd::NumVariant::hex ) + .def( "__long__", &pykd::NumVariant::long_ ) + .def( "__int__", &pykd::NumVariant::int_ ) + .def( "__index__", &pykd::NumVariant::long_ ) + .def( "__hash__", &pykd::NumVariant::long_ ); - // python::implicitly_convertible(); - // python::implicitly_convertible(); - // python::implicitly_convertible(); - // python::implicitly_convertible(); + python::implicitly_convertible(); + python::implicitly_convertible(); + python::implicitly_convertible(); + python::implicitly_convertible(); // python::class_ >("module", "Class representing executable module", python::no_init ) // .def("__init__", python::make_constructor(Module::loadModuleByName) ) diff --git a/pykd/variant.h b/pykd/variant.h new file mode 100644 index 0000000..eaeaa72 --- /dev/null +++ b/pykd/variant.h @@ -0,0 +1,206 @@ +#pragma once + +#include "kdlib/variant.h" + +namespace pykd { + +class NumVariant : public kdlib::NumVariant +{ + +public: + + NumVariant( const python::object &obj ) + { + if ( PyBool_Check( obj.ptr() ) ) + { + if ( obj.ptr() == Py_True ) + setBool(true); + else + setBool(false); + return; + } + + + if ( PyInt_CheckExact( obj.ptr() ) ) + { + setLong( PyLong_AsLong( obj.ptr() ) ); + return; + } + + if ( _PyLong_Sign( obj.ptr() ) >= 0 ) + setULongLong( PyLong_AsUnsignedLongLong( obj.ptr() ) ); + else + setLongLong( PyLong_AsLongLong( obj.ptr() ) ); + } + + python::object convertToPython() + { + if ( isChar() ) + return python::object( asInt() ); + + if ( isUChar() ) + return python::object( asInt() ); + + if (isShort() ) + return python::object( asInt() ); + + if ( isUShort() ) + return python::object( asInt() ); + + if ( isLong() ) + return python::object( asLong() ); + + if ( isULong() ) + return python::object( asULong() ); + + if ( isLongLong() ) + return python::object( asLongLong() ); + + if ( isULongLong() ) + return python::object( asULongLong() ); + + if ( isInt() ) + return python::object( asInt() ); + + if ( isUInt() ) + return python::object( asUInt() ); + + if ( isFloat() ) + return python::object( asFloat() ); + + if ( isDouble() ) + return python::object( asDouble() ); + } + + +public: + + python::object eq( python::object& obj ) { + return convertToPython() == obj; + } + + python::object ne( python::object& obj ) { + return convertToPython() != obj; + } + + python::object lt( python::object& obj ) { + return convertToPython() < obj; + } + + python::object gt( python::object& obj ) { + return convertToPython() > obj; + } + + python::object le( python::object& obj ) { + return convertToPython() <= obj; + } + + python::object ge( python::object& obj ) { + return convertToPython() >= obj; + } + + python::object add( python::object& obj ) { + return convertToPython() + obj; + } + + python::object sub( python::object& obj ) { + return convertToPython() - obj; + } + + python::object rsub( python::object& obj ) { + return obj - convertToPython(); + } + + python::object mul( python::object& obj ) { + return convertToPython() * obj; + } + + python::object div( python::object& obj ) { + return convertToPython() / obj; + } + + python::object rdiv( python::object& obj ) { + return obj / convertToPython(); + } + + python::object mod( python::object& obj ) { + return convertToPython() % obj; + } + + python::object rmod( python::object& obj ) { + return obj % convertToPython(); + } + + python::object rshift( python::object& obj ) { + return convertToPython() >> obj; + } + + python::object rrshift( python::object& obj ) { + return obj >> convertToPython(); + } + + python::object lshift( python::object& obj ) { + return convertToPython() << obj; + } + + python::object rlshift( python::object& obj ) { + return obj << convertToPython(); + } + + python::object and( python::object& obj ) { + return convertToPython() & obj; + } + + python::object or( python::object& obj ) { + return convertToPython() | obj; + } + + python::object xor( python::object& obj ) { + return convertToPython() ^ obj; + } + + python::object neg() { + return 0 - convertToPython(); + } + + python::object pos() { + return 0 + convertToPython(); + } + + python::object invert() { + return convertToPython() ^ convertToPython(); + } + + python::object nonzero() { + return convertToPython() != 0; + } + +public: + + python::object long_() { + return python::long_( asLongLong() ); + } + + python::object int_() { + return python::long_( asLongLong() ); + } + + operator unsigned long long() { + return asULongLong(); + } + + operator unsigned long() { + return asULong(); + } + + operator long long() { + return asLongLong(); + } + + operator long() { + return asLong(); + } + +}; + +} // end pykf namespace diff --git a/test/scripts/intbase.py b/test/scripts/intbase.py index 557fc9e..77386c8 100644 --- a/test/scripts/intbase.py +++ b/test/scripts/intbase.py @@ -1,173 +1,173 @@ import unittest import target -from pykd import intBase +from pykd import numVariant class IntBaseTest( unittest.TestCase ): def testCtor( self ): - a = intBase(0xFF) - a = intBase(0xFFFF) - a = intBase(0xFFFFFFFF) - a = intBase(0x8000000000000000) - a = intBase(0xFFFFFFFFFFFFFFFF) - a = intBase(-20) - a = intBase(-2000) - a = intBase(-200000) - a = intBase(-20000000000) - a = intBase(-0xFFFFFFFFFFFFFFFF ) - a = intBase( True ) + a = numVariant(0xFF) + a = numVariant(0xFFFF) + a = numVariant(0xFFFFFFFF) + a = numVariant(0x8000000000000000) + a = numVariant(0xFFFFFFFFFFFFFFFF) + a = numVariant(-20) + a = numVariant(-2000) + a = numVariant(-200000) + a = numVariant(-20000000000) + a = numVariant(-0xFFFFFFFFFFFFFFFF ) + a = numVariant( True ) def testEq( self ): - self.assertTrue( 0xFF == intBase(0xFF) and intBase(0xFF) == 0xFF ) - self.assertTrue( 0xFFFF == intBase(0xFFFF) and 0xFFFF == intBase(0xFFFF) ) - self.assertTrue( 0xFFFFFFFF == intBase(0xFFFFFFFF) and intBase(0xFFFFFFFF) == 0xFFFFFFFF ) - self.assertTrue( 0x8000000000000000 == intBase(0x8000000000000000) ) - self.assertTrue( 0xFFFFFFFFFFFFFFFF == intBase(0xFFFFFFFFFFFFFFFF) ) - self.assertTrue( -20 == intBase(-20) ) - self.assertTrue( -2000 == intBase(-2000) ) - self.assertTrue( -0x7FFFFFFF == intBase(-0x7FFFFFFF) ) - self.assertTrue( -20000000000 == intBase(-20000000000) ) - self.assertTrue( -0x8000000000000000 == intBase(-0x8000000000000000) ) - self.assertTrue( intBase(0x20L) == intBase(0x20) ) - self.assertTrue( True == intBase(True) ) - self.assertTrue( False == intBase(0) ) - self.assertTrue( True == intBase(1) ) - self.assertTrue( intBase(1) == intBase(1) ) + self.assertTrue( 0xFF == numVariant(0xFF) and numVariant(0xFF) == 0xFF ) + self.assertTrue( 0xFFFF == numVariant(0xFFFF) and 0xFFFF == numVariant(0xFFFF) ) + self.assertTrue( 0xFFFFFFFF == numVariant(0xFFFFFFFF) and numVariant(0xFFFFFFFF) == 0xFFFFFFFF ) + self.assertTrue( 0x8000000000000000 == numVariant(0x8000000000000000) ) + self.assertTrue( 0xFFFFFFFFFFFFFFFF == numVariant(0xFFFFFFFFFFFFFFFF) ) + self.assertTrue( -20 == numVariant(-20) ) + self.assertTrue( -2000 == numVariant(-2000) ) + self.assertTrue( -0x7FFFFFFF == numVariant(-0x7FFFFFFF) ) + self.assertTrue( -20000000000 == numVariant(-20000000000) ) + self.assertTrue( -0x8000000000000000 == numVariant(-0x8000000000000000) ) + self.assertTrue( numVariant(0x20L) == numVariant(0x20) ) + self.assertTrue( True == numVariant(True) ) + self.assertTrue( False == numVariant(0) ) + self.assertTrue( True == numVariant(1) ) + self.assertTrue( numVariant(1) == numVariant(1) ) def testNe( self ): - self.assertTrue( 0xFE != intBase(0xFF) ) - self.assertTrue( 0xFF00 != intBase(0xFFFF) ) - self.assertTrue( 0xFFFFFF88 != intBase(0xFFFFFFFF) ) - self.assertTrue( 0x8000000000000000 - 1 != intBase(0x8000000000000000) ) - self.assertTrue( 0xFFFFFFFFFFFFFFFF - 1 != intBase(0xFFFFFFFFFFFFFFFF) ) - self.assertTrue( -20 + 1 != intBase(-20) ) - self.assertTrue( -2000 + 1 != intBase(-2000) ) - self.assertTrue( -20000000000 + 1 != intBase(-20000000000) ) - self.assertTrue( -0x8000000000000000 - 1 != intBase(-0x8000000000000000) ) - self.assertTrue( intBase(1) != intBase(2) ) + self.assertTrue( 0xFE != numVariant(0xFF) ) + self.assertTrue( 0xFF00 != numVariant(0xFFFF) ) + self.assertTrue( 0xFFFFFF88 != numVariant(0xFFFFFFFF) ) + self.assertTrue( 0x8000000000000000 - 1 != numVariant(0x8000000000000000) ) + self.assertTrue( 0xFFFFFFFFFFFFFFFF - 1 != numVariant(0xFFFFFFFFFFFFFFFF) ) + self.assertTrue( -20 + 1 != numVariant(-20) ) + self.assertTrue( -2000 + 1 != numVariant(-2000) ) + self.assertTrue( -20000000000 + 1 != numVariant(-20000000000) ) + self.assertTrue( -0x8000000000000000 - 1 != numVariant(-0x8000000000000000) ) + self.assertTrue( numVariant(1) != numVariant(2) ) def testLtGt( self ): - self.assertTrue( 0xFE < intBase(0xFF) and intBase(0xFE) < 0xFF ) - self.assertFalse( -99 < intBase(-100) and intBase(-99) < - 100 ) - self.assertTrue( 0xFFFFFFFFFFFFFFFE < intBase(0xFFFFFFFFFFFFFFFF) ) - self.assertFalse(0xFFFFFFFFFFFFFFFF < intBase(0xFFFFFFFFFFFFFFFE) ) - self.assertTrue( intBase(0xFFFFFFFFFFFFFFFE) < 0xFFFFFFFFFFFFFFFF ) - self.assertTrue( intBase(1) < intBase(2) ) + self.assertTrue( 0xFE < numVariant(0xFF) and numVariant(0xFE) < 0xFF ) + self.assertFalse( -99 < numVariant(-100) and numVariant(-99) < - 100 ) + self.assertTrue( 0xFFFFFFFFFFFFFFFE < numVariant(0xFFFFFFFFFFFFFFFF) ) + self.assertFalse(0xFFFFFFFFFFFFFFFF < numVariant(0xFFFFFFFFFFFFFFFE) ) + self.assertTrue( numVariant(0xFFFFFFFFFFFFFFFE) < 0xFFFFFFFFFFFFFFFF ) + self.assertTrue( numVariant(1) < numVariant(2) ) def testLeGe( self ): - self.assertTrue( 0xFE <= intBase(0xFF) and intBase(0xFE) <= 0xFF ) - self.assertTrue( 0xFF <= intBase(0xFF) ) - self.assertFalse( -99 <= intBase(-100) and intBase(-99) <= - 100 ) - self.assertTrue( 0xFFFFFFFFFFFFFFFE <= intBase(0xFFFFFFFFFFFFFFFF) ) - self.assertFalse(0xFFFFFFFFFFFFFFFF <= intBase(0xFFFFFFFFFFFFFFFE) ) - self.assertTrue( intBase(0xFFFFFFFFFFFFFFFF) <= 0xFFFFFFFFFFFFFFFF ) - self.assertFalse( intBase(1) >= intBase(2) ) + self.assertTrue( 0xFE <= numVariant(0xFF) and numVariant(0xFE) <= 0xFF ) + self.assertTrue( 0xFF <= numVariant(0xFF) ) + self.assertFalse( -99 <= numVariant(-100) and numVariant(-99) <= - 100 ) + self.assertTrue( 0xFFFFFFFFFFFFFFFE <= numVariant(0xFFFFFFFFFFFFFFFF) ) + self.assertFalse(0xFFFFFFFFFFFFFFFF <= numVariant(0xFFFFFFFFFFFFFFFE) ) + self.assertTrue( numVariant(0xFFFFFFFFFFFFFFFF) <= 0xFFFFFFFFFFFFFFFF ) + self.assertFalse( numVariant(1) >= numVariant(2) ) def testAdd( self ): - self.assertEqual( 10, intBase(5) + 5 ) - self.assertEqual( 10, 5 + intBase(5) ) + self.assertEqual( 10, numVariant(5) + 5 ) + self.assertEqual( 10, 5 + numVariant(5) ) a = 10 - a += intBase(10) + a += numVariant(10) self.assertEqual( 20, a ) - self.assertEqual( -20, intBase(-10) + (-10) ) - self.assertEqual( 10, intBase(-10) + 20 ) - self.assertEqual( 0x7fffffffffffffff + 1, intBase(0x7fffffffffffffff) + 1) - self.assertEqual( -0x8000000000000000 + 10, intBase(-0x8000000000000000) + 10 ) - self.assertEqual( 0, intBase(-0x8000000000000000) + 0x8000000000000000 ) - self.assertEqual( 5, intBase(3) + intBase(2) ) + self.assertEqual( -20, numVariant(-10) + (-10) ) + self.assertEqual( 10, numVariant(-10) + 20 ) + self.assertEqual( 0x7fffffffffffffff + 1, numVariant(0x7fffffffffffffff) + 1) + self.assertEqual( -0x8000000000000000 + 10, numVariant(-0x8000000000000000) + 10 ) + self.assertEqual( 0, numVariant(-0x8000000000000000) + 0x8000000000000000 ) + self.assertEqual( 5, numVariant(3) + numVariant(2) ) def testSub( self ): - self.assertEqual( 0, intBase(5) - 5 ) - self.assertEqual( 10, 15 - intBase(5) ) + self.assertEqual( 0, numVariant(5) - 5 ) + self.assertEqual( 10, 15 - numVariant(5) ) a = 10 - a -= intBase(5) + a -= numVariant(5) self.assertEqual( 5, a ) - self.assertEqual( -20, intBase(-10) -10 ) - self.assertEqual( -10, 10 - intBase(20) ) - self.assertEqual( -0xFFFFFFFF - 1, intBase(-0xFFFFFFFF) - 1 ) - self.assertEqual( 5, intBase(7) - intBase(2) ) + self.assertEqual( -20, numVariant(-10) -10 ) + self.assertEqual( -10, 10 - numVariant(20) ) + self.assertEqual( -0xFFFFFFFF - 1, numVariant(-0xFFFFFFFF) - 1 ) + self.assertEqual( 5, numVariant(7) - numVariant(2) ) def testMul( self ): - self.assertEqual( 4, intBase(2) * 2 ) - self.assertEqual( 4, 2 * intBase(2) ) - self.assertEqual( -4, 2 * intBase(-2) ) - self.assertEqual( 4, -2 * intBase(-2) ) - self.assertEqual( 0x7fffffffffffffff * 2, intBase(0x7fffffffffffffff) * 2) - self.assertEqual( 0x80000000*2, intBase(0x80000000)*2 ) - self.assertEqual( -0x80000000*2, 2 * intBase(-0x80000000)) - self.assertEqual( 14, intBase(7)*intBase(2) ) + self.assertEqual( 4, numVariant(2) * 2 ) + self.assertEqual( 4, 2 * numVariant(2) ) + self.assertEqual( -4, 2 * numVariant(-2) ) + self.assertEqual( 4, -2 * numVariant(-2) ) + self.assertEqual( 0x7fffffffffffffff * 2, numVariant(0x7fffffffffffffff) * 2) + self.assertEqual( 0x80000000*2, numVariant(0x80000000)*2 ) + self.assertEqual( -0x80000000*2, 2 * numVariant(-0x80000000)) + self.assertEqual( 14, numVariant(7)*numVariant(2) ) def testDiv( self ): - self.assertEqual( 1, intBase(2) / 2 ) - self.assertEqual( 2, 5 / intBase(2) ) - self.assertEqual( -1, 2 / intBase(-2) ) - self.assertEqual( 1, -2 / intBase(-2) ) - self.assertEqual( 3, intBase(7)/intBase(2) ) + self.assertEqual( 1, numVariant(2) / 2 ) + self.assertEqual( 2, 5 / numVariant(2) ) + self.assertEqual( -1, 2 / numVariant(-2) ) + self.assertEqual( 1, -2 / numVariant(-2) ) + self.assertEqual( 3, numVariant(7)/numVariant(2) ) try: - -2 / intBase(0) + -2 / numVariant(0) self.assertTrue( False ) except ZeroDivisionError: self.assertTrue( True ) try: - intBase(2)/0 + numVariant(2)/0 self.assertTrue( False ) except ZeroDivisionError: self.assertTrue( True ) try: - intBase(0)/intBase(0) + numVariant(0)/numVariant(0) self.assertTrue( False ) except ZeroDivisionError: self.assertTrue( True ) def testMod( self ): - self.assertEqual( 1, intBase(3) % 2 ) - self.assertEqual( 0, intBase(3) % 3 ) - self.assertEqual( 1, 3 % intBase(2) ) - self.assertEqual( 0, 3 % intBase(3) ) - self.assertEqual( 2, intBase(5) % intBase(3) ) + self.assertEqual( 1, numVariant(3) % 2 ) + self.assertEqual( 0, numVariant(3) % 3 ) + self.assertEqual( 1, 3 % numVariant(2) ) + self.assertEqual( 0, 3 % numVariant(3) ) + self.assertEqual( 2, numVariant(5) % numVariant(3) ) def testShift( self ): - self.assertEqual( 0xFFFFFFFF >> 8, intBase(0xFFFFFFFF) >> 8 ) - self.assertEqual( 0x00FFFFFF << 8, intBase(0x00FFFFFF) << 8 ) - self.assertEqual( 0xFFFFFFFF >> 8, 0xFFFFFFFF >> intBase(8) ) - self.assertEqual( 0x00FFFFFF << 8, 0x00FFFFFF << intBase(8) ) + self.assertEqual( 0xFFFFFFFF >> 8, numVariant(0xFFFFFFFF) >> 8 ) + self.assertEqual( 0x00FFFFFF << 8, numVariant(0x00FFFFFF) << 8 ) + self.assertEqual( 0xFFFFFFFF >> 8, 0xFFFFFFFF >> numVariant(8) ) + self.assertEqual( 0x00FFFFFF << 8, 0x00FFFFFF << numVariant(8) ) def testAnd( self ): - self.assertEqual( 0xFFFFFFFF & 0xFFFF, intBase(0xFFFFFFFF) & 0xFFFF ) - self.assertEqual( 0xFFFFFFFF & 0xFFFF, 0xFFFFFFFF & intBase(0xFFFF) ) - self.assertEqual( -0xFFFFFFFF & 0xFFFF, intBase(-0xFFFFFFFF) & 0xFFFF ) - self.assertEqual( -0xFFFFFFFF & 0xFFFF, -0xFFFFFFFF & intBase(0xFFFF) ) + self.assertEqual( 0xFFFFFFFF & 0xFFFF, numVariant(0xFFFFFFFF) & 0xFFFF ) + self.assertEqual( 0xFFFFFFFF & 0xFFFF, 0xFFFFFFFF & numVariant(0xFFFF) ) + self.assertEqual( -0xFFFFFFFF & 0xFFFF, numVariant(-0xFFFFFFFF) & 0xFFFF ) + self.assertEqual( -0xFFFFFFFF & 0xFFFF, -0xFFFFFFFF & numVariant(0xFFFF) ) def testOr( self ): - self.assertEqual( 0xFFFF0000 | 0xFFFF, intBase(0xFFFF0000) | 0xFFFF ) - self.assertEqual( 0xFFFF0000 | 0xFFFF, 0xFFFF0000 | intBase(0xFFFF) ) - self.assertEqual( -0xFFFF0000 | 0xFFFF, intBase(-0xFFFF0000) | 0xFFFF ) - self.assertEqual( -0xFFFF0000 | 0xFFFF, -0xFFFF0000 | intBase(0xFFFF) ) + self.assertEqual( 0xFFFF0000 | 0xFFFF, numVariant(0xFFFF0000) | 0xFFFF ) + self.assertEqual( 0xFFFF0000 | 0xFFFF, 0xFFFF0000 | numVariant(0xFFFF) ) + self.assertEqual( -0xFFFF0000 | 0xFFFF, numVariant(-0xFFFF0000) | 0xFFFF ) + self.assertEqual( -0xFFFF0000 | 0xFFFF, -0xFFFF0000 | numVariant(0xFFFF) ) def testXor( self ): - self.assertEqual( 0xFFFFFFFF ^ 0xFFFF, intBase(0xFFFFFFFF) ^ 0xFFFF ) - self.assertEqual( 0xFFFFFFFF ^ 0xFFFF, 0xFFFFFFFF ^ intBase(0xFFFF) ) - self.assertEqual( -0xFFFFFFFF ^ 0xFFFF, intBase(-0xFFFFFFFF) ^ 0xFFFF ) - self.assertEqual( -0xFFFFFFFF ^ 0xFFFF, -0xFFFFFFFF ^ intBase(0xFFFF) ) + self.assertEqual( 0xFFFFFFFF ^ 0xFFFF, numVariant(0xFFFFFFFF) ^ 0xFFFF ) + self.assertEqual( 0xFFFFFFFF ^ 0xFFFF, 0xFFFFFFFF ^ numVariant(0xFFFF) ) + self.assertEqual( -0xFFFFFFFF ^ 0xFFFF, numVariant(-0xFFFFFFFF) ^ 0xFFFF ) + self.assertEqual( -0xFFFFFFFF ^ 0xFFFF, -0xFFFFFFFF ^ numVariant(0xFFFF) ) def testUnary( self ): - self.assertEqual( -0xFFFFFFFF, -intBase(0xFFFFFFFF) ) - self.assertEqual( 0xFFFFFFFF, +intBase(0xFFFFFFFF) ) - self.assertEqual( 0, ~intBase(0xFFFFFFFF) ) + self.assertEqual( -0xFFFFFFFF, -numVariant(0xFFFFFFFF) ) + self.assertEqual( 0xFFFFFFFF, +numVariant(0xFFFFFFFF) ) + self.assertEqual( 0, ~numVariant(0xFFFFFFFF) ) def testLongConvert( self ): - self.assertEqual( "100", "%d" % intBase(100) ) - self.assertEqual( "FFFF", "%X" % intBase(0xFFFF) ) - self.assertEqual( "-70000000000", "%d" % intBase(-70000000000) ) - self.assertEqual( "FFFFFFFFFFFFFF", "%X" % intBase(0xFFFFFFFFFFFFFF) ) - self.assertEqual( "0", "%d" % intBase(False) ) + self.assertEqual( "100", "%d" % numVariant(100) ) + self.assertEqual( "FFFF", "%X" % numVariant(0xFFFF) ) + self.assertEqual( "-70000000000", "%d" % numVariant(-70000000000) ) + self.assertEqual( "FFFFFFFFFFFFFF", "%X" % numVariant(0xFFFFFFFFFFFFFF) ) + self.assertEqual( "0", "%d" % numVariant(False) ) def testConvert( self ): - self.assertEqual( "100", "%d" % intBase(100) ) - self.assertEqual( "64", "%x" % intBase(100) ) + self.assertEqual( "100", "%d" % numVariant(100) ) + self.assertEqual( "64", "%x" % numVariant(100) ) \ No newline at end of file diff --git a/test/scripts/pykdtest.py b/test/scripts/pykdtest.py index c4f5a92..cdbe683 100644 --- a/test/scripts/pykdtest.py +++ b/test/scripts/pykdtest.py @@ -13,7 +13,7 @@ import pykd import target -#import intbase +import intbase #import memtest #import moduletest #import typeinfo @@ -29,10 +29,10 @@ import target class StartProcessWithoutParamsTest(unittest.TestCase): def testStart(self): target.processId = pykd.startProcess( target.appPath ) - # target.module = pykd.module( target.moduleName ) - # target.module.reload(); + target.module = pykd.module( target.moduleName ) + target.module.reload(); # print "\n" + str( pykd.getSystemVersion() ) - # pykd.go() + pykd.go() class TerminateProcessTest(unittest.TestCase): def testKill(self): @@ -43,9 +43,10 @@ def getTestSuite( singleName = "" ): if singleName == "": return unittest.TestSuite( [ + unittest.TestLoader().loadTestsFromTestCase( intbase.IntBaseTest ), + unittest.TestLoader().loadTestsFromTestCase( StartProcessWithoutParamsTest ), # *** Test without start/kill new processes - #unittest.TestLoader().loadTestsFromTestCase( intbase.IntBaseTest ), #unittest.TestLoader().loadTestsFromTestCase( moduletest.ModuleTest ), #unittest.TestLoader().loadTestsFromTestCase( memtest.MemoryTest ), #unittest.TestLoader().loadTestsFromTestCase( typeinfo.TypeInfoTest ),