PageRenderTime 50ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/pypy/module/cpyext/test/test_pystrtod.py

https://bitbucket.org/pypy/pypy/
Python | 167 lines | 162 code | 5 blank | 0 comment | 0 complexity | d8c2ce0b02ec2a67d77a5ac03bf0e6b7 MD5 | raw file
Possible License(s): AGPL-3.0, BSD-3-Clause, Apache-2.0 
    

  1. import math
    2. 

  2. 

  3. from pypy.module.cpyext import pystrtod
    4. 

  4. from pypy.module.cpyext.test.test_api import BaseApiTest
    5. 

  5. from rpython.rtyper.lltypesystem import rffi
    6. 

  6. from rpython.rtyper.lltypesystem import lltype
    7. 

  7. 

  8. 

  9. class TestPyOS_string_to_double(BaseApiTest):
    10. 

  10. 

  11.     def test_simple_float(self, api):
    12. 

  12.         s = rffi.str2charp('0.4')
    13. 

  13.         null = lltype.nullptr(rffi.CCHARPP.TO)
    14. 

  14.         r = api.PyOS_string_to_double(s, null, None)
    15. 

  15.         assert r == 0.4
    16. 

  16.         rffi.free_charp(s)
    17. 

  17. 

  18.     def test_empty_string(self, api):
    19. 

  19.         s = rffi.str2charp('')
    20. 

  20.         null = lltype.nullptr(rffi.CCHARPP.TO)
    21. 

  21.         r = api.PyOS_string_to_double(s, null, None)
    22. 

  22.         assert r == -1.0
    23. 

  23.         raises(ValueError)
    24. 

  24.         api.PyErr_Clear()
    25. 

  25.         rffi.free_charp(s)
    26. 

  26. 

  27.     def test_bad_string(self, api):
    28. 

  28.         s = rffi.str2charp(' 0.4')
    29. 

  29.         null = lltype.nullptr(rffi.CCHARPP.TO)
    30. 

  30.         r = api.PyOS_string_to_double(s, null, None)
    31. 

  31.         assert r == -1.0
    32. 

  32.         raises(ValueError)
    33. 

  33.         api.PyErr_Clear()
    34. 

  34.         rffi.free_charp(s)
    35. 

  35. 

  36.     def test_overflow_pos(self, api):
    37. 

  37.         s = rffi.str2charp('1e500')
    38. 

  38.         null = lltype.nullptr(rffi.CCHARPP.TO)
    39. 

  39.         r = api.PyOS_string_to_double(s, null, None)
    40. 

  40.         assert math.isinf(r)
    41. 

  41.         assert r > 0
    42. 

  42.         rffi.free_charp(s)
    43. 

  43. 

  44.     def test_overflow_neg(self, api):
    45. 

  45.         s = rffi.str2charp('-1e500')
    46. 

  46.         null = lltype.nullptr(rffi.CCHARPP.TO)
    47. 

  47.         r = api.PyOS_string_to_double(s, null, None)
    48. 

  48.         assert math.isinf(r)
    49. 

  49.         assert r < 0
    50. 

  50.         rffi.free_charp(s)
    51. 

  51. 

  52.     def test_overflow_exc(self, space, api):
    53. 

  53.         s = rffi.str2charp('1e500')
    54. 

  54.         null = lltype.nullptr(rffi.CCHARPP.TO)
    55. 

  55.         r = api.PyOS_string_to_double(s, null, space.w_ValueError)
    56. 

  56.         assert r == -1.0
    57. 

  57.         raises(ValueError)
    58. 

  58.         api.PyErr_Clear()
    59. 

  59.         rffi.free_charp(s)
    60. 

  60. 

  61.     def test_endptr_number(self, api):
    62. 

  62.         s = rffi.str2charp('0.4')
    63. 

  63.         endp = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw')
    64. 

  64.         r = api.PyOS_string_to_double(s, endp, None)
    65. 

  65.         assert r == 0.4
    66. 

  66.         endp_addr = rffi.cast(rffi.LONG, endp[0])
    67. 

  67.         s_addr = rffi.cast(rffi.LONG, s)
    68. 

  68.         assert endp_addr == s_addr + 3
    69. 

  69.         rffi.free_charp(s)
    70. 

  70.         lltype.free(endp, flavor='raw')
    71. 

  71. 

  72.     def test_endptr_tail(self, api):
    73. 

  73.         s = rffi.str2charp('0.4 foo')
    74. 

  74.         endp = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw')
    75. 

  75.         r = api.PyOS_string_to_double(s, endp, None)
    76. 

  76.         assert r == 0.4
    77. 

  77.         endp_addr = rffi.cast(rffi.LONG, endp[0])
    78. 

  78.         s_addr = rffi.cast(rffi.LONG, s)
    79. 

  79.         assert endp_addr == s_addr + 3
    80. 

  80.         rffi.free_charp(s)
    81. 

  81.         lltype.free(endp, flavor='raw')
    82. 

  82. 

  83.     def test_endptr_no_conversion(self, api):
    84. 

  84.         s = rffi.str2charp('foo')
    85. 

  85.         endp = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw')
    86. 

  86.         r = api.PyOS_string_to_double(s, endp, None)
    87. 

  87.         assert r == -1.0
    88. 

  88.         raises(ValueError)
    89. 

  89.         endp_addr = rffi.cast(rffi.LONG, endp[0])
    90. 

  90.         s_addr = rffi.cast(rffi.LONG, s)
    91. 

  91.         assert endp_addr == s_addr
    92. 

  92.         api.PyErr_Clear()
    93. 

  93.         rffi.free_charp(s)
    94. 

  94.         lltype.free(endp, flavor='raw')
    95. 

  95. 

  96. 

  97. class TestPyOS_double_to_string(BaseApiTest):
    98. 

  98. 

  99.     def test_format_code(self, api):
    100. 

  100.         ptype = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
    101. 

  101.         r = api.PyOS_double_to_string(150.0, 'e', 1, 0, ptype)
    102. 

  102.         assert '1.5e+02' == rffi.charp2str(r)
    103. 

  103.         type_value = rffi.cast(lltype.Signed, ptype[0])
    104. 

  104.         assert pystrtod.Py_DTST_FINITE == type_value
    105. 

  105.         rffi.free_charp(r)
    106. 

  106.         lltype.free(ptype, flavor='raw')
    107. 

  107. 

  108.     def test_precision(self, api):
    109. 

  109.         ptype = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
    110. 

  110.         r = api.PyOS_double_to_string(3.14159269397, 'g', 5, 0, ptype)
    111. 

  111.         assert '3.1416' == rffi.charp2str(r)
    112. 

  112.         type_value = rffi.cast(lltype.Signed, ptype[0])
    113. 

  113.         assert pystrtod.Py_DTST_FINITE == type_value
    114. 

  114.         rffi.free_charp(r)
    115. 

  115.         lltype.free(ptype, flavor='raw')
    116. 

  116. 

  117.     def test_flags_sign(self, api):
    118. 

  118.         ptype = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
    119. 

  119.         r = api.PyOS_double_to_string(-3.14, 'g', 3, 1, ptype)
    120. 

  120.         assert '-3.14' == rffi.charp2str(r)
    121. 

  121.         type_value = rffi.cast(lltype.Signed, ptype[0])
    122. 

  122.         assert pystrtod.Py_DTST_FINITE == type_value
    123. 

  123.         rffi.free_charp(r)
    124. 

  124.         lltype.free(ptype, flavor='raw')
    125. 

  125. 

  126.     def test_flags_add_dot_0(self, api):
    127. 

  127.         ptype = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
    128. 

  128.         r = api.PyOS_double_to_string(3, 'g', 5, 2, ptype)
    129. 

  129.         assert '3.0' == rffi.charp2str(r)
    130. 

  130.         type_value = rffi.cast(lltype.Signed, ptype[0])
    131. 

  131.         assert pystrtod.Py_DTST_FINITE == type_value
    132. 

  132.         rffi.free_charp(r)
    133. 

  133.         lltype.free(ptype, flavor='raw')
    134. 

  134. 

  135.     def test_flags_alt(self, api):
    136. 

  136.         ptype = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
    137. 

  137.         r = api.PyOS_double_to_string(314., 'g', 3, 4, ptype)
    138. 

  138.         assert '314.' == rffi.charp2str(r)
    139. 

  139.         type_value = rffi.cast(lltype.Signed, ptype[0])
    140. 

  140.         assert pystrtod.Py_DTST_FINITE == type_value
    141. 

  141.         rffi.free_charp(r)
    142. 

  142.         lltype.free(ptype, flavor='raw')
    143. 

  143. 

  144.     def test_ptype_nan(self, api):
    145. 

  145.         ptype = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
    146. 

  146.         r = api.PyOS_double_to_string(float('nan'), 'g', 3, 4, ptype)
    147. 

  147.         assert 'nan' == rffi.charp2str(r)
    148. 

  148.         type_value = rffi.cast(lltype.Signed, ptype[0])
    149. 

  149.         assert pystrtod.Py_DTST_NAN == type_value
    150. 

  150.         rffi.free_charp(r)
    151. 

  151.         lltype.free(ptype, flavor='raw')
    152. 

  152. 

  153.     def test_ptype_infinity(self, api):
    154. 

  154.         ptype = lltype.malloc(rffi.INTP.TO, 1, flavor='raw')
    155. 

  155.         r = api.PyOS_double_to_string(1e200 * 1e200, 'g', 0, 0, ptype)
    156. 

  156.         assert 'inf' == rffi.charp2str(r)
    157. 

  157.         type_value = rffi.cast(lltype.Signed, ptype[0])
    158. 

  158.         assert pystrtod.Py_DTST_INFINITE == type_value
    159. 

  159.         rffi.free_charp(r)
    160. 

  160.         lltype.free(ptype, flavor='raw')
    161. 

  161. 

  162.     def test_ptype_null(self, api):
    163. 

  163.         ptype = lltype.nullptr(rffi.INTP.TO)
    164. 

  164.         r = api.PyOS_double_to_string(3.14, 'g', 3, 0, ptype)
    165. 

  165.         assert '3.14' == rffi.charp2str(r)
    166. 

  166.         assert ptype == lltype.nullptr(rffi.INTP.TO)
    167. 

  167.         rffi.free_charp(r)
    168.