code: def test_correctly_rounded_true_division(self):
      # more stringent tests than those above, checking that the
      # result of true division of ints is always correctly rounded.
      # This test should probably be considered CPython-specific.
  
      # Exercise all the code paths not involving Gb-sized ints.
      # ... divisions involving zero
      self.check_truediv(123, 0)
      self.check_truediv(-456, 0)
      self.check_truediv(0, 3)
      self.check_truediv(0, -3)
      self.check_truediv(0, 0)
      # ... overflow or underflow by large margin
      self.check_truediv(671 * 12345 * 2**DBL_MAX_EXP, 12345)
      self.check_truediv(
          12345, 345678 * 2 ** (DBL_MANT_DIG - DBL_MIN_EXP)
      )
      # ... a much larger or smaller than b
      self.check_truediv(12345 * 2**100, 98765)
      self.check_truediv(12345 * 2**30, 98765 * 7**81)
      # ... a / b near a boundary: one of 1, 2**DBL_MANT_DIG, 2**DBL_MIN_EXP,
      #                 2**DBL_MAX_EXP, 2**(DBL_MIN_EXP-DBL_MANT_DIG)
      bases = (
          0,
          DBL_MANT_DIG,
          DBL_MIN_EXP,
          DBL_MAX_EXP,
          DBL_MIN_EXP - DBL_MANT_DIG,
      )
      for base in bases:
          for exp in range(base - 15, base + 15):
              self.check_truediv(
                  75312 * 2 ** max(exp, 0), 69187 * 2 ** max(-exp, 0)
              )
              self.check_truediv(
                  69187 * 2 ** max(exp, 0), 75312 * 2 ** max(-exp, 0)
              )
  
      # overflow corner case
      for m in [
          1,
          2,
          7,
          17,
          12345,
          7**100,
          -1,
          -2,
          -5,
          -23,
          -67891,
          -(41**50),
      ]:
          for n in range(-10, 10):
              self.check_truediv(m * DBL_MIN_OVERFLOW + n, m)
              self.check_truediv(m * DBL_MIN_OVERFLOW + n, -m)
  
      # check detection of inexactness in shifting stage
      for n in range(250):
          # (2**DBL_MANT_DIG+1)/(2**DBL_MANT_DIG) lies halfway
          # between two representable floats, and would usually be
          # rounded down under round-half-to-even.  The tiniest of
          # additions to the numerator should cause it to be rounded
          # up instead.
          self.check_truediv(
              (2**DBL_MANT_DIG + 1) * 12345 * 2**200 + 2**n,
              2**DBL_MANT_DIG * 12345,
          )
  
      # 1/2731 is one of the smallest division cases that's subject
      # to double rounding on IEEE 754 machines working internally with
      # 64-bit precision.  On such machines, the next check would fail,
      # were it not explicitly skipped in check_truediv.
      self.check_truediv(1, 2731)
  
      # a particularly bad case for the old algorithm:  gives an
      # error of close to 3.5 ulps.
      self.check_truediv(295147931372582273023, 295147932265116303360)
      for i in range(1000):
          self.check_truediv(10 ** (i + 1), 10**i)
          self.check_truediv(10**i, 10 ** (i + 1))
  
      # test round-half-to-even behaviour, normal result
      for m in [
          1,
          2,
          4,
          7,
          8,
          16,
          17,
          32,
          12345,
          7**100,
          -1,
          -2,
          -5,
          -23,
          -67891,
          -(41**50),
      ]:
          for n in range(-10, 10):
              self.check_truediv(2**DBL_MANT_DIG * m + n, m)
  
      # test round-half-to-even, subnormal result
      for n in range(-20, 20):
          self.check_truediv(n, 2**1076)
  
      # largeish random divisions: a/b where |a| <= |b| <=
      # 2*|a|; |ans| is between 0.5 and 1.0, so error should
      # always be bounded by 2**-54 with equality possible only
      # if the least significant bit of q=ans*2**53 is zero.
      for M in [10**10, 10**100, 10**1000]:
          for i in range(1000):
              a = random.randrange(1, M)
              b = random.randrange(a, 2 * a + 1)
              self.check_truediv(a, b)
              self.check_truediv(-a, b)
              self.check_truediv(a, -b)
              self.check_truediv(-a, -b)
  
      # and some (genuinely) random tests
      for _ in range(10000):
          a_bits = random.randrange(1000)
          b_bits = random.randrange(1, 1000)
          x = random.randrange(2**a_bits)
          y = random.randrange(1, 2**b_bits)
          self.check_truediv(x, y)
          self.check_truediv(x, -y)
          self.check_truediv(-x, y)
          self.check_truediv(-x, -y)
  
imports: import unittest
  from test import support
  import sys
  import random
  import math
  import array
label_desc: Use image node_id 26 for calling the LongTest obj's underlying member method code with example usage: obj.test_correctly_rounded_true_division() without return types