PageRenderTime 51ms CodeModel.GetById 15ms RepoModel.GetById 1ms app.codeStats 0ms

/branch/0.1.x/test/scripts/intbase.py

#
Python | 173 lines | 149 code | 24 blank | 0 comment | 13 complexity | 870e938e7b8ff25acafd3a5c8ad7213f MD5 | raw file
Possible License(s): CC-BY-SA-3.0, Unlicense 
    

  1. 

    2. 

  2. import unittest

    3. 

  3. import target

    4. 

  4. from pykd import intBase

    5. 

  5. 

    6. 

  6. class IntBaseTest( unittest.TestCase ):

    7. 

  7. 

    8. 

  8.     def testCtor( self ):

    9. 

  9.         a = intBase(0xFF)

    10. 

  10.         a = intBase(0xFFFF)

    11. 

  11.         a = intBase(0xFFFFFFFF)

    12. 

  12.         a = intBase(0x8000000000000000)

    13. 

  13.         a = intBase(0xFFFFFFFFFFFFFFFF)

    14. 

  14.         a = intBase(-20)

    15. 

  15.         a = intBase(-2000)

    16. 

  16.         a = intBase(-200000)

    17. 

  17.         a = intBase(-20000000000) 

    18. 

  18.         a = intBase(-0xFFFFFFFFFFFFFFFF )

    19. 

  19.         a = intBase( True )

    20. 

  20.         

    21. 

  21.     def testEq( self ):

    22. 

  22.         self.assertTrue( 0xFF == intBase(0xFF) and intBase(0xFF) == 0xFF )

    23. 

  23.         self.assertTrue( 0xFFFF == intBase(0xFFFF) and 0xFFFF == intBase(0xFFFF) )

    24. 

  24.         self.assertTrue( 0xFFFFFFFF ==  intBase(0xFFFFFFFF) and  intBase(0xFFFFFFFF) == 0xFFFFFFFF )

    25. 

  25.         self.assertTrue( 0x8000000000000000 == intBase(0x8000000000000000) )

    26. 

  26.         self.assertTrue( 0xFFFFFFFFFFFFFFFF ==  intBase(0xFFFFFFFFFFFFFFFF) )

    27. 

  27.         self.assertTrue( -20 == intBase(-20) )

    28. 

  28.         self.assertTrue( -2000 == intBase(-2000) )

    29. 

  29.         self.assertTrue( -0x7FFFFFFF == intBase(-0x7FFFFFFF) )

    30. 

  30.         self.assertTrue( -20000000000 == intBase(-20000000000) )         

    31. 

  31.         self.assertTrue( -0x8000000000000000 == intBase(-0x8000000000000000) )

    32. 

  32.         self.assertTrue( intBase(0x20L) == intBase(0x20) )

    33. 

  33.         self.assertTrue( True == intBase(True) )

    34. 

  34.         self.assertTrue( False == intBase(0) )

    35. 

  35.         self.assertTrue( True == intBase(1) )

    36. 

  36.         self.assertTrue( intBase(1) == intBase(1) )

    37. 

  37.         

    38. 

  38.     def testNe( self ):

    39. 

  39.         self.assertTrue( 0xFE != intBase(0xFF) )

    40. 

  40.         self.assertTrue( 0xFF00 !=  intBase(0xFFFF) )

    41. 

  41.         self.assertTrue( 0xFFFFFF88 != intBase(0xFFFFFFFF) )

    42. 

  42.         self.assertTrue( 0x8000000000000000 - 1 != intBase(0x8000000000000000) )

    43. 

  43.         self.assertTrue( 0xFFFFFFFFFFFFFFFF - 1 !=  intBase(0xFFFFFFFFFFFFFFFF) )

    44. 

  44.         self.assertTrue( -20 + 1 != intBase(-20) )        

    45. 

  45.         self.assertTrue( -2000 + 1 != intBase(-2000) )        

    46. 

  46.         self.assertTrue( -20000000000 + 1 != intBase(-20000000000) )

    47. 

  47.         self.assertTrue( -0x8000000000000000 - 1 != intBase(-0x8000000000000000) )

    48. 

  48.         self.assertTrue( intBase(1) != intBase(2) )

    49. 

  49.         

    50. 

  50.     def testLtGt( self ):

    51. 

  51.         self.assertTrue( 0xFE < intBase(0xFF) and intBase(0xFE) < 0xFF )

    52. 

  52.         self.assertFalse( -99 < intBase(-100) and intBase(-99) < - 100 )

    53. 

  53.         self.assertTrue( 0xFFFFFFFFFFFFFFFE < intBase(0xFFFFFFFFFFFFFFFF) )

    54. 

  54.         self.assertFalse(0xFFFFFFFFFFFFFFFF < intBase(0xFFFFFFFFFFFFFFFE) )

    55. 

  55.         self.assertTrue( intBase(0xFFFFFFFFFFFFFFFE) < 0xFFFFFFFFFFFFFFFF )

    56. 

  56.         self.assertTrue( intBase(1) < intBase(2) )

    57. 

  57.         

    58. 

  58.     def testLeGe( self ):

    59. 

  59.         self.assertTrue( 0xFE <= intBase(0xFF) and intBase(0xFE) <= 0xFF )

    60. 

  60.         self.assertTrue( 0xFF <= intBase(0xFF) )

    61. 

  61.         self.assertFalse( -99 <= intBase(-100) and intBase(-99) <= - 100 )

    62. 

  62.         self.assertTrue( 0xFFFFFFFFFFFFFFFE <= intBase(0xFFFFFFFFFFFFFFFF) )

    63. 

  63.         self.assertFalse(0xFFFFFFFFFFFFFFFF <= intBase(0xFFFFFFFFFFFFFFFE) )

    64. 

  64.         self.assertTrue( intBase(0xFFFFFFFFFFFFFFFF) <= 0xFFFFFFFFFFFFFFFF )

    65. 

  65.         self.assertFalse( intBase(1) >= intBase(2) )

    66. 

  66.                 

    67. 

  67.     def testAdd( self ):

    68. 

  68.         self.assertEqual( 10, intBase(5) + 5 )

    69. 

  69.         self.assertEqual( 10, 5 + intBase(5) )

    70. 

  70.         a = 10

    71. 

  71.         a += intBase(10)

    72. 

  72.         self.assertEqual( 20, a )

    73. 

  73.         self.assertEqual( -20, intBase(-10) + (-10) )

    74. 

  74.         self.assertEqual( 10, intBase(-10) + 20 )

    75. 

  75.         self.assertEqual( 0x7fffffffffffffff + 1, intBase(0x7fffffffffffffff) + 1)

    76. 

  76.         self.assertEqual( -0x8000000000000000 + 10, intBase(-0x8000000000000000) + 10 )

    77. 

  77.         self.assertEqual( 0, intBase(-0x8000000000000000) + 0x8000000000000000 )

    78. 

  78.         self.assertEqual( 5, intBase(3) + intBase(2) )

    79. 

  79. 

    80. 

  80.     def testSub( self ):

    81. 

  81.         self.assertEqual( 0, intBase(5) - 5 )

    82. 

  82.         self.assertEqual( 10, 15 - intBase(5) )

    83. 

  83.         a = 10

    84. 

  84.         a -= intBase(5)

    85. 

  85.         self.assertEqual( 5, a )

    86. 

  86.         self.assertEqual( -20, intBase(-10) -10 )

    87. 

  87.         self.assertEqual( -10, 10 - intBase(20) )

    88. 

  88.         self.assertEqual( -0xFFFFFFFF - 1, intBase(-0xFFFFFFFF) - 1 )

    89. 

  89.         self.assertEqual( 5, intBase(7) - intBase(2) )

    90. 

  90.         

    91. 

  91.     def testMul( self ):

    92. 

  92.         self.assertEqual( 4, intBase(2) * 2 )

    93. 

  93.         self.assertEqual( 4, 2 * intBase(2) )

    94. 

  94.         self.assertEqual( -4, 2 * intBase(-2) )

    95. 

  95.         self.assertEqual( 4, -2 * intBase(-2) )

    96. 

  96.         self.assertEqual( 0x7fffffffffffffff * 2, intBase(0x7fffffffffffffff) * 2)

    97. 

  97.         self.assertEqual( 0x80000000*2, intBase(0x80000000)*2 )

    98. 

  98.         self.assertEqual( -0x80000000*2, 2 * intBase(-0x80000000))

    99. 

  99.         self.assertEqual( 14, intBase(7)*intBase(2) )

    100. 

  100.         

    101. 

  101.     def testDiv( self ):

    102. 

  102.         self.assertEqual( 1, intBase(2) / 2 )

    103. 

  103.         self.assertEqual( 2, 5 / intBase(2) )

    104. 

  104.         self.assertEqual( -1, 2 / intBase(-2) )

    105. 

  105.         self.assertEqual( 1, -2 / intBase(-2) )

    106. 

  106.         self.assertEqual( 3, intBase(7)/intBase(2) )

    107. 

  107.         

    108. 

  108.         try: 

    109. 

  109.             -2 / intBase(0)

    110. 

  110.             self.assertTrue( False )

    111. 

  111.         except ZeroDivisionError:

    112. 

  112.             self.assertTrue( True )

    113. 

  113. 

    114. 

  114.         try:

    115. 

  115.             intBase(2)/0

    116. 

  116.             self.assertTrue( False )

    117. 

  117.         except ZeroDivisionError:

    118. 

  118.             self.assertTrue( True )

    119. 

  119.             

    120. 

  120.         try:

    121. 

  121.             intBase(0)/intBase(0)

    122. 

  122.             self.assertTrue( False )

    123. 

  123.         except ZeroDivisionError:

    124. 

  124.             self.assertTrue( True )

    125. 

  125.             

    126. 

  126.     def testMod( self ):

    127. 

  127.         self.assertEqual( 1, intBase(3) % 2 )

    128. 

  128.         self.assertEqual( 0, intBase(3) % 3 )

    129. 

  129.         self.assertEqual( 1, 3 % intBase(2) )

    130. 

  130.         self.assertEqual( 0, 3 % intBase(3) )

    131. 

  131.         self.assertEqual( 2, intBase(5) % intBase(3) )

    132. 

  132.         

    133. 

  133.     def testShift( self ):

    134. 

  134.         self.assertEqual( 0xFFFFFFFF >> 8, intBase(0xFFFFFFFF) >> 8 )

    135. 

  135.         self.assertEqual( 0x00FFFFFF << 8, intBase(0x00FFFFFF) << 8 )

    136. 

  136.         self.assertEqual( 0xFFFFFFFF >> 8, 0xFFFFFFFF >> intBase(8) )

    137. 

  137.         self.assertEqual( 0x00FFFFFF << 8, 0x00FFFFFF << intBase(8) )

    138. 

  138.     

    139. 

  139.     def testAnd( self ):

    140. 

  140.         self.assertEqual( 0xFFFFFFFF & 0xFFFF, intBase(0xFFFFFFFF) & 0xFFFF )

    141. 

  141.         self.assertEqual( 0xFFFFFFFF & 0xFFFF, 0xFFFFFFFF & intBase(0xFFFF) )

    142. 

  142.         self.assertEqual( -0xFFFFFFFF & 0xFFFF, intBase(-0xFFFFFFFF) & 0xFFFF )

    143. 

  143.         self.assertEqual( -0xFFFFFFFF & 0xFFFF, -0xFFFFFFFF & intBase(0xFFFF) )

    144. 

  144.         

    145. 

  145.     def testOr( self ):

    146. 

  146.         self.assertEqual( 0xFFFF0000 | 0xFFFF, intBase(0xFFFF0000) | 0xFFFF )

    147. 

  147.         self.assertEqual( 0xFFFF0000 | 0xFFFF, 0xFFFF0000 | intBase(0xFFFF) )

    148. 

  148.         self.assertEqual( -0xFFFF0000 | 0xFFFF, intBase(-0xFFFF0000) | 0xFFFF )

    149. 

  149.         self.assertEqual( -0xFFFF0000 | 0xFFFF, -0xFFFF0000 | intBase(0xFFFF) )        

    150. 

  150.         

    151. 

  151.     def testXor( self ):

    152. 

  152.         self.assertEqual( 0xFFFFFFFF ^ 0xFFFF, intBase(0xFFFFFFFF) ^ 0xFFFF )

    153. 

  153.         self.assertEqual( 0xFFFFFFFF ^ 0xFFFF, 0xFFFFFFFF ^ intBase(0xFFFF) )

    154. 

  154.         self.assertEqual( -0xFFFFFFFF ^ 0xFFFF, intBase(-0xFFFFFFFF) ^ 0xFFFF )

    155. 

  155.         self.assertEqual( -0xFFFFFFFF ^ 0xFFFF, -0xFFFFFFFF ^ intBase(0xFFFF) )        

    156. 

  156.         

    157. 

  157.     def testUnary( self ):

    158. 

  158.         self.assertEqual( -0xFFFFFFFF, -intBase(0xFFFFFFFF) )

    159. 

  159.         self.assertEqual( 0xFFFFFFFF, +intBase(0xFFFFFFFF) )

    160. 

  160.         self.assertEqual( 0, ~intBase(0xFFFFFFFF) )

    161. 

  161.         

    162. 

  162.     def testLongConvert( self ):

    163. 

  163.         self.assertEqual( "100", "%d" % intBase(100) )

    164. 

  164.         self.assertEqual( "FFFF", "%X" % intBase(0xFFFF) )

    165. 

  165.         self.assertEqual( "-70000000000", "%d" % intBase(-70000000000) )

    166. 

  166.         self.assertEqual( "FFFFFFFFFFFFFF", "%X" % intBase(0xFFFFFFFFFFFFFF) )

    167. 

  167.         self.assertEqual( "0", "%d" % intBase(False) )

    168. 

  168.         

    169. 

  169.     def testConvert( self ):

    170. 

  170.         self.assertEqual( "100", "%d" % intBase(100) )

    171. 

  171.         self.assertEqual( "64", "%x" % intBase(100) )

    172. 

  172.        

    173. 

  173.             
    174.