mirror of
https://github.com/ivellioscolin/pykd.git
synced 2025-04-19 19:13:22 +08:00
[0.3.x] added numVariant class
git-svn-id: https://pykd.svn.codeplex.com/svn@83703 9b283d60-5439-405e-af05-b73fd8c4d996
This commit is contained in:
SND\kernelnet_cp
Mikhail I. Izmestev
parent
f17e190978
commit
238ead9227
@ -125,6 +125,7 @@
|
||||
<ItemGroup>
|
||||
<ClInclude Include="stdafx.h" />
|
||||
<ClInclude Include="targetver.h" />
|
||||
<ClInclude Include="variant.h" />
|
||||
<ClInclude Include="windbgext.h" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
|
||||
@ -24,6 +24,9 @@
|
||||
<ClInclude Include="windbgext.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="variant.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="stdafx.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", "intBase", python::no_init )
|
||||
// .def( python::init<python::object&>() )
|
||||
// .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_<pykd::NumVariant>( "numVariant", "numVariant", python::no_init )
|
||||
.def( python::init<python::object&>() )
|
||||
.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<intBase,ULONG64>();
|
||||
// python::implicitly_convertible<intBase,LONG64>();
|
||||
// python::implicitly_convertible<intBase,ULONG>();
|
||||
// python::implicitly_convertible<intBase,LONG>();
|
||||
python::implicitly_convertible<pykd::NumVariant, unsigned long long>();
|
||||
python::implicitly_convertible<pykd::NumVariant, long long>();
|
||||
python::implicitly_convertible<pykd::NumVariant, unsigned long>();
|
||||
python::implicitly_convertible<pykd::NumVariant, long>();
|
||||
|
||||
// python::class_<Module, ModulePtr, python::bases<intBase> >("module", "Class representing executable module", python::no_init )
|
||||
// .def("__init__", python::make_constructor(Module::loadModuleByName) )
|
||||
|
||||
206
pykd/variant.h
Normal file
206
pykd/variant.h
Normal file
@ -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
|
||||
@ -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) )
|
||||
|
||||
|
||||
@ -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 ),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user