Obtain the last block's length without having to create it

hypothesis-python/RELEASE.rst

@@ -0,0 +1,4 @@
+RELEASE_TYPE: patch
+
+This change makes a tiny improvement to the core engine's bookkeeping.
+There is no user-visible change.

hypothesis-python/src/hypothesis/internal/conjecture/data.py

@@ -202,6 +202,8 @@ def transfer_ownership(self, new_owner):
 
  def start(self, i):
  """Equivalent to self[i].start."""
+ i = self._check_index(i)
+
  if i == 0:
  return 0
  else:
@@ -222,6 +224,10 @@ def all_bounds(self):
  yield (prev, e)
  prev = e
 
+ @property
+ def last_block_length(self):
+ return self.end(-1) - self.start(-1)
+
  def __len__(self):
  return len(self.endpoints)
 
@@ -231,12 +237,16 @@ def __known_block(self, i):
  except (KeyError, IndexError):
  return None
 
- def __getitem__(self, i):
+ def _check_index(self, i):
  n = len(self)
  if i < -n or i >= n:
  raise IndexError("Index %d out of range [-%d, %d)" % (i, n, n))
  if i < 0:
  i += n
+ return i
+
+ def __getitem__(self, i):
+ i = self._check_index(i)
  assert i >= 0
  result = self.__known_block(i)
  if result is not None:

hypothesis-python/src/hypothesis/stateful.py

@@ -619,7 +619,7 @@ def do_draw(self, data):
  # Easy, right?
  n = len(self.rules)
  i = cu.integer_range(data, 0, n - 1)
- block_length = data.blocks[-1].length
+ block_length = data.blocks.last_block_length
  rule = self.rules[i]
  if not self.is_valid(rule):
  valid_rules = [j for j, r in enumerate(self.rules) if self.is_valid(r)]

hypothesis-python/tests/cover/test_conjecture_test_data.py

@@ -268,3 +268,35 @@ def conclude_test(self, status, reason):
  x.freeze()
 
  assert observer.conclusion == (Status.VALID, None)
+
+
+def test_handles_start_indices_like_a_list():
+ n = 5
+ d = ConjectureData.for_buffer([1] * n)
+ for _ in hrange(n):
+ d.draw_bits(1)
+
+ for i in hrange(-2 * n, 2 * n + 1):
+ try:
+ start = d.blocks.start(i)
+ except IndexError:
+ # Directly retrieving the start position failed, so check that
+ # indexing also fails.
+ with pytest.raises(IndexError):
+ d.blocks[i]
+ continue
+
+ # Directly retrieving the start position succeeded, so check that
+ # indexing also succeeds, and gives the same position.
+ assert start == d.blocks[i].start
+
+
+def test_last_block_length():
+ d = ConjectureData.for_buffer([0] * 15)
+
+ with pytest.raises(IndexError):
+ d.blocks.last_block_length
+
+ for n in hrange(1, 5 + 1):
+ d.draw_bits(n * 8)
+ assert d.blocks.last_block_length == n