hypothesis-specs 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 793034b02b1dde38856e5e7d7192b6b281aae453d6ff060ddd4478147bf066fc
-  data.tar.gz: 4fdc7f52bc5d36816a3dfc94c59e4273155af358cb2d57629402e6ad4582090b
+  metadata.gz: 70d4e8207879b336d81af1a5c591b0eb184068114617a87f75640cc729e2152f
+  data.tar.gz: 1cd583baf6d78a411ddc81756ceee110566b05025671cdc50fd8c210d41b444f
 SHA512:
-  metadata.gz: 43cd31e4681166b72d147f0c7f5fb0a906b98677515656410897abe7442cf101673e8abbdf69079488de6edbab315be5bfcdfba6a9e9fb6adff95485c9e2ad60
-  data.tar.gz: 34859a4362b50323fa4dd19ed195cb9e00a854a5ae0aa06d6c77c8cdb8abb0f8fd21428696fd388c7abe35e49c5eab726e83b7e09aee0ff01478fa9e15c13cac
+  metadata.gz: f5811a1bf2bd16b8ca011e40cc25e007afcccd5432d082dea9d4d7fd3f042e1c835d0b42f3808bf6915fe4042fafabdbd12ed7f5f7fb4dc2f46cb5cd94e6a2e1
+  data.tar.gz: 7be4261c0ee96f7d22eb107dba0e9ee485ec5510bbf769841fc50e0cb9d13a0dda56ef4b100b4e27b601aaccbfba1fe07c7b35a36006029ff03950df14bc3d70

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# Hypothesis for Ruby 0.0.13 (2018-06-25)
+
+This release moves the core Rust engine into the separate Conjecture crate. It
+should have no user visible effect.
+
 # Hypothesis for Ruby 0.0.12 (2018-06-23)
 
 This release is the beginning of splitting out the Rust core of Hypothesis

data/Cargo.toml

@@ -9,4 +9,4 @@ crate-type = ["cdylib"]
 [dependencies]
 helix = '0.7.5'
 rand = '0.3'
-conjecture = '0.1.1'
+conjecture = '0.2.0'

data/Rakefile

@@ -16,11 +16,7 @@ begin
     t.verbose = true
   end
 
-  task :rust_tests do
-    sh 'cargo test'
-  end
-
-  task test: %i[build spec minitests rust_tests]
+  task test: %i[build spec minitests]
 rescue LoadError
 end
 

data/src/lib.rs

@@ -11,17 +11,14 @@ extern crate core;
 #[macro_use]
 extern crate helix;
 extern crate rand;
-
-mod data;
-mod distributions;
-mod engine;
-mod intminimize;
+extern crate conjecture;
 
 use std::mem;
 
-use data::{DataSource, Status};
-use distributions::Repeat;
-use engine::Engine;
+use conjecture::data::{DataSource, Status};
+use conjecture::distributions::Repeat;
+use conjecture::distributions;
+use conjecture::engine::Engine;
 
 ruby! {
   class HypothesisCoreDataSource {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hypothesis-specs
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - David R. Maciver
@@ -67,10 +67,6 @@ files:
 - lib/hypothesis/possible.rb
 - lib/hypothesis/testcase.rb
 - lib/hypothesis/world.rb
-- src/data.rs
-- src/distributions.rs
-- src/engine.rs
-- src/intminimize.rs
 - src/lib.rs
 homepage: https://github.com/HypothesisWorks/hypothesis/tree/master/hypothesis-ruby
 licenses:

data/src/data.rs

@@ -1,184 +0,0 @@
-// Module representing core data types that Hypothesis
-// needs.
-
-use rand::{ChaChaRng, Rng};
-use std::collections::HashSet;
-
-pub type DataStream = Vec<u64>;
-
-#[derive(Debug, Clone)]
-pub struct FailedDraw;
-
-#[derive(Debug, Clone)]
-enum BitGenerator {
-    Random(ChaChaRng),
-    Recorded(DataStream),
-}
-
-// Records information corresponding to a single draw call.
-#[derive(Debug, Clone)]
-pub struct DrawInProgress {
-    depth: usize,
-    start: usize,
-    end: Option<usize>,
-}
-
-// Records information corresponding to a single draw call.
-#[derive(Debug, Clone)]
-pub struct Draw {
-    pub depth: usize,
-    pub start: usize,
-    pub end: usize,
-}
-
-// Main entry point for running a test:
-// A test function takes a DataSource, uses it to
-// produce some data, and the DataSource records the
-// relevant information about what they did.
-#[derive(Debug, Clone)]
-pub struct DataSource {
-    bitgenerator: BitGenerator,
-    record: DataStream,
-    sizes: Vec<u64>,
-    draws: Vec<DrawInProgress>,
-    draw_stack: Vec<usize>,
-    written_indices: HashSet<usize>,
-}
-
-impl DataSource {
-    fn new(generator: BitGenerator) -> DataSource {
-        return DataSource {
-            bitgenerator: generator,
-            record: DataStream::new(),
-            sizes: Vec::new(),
-            draws: Vec::new(),
-            draw_stack: Vec::new(),
-            written_indices: HashSet::new(),
-        };
-    }
-
-    pub fn from_random(random: ChaChaRng) -> DataSource {
-        return DataSource::new(BitGenerator::Random(random));
-    }
-
-    pub fn from_vec(record: DataStream) -> DataSource {
-        return DataSource::new(BitGenerator::Recorded(record));
-    }
-
-    pub fn start_draw(&mut self) {
-        let i = self.draws.len();
-        let depth = self.draw_stack.len();
-        let start = self.record.len();
-
-        self.draw_stack.push(i);
-        self.draws.push(DrawInProgress {
-            start: start,
-            end: None,
-            depth: depth,
-        });
-    }
-
-    pub fn stop_draw(&mut self) {
-        assert!(self.draws.len() > 0);
-        assert!(self.draw_stack.len() > 0);
-        let i = self.draw_stack.pop().unwrap();
-        let end = self.record.len();
-        self.draws[i].end = Some(end);
-    }
-
-    pub fn write(&mut self, value: u64) -> Result<(), FailedDraw> {
-        match self.bitgenerator {
-            BitGenerator::Recorded(ref mut v) if self.record.len() >= v.len() => Err(FailedDraw),
-            _ => {
-                self.sizes.push(0);
-                self.record.push(value);
-                Ok(())
-            }
-        }
-    }
-
-    pub fn bits(&mut self, n_bits: u64) -> Result<u64, FailedDraw> {
-        self.sizes.push(n_bits);
-        let mut result = match self.bitgenerator {
-            BitGenerator::Random(ref mut random) => random.next_u64(),
-            BitGenerator::Recorded(ref mut v) => if self.record.len() >= v.len() {
-                return Err(FailedDraw);
-            } else {
-                v[self.record.len()]
-            },
-        };
-
-        if n_bits < 64 {
-            let mask = (1 << n_bits) - 1;
-            result &= mask;
-        };
-
-        self.record.push(result);
-
-        return Ok(result);
-    }
-
-    pub fn to_result(mut self, status: Status) -> TestResult {
-        TestResult {
-            record: self.record,
-            status: status,
-            written_indices: self.written_indices,
-            sizes: self.sizes,
-            draws: self.draws
-                .drain(..)
-                .filter_map(|d| match d {
-                    DrawInProgress {
-                        depth,
-                        start,
-                        end: Some(end),
-                    } if start < end =>
-                    {
-                        Some(Draw {
-                            start: start,
-                            end: end,
-                            depth: depth,
-                        })
-                    }
-                    DrawInProgress { end: None, .. } => {
-                        assert!(status == Status::Invalid || status == Status::Overflow);
-                        None
-                    }
-                    _ => None,
-                })
-                .collect(),
-        }
-    }
-}
-
-// Status indicates the result that we got from completing
-// a single test execution.
-#[derive(Debug, Clone, Eq, PartialEq, Copy)]
-pub enum Status {
-    // The test tried to read more data than we had for it.
-    Overflow,
-
-    // Some important precondition of the test was not
-    // satisfied.
-    Invalid,
-
-    // This test ran successfully to completion without
-    // anything of note happening.
-    Valid,
-
-    // This was an interesting test execution! (Usually this
-    // means failing, but for things like find it may not).
-    Interesting,
-}
-
-// Once a data source is finished it "decays" to a
-// TestResult, that retains a trace of all the information
-// we needed from the DataSource. It is these we keep around,
-// not the original DataSource objects.
-#[derive(Debug, Clone)]
-pub struct TestResult {
-    pub record: DataStream,
-    pub status: Status,
-    pub draws: Vec<Draw>,
-    pub sizes: Vec<u64>,
-    pub written_indices: HashSet<usize>,
-}

data/src/distributions.rs

@@ -1,297 +0,0 @@
-use data::{DataSource, FailedDraw};
-
-use std::cmp::{Ord, Ordering, PartialOrd, Reverse};
-use std::collections::BinaryHeap;
-use std::mem;
-
-use std::u64::MAX as MAX64;
-
-type Draw<T> = Result<T, FailedDraw>;
-
-pub fn weighted(source: &mut DataSource, probability: f64) -> Result<bool, FailedDraw> {
-    // TODO: Less bit-hungry implementation.
-
-    let truthy = (probability * (u64::max_value() as f64 + 1.0)).floor() as u64;
-    let probe = source.bits(64)?;
-    Ok(match (truthy, probe) {
-        (0, _) => false,
-        (MAX64, _) => true,
-        (_, 0) => false,
-        (_, 1) => true,
-        _ => probe >= MAX64 - truthy,
-    })
-}
-
-pub fn bounded_int(source: &mut DataSource, max: u64) -> Draw<u64> {
-    let bitlength = 64 - max.leading_zeros() as u64;
-    if bitlength == 0 {
-        source.write(0)?;
-        return Ok(0);
-    }
-    loop {
-        let probe = source.bits(bitlength)?;
-        if probe <= max {
-            return Ok(probe);
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Repeat {
-    min_count: u64,
-    max_count: u64,
-    p_continue: f64,
-
-    current_count: u64,
-}
-
-impl Repeat {
-    pub fn new(min_count: u64, max_count: u64, expected_count: f64) -> Repeat {
-        Repeat {
-            min_count: min_count,
-            max_count: max_count,
-            p_continue: 1.0 - 1.0 / (1.0 + expected_count),
-            current_count: 0,
-        }
-    }
-
-    pub fn reject(&mut self) {
-        assert!(self.current_count > 0);
-        self.current_count -= 1;
-    }
-
-    pub fn should_continue(&mut self, source: &mut DataSource) -> Result<bool, FailedDraw> {
-        if self.min_count == self.max_count {
-            if self.current_count < self.max_count {
-                self.current_count += 1;
-                return Ok(true);
-            } else {
-                return Ok(false);
-            }
-        } else if self.current_count < self.min_count {
-            source.write(1)?;
-            self.current_count += 1;
-            return Ok(true);
-        } else if self.current_count >= self.max_count {
-            source.write(0)?;
-            return Ok(false);
-        }
-
-        let result = weighted(source, self.p_continue)?;
-        if result {
-            self.current_count += 1;
-        } else {
-        }
-        return Ok(result);
-    }
-}
-
-#[derive(Debug, Clone)]
-struct SamplerEntry {
-    primary: usize,
-    alternate: usize,
-    use_alternate: f32,
-}
-
-impl SamplerEntry {
-    fn single(i: usize) -> SamplerEntry {
-        SamplerEntry {
-            primary: i,
-            alternate: i,
-            use_alternate: 0.0,
-        }
-    }
-}
-
-impl Ord for SamplerEntry {
-    fn cmp(&self, other: &SamplerEntry) -> Ordering {
-        return self.primary
-            .cmp(&other.primary)
-            .then(self.alternate.cmp(&other.alternate));
-    }
-}
-
-impl PartialOrd for SamplerEntry {
-    fn partial_cmp(&self, other: &SamplerEntry) -> Option<Ordering> {
-        return Some(self.cmp(other));
-    }
-}
-
-impl PartialEq for SamplerEntry {
-    fn eq(&self, other: &SamplerEntry) -> bool {
-        return self.cmp(other) == Ordering::Equal;
-    }
-}
-
-impl Eq for SamplerEntry {}
-
-#[derive(Debug, Clone)]
-pub struct Sampler {
-    table: Vec<SamplerEntry>,
-}
-
-impl Sampler {
-    pub fn new(weights: Vec<f32>) -> Sampler {
-        // FIXME: The correct thing to do here is to allow this,
-        // return early, and make this reject the data, but we don't
-        // currently have the status built into our data properly...
-        assert!(weights.len() > 0);
-
-        let mut table = Vec::new();
-
-        let mut small = BinaryHeap::new();
-        let mut large = BinaryHeap::new();
-
-        let total: f32 = weights.iter().sum();
-
-        let mut scaled_probabilities = Vec::new();
-
-        let n = weights.len() as f32;
-
-        for (i, w) in weights.iter().enumerate() {
-            let scaled = n * w / total;
-            scaled_probabilities.push(scaled);
-            if scaled == 1.0 {
-                table.push(SamplerEntry::single(i))
-            } else if scaled > 1.0 {
-                large.push(Reverse(i));
-            } else {
-                assert!(scaled < 1.0);
-                small.push(Reverse(i));
-            }
-        }
-
-        while !(small.is_empty() || large.is_empty()) {
-            let Reverse(lo) = small.pop().unwrap();
-            let Reverse(hi) = large.pop().unwrap();
-
-            assert!(lo != hi);
-            assert!(scaled_probabilities[hi] > 1.0);
-            assert!(scaled_probabilities[lo] < 1.0);
-            scaled_probabilities[hi] = (scaled_probabilities[hi] + scaled_probabilities[lo]) - 1.0;
-            table.push(SamplerEntry {
-                primary: lo,
-                alternate: hi,
-                use_alternate: 1.0 - scaled_probabilities[lo],
-            });
-
-            if scaled_probabilities[hi] < 1.0 {
-                small.push(Reverse(hi))
-            } else if scaled_probabilities[hi] > 1.0 {
-                large.push(Reverse(hi))
-            } else {
-                table.push(SamplerEntry::single(hi))
-            }
-        }
-        for &Reverse(i) in small.iter() {
-            table.push(SamplerEntry::single(i))
-        }
-        for &Reverse(i) in large.iter() {
-            table.push(SamplerEntry::single(i))
-        }
-
-        for ref mut entry in table.iter_mut() {
-            if entry.alternate < entry.primary {
-                mem::swap(&mut entry.primary, &mut entry.alternate);
-                entry.use_alternate = 1.0 - entry.use_alternate;
-            }
-        }
-
-        table.sort();
-        assert!(table.len() > 0);
-        return Sampler { table: table };
-    }
-
-    pub fn sample(&self, source: &mut DataSource) -> Draw<usize> {
-        assert!(self.table.len() > 0);
-        let i = bounded_int(source, self.table.len() as u64 - 1)? as usize;
-        let entry = &self.table[i];
-        let use_alternate = weighted(source, entry.use_alternate as f64)?;
-        if use_alternate {
-            Ok(entry.alternate)
-        } else {
-            Ok(entry.primary)
-        }
-    }
-}
-
-pub fn good_bitlengths() -> Sampler {
-    let weights = vec![
-        4.0,
-        4.0,
-        4.0,
-        4.0,
-        4.0,
-        4.0,
-        4.0,
-        4.0, // 1 byte
-        2.0,
-        2.0,
-        2.0,
-        2.0,
-        2.0,
-        2.0,
-        2.0,
-        2.0, // 2 bytes
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0, // 3 bytes
-        0.5,
-        0.5,
-        0.5,
-        0.5,
-        0.5,
-        0.5,
-        0.5,
-        0.5, // 4 bytes
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1, // 5 bytes
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1, // 6 bytes
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1, // 7 bytes
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1,
-        0.1, // 8 bytes (last bit spare for sign)
-    ];
-    assert!(weights.len() == 63);
-    Sampler::new(weights)
-}
-
-pub fn integer_from_bitlengths(source: &mut DataSource, bitlengths: &Sampler) -> Draw<i64> {
-    let bitlength = bitlengths.sample(source)? as u64 + 1;
-    let base = source.bits(bitlength)? as i64;
-    let sign = source.bits(1)?;
-    if sign > 0 {
-        Ok(-base)
-    } else {
-        Ok(base)
-    }
-}

data/src/engine.rs

@@ -1,620 +0,0 @@
-// Core module that provides a main execution loop and
-// the API that can be used to get test data from it.
-
-use rand::{ChaChaRng, Rng, SeedableRng};
-
-use std::cmp::Reverse;
-use std::collections::HashMap;
-use std::mem;
-use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
-use std::thread;
-
-use data::{DataSource, DataStream, Status, TestResult};
-use intminimize::minimize_integer;
-
-#[derive(Debug, Clone)]
-enum LoopExitReason {
-    Complete,
-    MaxExamples,
-    Shutdown,
-}
-
-#[derive(Debug)]
-enum LoopCommand {
-    RunThis(DataSource),
-    Finished(LoopExitReason, MainGenerationLoop),
-}
-
-#[derive(Debug)]
-struct MainGenerationLoop {
-    receiver: Receiver<TestResult>,
-    sender: SyncSender<LoopCommand>,
-    max_examples: u64,
-    random: ChaChaRng,
-
-    best_example: Option<TestResult>,
-
-    valid_examples: u64,
-    invalid_examples: u64,
-    interesting_examples: u64,
-}
-
-type StepResult = Result<(), LoopExitReason>;
-
-impl MainGenerationLoop {
-    fn run(mut self) {
-        let result = self.loop_body();
-        match result {
-            // Silent shutdown when the main thread terminates
-            Err(LoopExitReason::Shutdown) => (),
-            Err(reason) => {
-                // Must clone because otherwise it is borrowed.
-                let shutdown_sender = self.sender.clone();
-                shutdown_sender
-                    .send(LoopCommand::Finished(reason, self))
-                    .unwrap()
-            }
-            Ok(_) => panic!("BUG: Generation loop was not supposed to return normally."),
-        }
-    }
-
-    fn loop_body(&mut self) -> StepResult {
-        let interesting_example = self.generate_examples()?;
-
-        let mut shrinker = Shrinker::new(self, interesting_example, |r| {
-            r.status == Status::Interesting
-        });
-
-        shrinker.run()?;
-
-        return Err(LoopExitReason::Complete);
-    }
-
-    fn generate_examples(&mut self) -> Result<TestResult, LoopExitReason> {
-        while self.valid_examples < self.max_examples
-            && self.invalid_examples < 10 * self.max_examples
-        {
-            let r = self.random.gen();
-            let result = self.execute(DataSource::from_random(r))?;
-            if result.status == Status::Interesting {
-                return Ok(result);
-            }
-        }
-        return Err(LoopExitReason::MaxExamples);
-    }
-
-    fn execute(&mut self, source: DataSource) -> Result<TestResult, LoopExitReason> {
-        let result = match self.sender.send(LoopCommand::RunThis(source)) {
-            Ok(_) => match self.receiver.recv() {
-                Ok(t) => t,
-                Err(_) => return Err(LoopExitReason::Shutdown),
-            },
-            Err(_) => return Err(LoopExitReason::Shutdown),
-        };
-        match result.status {
-            Status::Overflow => (),
-            Status::Invalid => self.invalid_examples += 1,
-            Status::Valid => self.valid_examples += 1,
-            Status::Interesting => {
-                self.best_example = Some(result.clone());
-                self.interesting_examples += 1;
-            }
-        }
-
-        Ok(result)
-    }
-}
-
-struct Shrinker<'owner, Predicate> {
-    _predicate: Predicate,
-    shrink_target: TestResult,
-    changes: u64,
-    expensive_passes_enabled: bool,
-    main_loop: &'owner mut MainGenerationLoop,
-}
-
-impl<'owner, Predicate> Shrinker<'owner, Predicate>
-where
-    Predicate: Fn(&TestResult) -> bool,
-{
-    fn new(
-        main_loop: &'owner mut MainGenerationLoop,
-        shrink_target: TestResult,
-        predicate: Predicate,
-    ) -> Shrinker<'owner, Predicate> {
-        assert!(predicate(&shrink_target));
-        Shrinker {
-            main_loop: main_loop,
-            _predicate: predicate,
-            shrink_target: shrink_target,
-            changes: 0,
-            expensive_passes_enabled: false,
-        }
-    }
-
-    fn predicate(&mut self, result: &TestResult) -> bool {
-        let succeeded = (self._predicate)(result);
-        if succeeded
-            && (
-          // In the presence of writes it may be the case that we thought
-          // we were going to shrink this but didn't actually succeed because
-          // the written value was used.
-          result.record.len() < self.shrink_target.record.len() || (
-            result.record.len() == self.shrink_target.record.len()  &&
-            result.record < self.shrink_target.record
-          )
-        ) {
-            self.changes += 1;
-            self.shrink_target = result.clone();
-        }
-        succeeded
-    }
-
-    fn run(&mut self) -> StepResult {
-        let mut prev = self.changes + 1;
-
-        while prev != self.changes {
-            prev = self.changes;
-            self.adaptive_delete()?;
-            self.minimize_individual_blocks()?;
-            self.minimize_duplicated_blocks()?;
-            if prev == self.changes {
-                self.expensive_passes_enabled = true;
-            }
-            if !self.expensive_passes_enabled {
-                continue;
-            }
-
-            self.reorder_blocks()?;
-            self.lower_and_delete()?;
-            self.delete_all_ranges()?;
-        }
-        Ok(())
-    }
-
-    fn lower_and_delete(&mut self) -> StepResult {
-        let mut i = 0;
-        while i < self.shrink_target.record.len() {
-            if self.shrink_target.record[i] > 0 {
-                let mut attempt = self.shrink_target.record.clone();
-                attempt[i] -= 1;
-                let (succeeded, result) = self.execute(&attempt)?;
-                if !succeeded && result.record.len() < self.shrink_target.record.len() {
-                    let mut j = 0;
-                    while j < self.shrink_target.draws.len() {
-                        // Having to copy this is an annoying consequence of lexical lifetimes -
-                        // if we borrowed it immutably then we'd not be allowed to call self.incorporate
-                        // down below. Fortunately these things are tiny structs of integers so it doesn't
-                        // really matter.
-                        let d = self.shrink_target.draws[j].clone();
-                        if d.start > i {
-                            let mut attempt2 = attempt.clone();
-                            attempt2.drain(d.start..d.end);
-                            if self.incorporate(&attempt2)? {
-                                break;
-                            }
-                        }
-                        j += 1;
-                    }
-                }
-            }
-            i += 1;
-        }
-        Ok(())
-    }
-
-    fn reorder_blocks(&mut self) -> StepResult {
-        let mut i = 0;
-        while i < self.shrink_target.record.len() {
-            let mut j = i + 1;
-            while j < self.shrink_target.record.len() {
-                assert!(i < self.shrink_target.record.len());
-                if self.shrink_target.record[i] == 0 {
-                    break;
-                }
-                if self.shrink_target.record[j] < self.shrink_target.record[i] {
-                    let mut attempt = self.shrink_target.record.clone();
-                    attempt.swap(i, j);
-                    self.incorporate(&attempt)?;
-                }
-                j += 1;
-            }
-            i += 1;
-        }
-        Ok(())
-    }
-
-    fn try_delete_range(
-        &mut self,
-        target: &TestResult,
-        i: usize,
-        k: usize,
-    ) -> Result<bool, LoopExitReason> {
-        // Attempts to delete k non-overlapping draws starting from the draw at index i.
-
-        let mut stack: Vec<(usize, usize)> = Vec::new();
-        let mut j = i;
-        while j < target.draws.len() && stack.len() < k {
-            let m = target.draws[j].start;
-            let n = target.draws[j].end;
-            assert!(m < n);
-            if m < n && (stack.len() == 0 || stack[stack.len() - 1].1 <= m) {
-                stack.push((m, n))
-            }
-            j += 1;
-        }
-
-        let mut attempt = target.record.clone();
-        while stack.len() > 0 {
-            let (m, n) = stack.pop().unwrap();
-            attempt.drain(m..n);
-        }
-
-        if attempt.len() >= self.shrink_target.record.len() {
-            Ok(false)
-        } else {
-            self.incorporate(&attempt)
-        }
-    }
-
-    fn adaptive_delete(&mut self) -> StepResult {
-        let mut i = 0;
-        let target = self.shrink_target.clone();
-
-        while i < target.draws.len() {
-            // This is an adaptive pass loosely modelled after timsort. If
-            // little or nothing is deletable here then we don't try any more
-            // deletions than the naive greedy algorithm would, but if it looks
-            // like we have an opportunity to delete a lot then we try to do so.
-
-            // What we're trying to do is to find a large k such that we can
-            // delete k but not k + 1 draws starting from this point, and we
-            // want to do that in O(log(k)) rather than O(k) test executions.
-
-            // We try a quite careful sequence of small shrinks here before we
-            // move on to anything big. This is because if we try to be
-            // aggressive too early on we'll tend to find that we lose out when
-            // the example is "nearly minimal".
-            if self.try_delete_range(&target, i, 2)? {
-                if self.try_delete_range(&target, i, 3)? && self.try_delete_range(&target, i, 4)? {
-                    let mut hi = 5;
-                    // At this point it looks like we've got a pretty good
-                    // opportunity for a long run here. We do an exponential
-                    // probe upwards to try and find some k where we can't
-                    // delete many intervals. We do this rather than choosing
-                    // that upper bound to immediately be large because we
-                    // don't really expect k to be huge. If it turns out that
-                    // it is, the subsequent example is going to be so tiny that
-                    // it doesn't really matter if we waste a bit of extra time
-                    // here.
-                    while self.try_delete_range(&target, i, hi)? {
-                        assert!(hi <= target.draws.len());
-                        hi *= 2;
-                    }
-                    // We now know that we can delete the first lo intervals but
-                    // not the first hi. We preserve that property while doing
-                    // a binary search to find the point at which we stop being
-                    // able to delete intervals.
-                    let mut lo = 4;
-                    while lo + 1 < hi {
-                        let mid = lo + (hi - lo) / 2;
-                        if self.try_delete_range(&target, i, mid)? {
-                            lo = mid;
-                        } else {
-                            hi = mid;
-                        }
-                    }
-                }
-            } else {
-                self.try_delete_range(&target, i, 1)?;
-            }
-            // We unconditionally bump i because we have always tried deleting
-            // one more example than we succeeded at deleting, so we expect the
-            // next example to be undeletable.
-            i += 1;
-        }
-        return Ok(());
-    }
-
-    fn delete_all_ranges(&mut self) -> StepResult {
-        let mut i = 0;
-        while i < self.shrink_target.record.len() {
-            let start_length = self.shrink_target.record.len();
-
-            let mut j = i + 1;
-            while j < self.shrink_target.record.len() {
-                assert!(j > i);
-                let mut attempt = self.shrink_target.record.clone();
-                attempt.drain(i..j);
-                assert!(attempt.len() + (j - i) == self.shrink_target.record.len());
-                let deleted = self.incorporate(&attempt)?;
-                if !deleted {
-                    j += 1;
-                }
-            }
-            if start_length == self.shrink_target.record.len() {
-                i += 1;
-            }
-        }
-        Ok(())
-    }
-
-    fn try_lowering_value(&mut self, i: usize, v: u64) -> Result<bool, LoopExitReason> {
-        if v >= self.shrink_target.record[i] {
-            return Ok(false);
-        }
-
-        let mut attempt = self.shrink_target.record.clone();
-        attempt[i] = v;
-        let (succeeded, result) = self.execute(&attempt)?;
-        assert!(result.record.len() <= self.shrink_target.record.len());
-        let lost_bytes = self.shrink_target.record.len() - result.record.len();
-        if !succeeded && result.status == Status::Valid && lost_bytes > 0 {
-            attempt.drain(i + 1..i + lost_bytes + 1);
-            assert!(attempt.len() + lost_bytes == self.shrink_target.record.len());
-            self.incorporate(&attempt)
-        } else {
-            Ok(succeeded)
-        }
-    }
-
-    fn minimize_individual_blocks(&mut self) -> StepResult {
-        let mut i = 0;
-
-        while i < self.shrink_target.record.len() {
-            if !self.shrink_target.written_indices.contains(&i) {
-                minimize_integer(self.shrink_target.record[i], |v| {
-                    self.try_lowering_value(i, v)
-                })?;
-            }
-
-            i += 1;
-        }
-
-        Ok(())
-    }
-
-    fn calc_duplicates(&self) -> Vec<Vec<usize>> {
-        assert!(self.shrink_target.record.len() == self.shrink_target.sizes.len());
-        let mut duplicates: HashMap<(u64, u64), Vec<usize>> = HashMap::new();
-        for (i, (u, v)) in self.shrink_target
-            .record
-            .iter()
-            .zip(self.shrink_target.sizes.iter())
-            .enumerate()
-        {
-            if !self.shrink_target.written_indices.contains(&i) {
-                duplicates
-                    .entry((*u, *v))
-                    .or_insert_with(|| Vec::new())
-                    .push(i);
-            }
-        }
-
-        let mut result: Vec<Vec<usize>> = duplicates
-            .drain()
-            .filter_map(|(_, elements)| {
-                if elements.len() > 1 {
-                    Some(elements)
-                } else {
-                    None
-                }
-            })
-            .collect();
-        result.sort_by_key(|v| Reverse(v.len()));
-        result
-    }
-
-    fn minimize_duplicated_blocks(&mut self) -> StepResult {
-        let mut i = 0;
-        let mut targets = self.calc_duplicates();
-        while i < targets.len() {
-            let target = mem::replace(&mut targets[i], Vec::new());
-            i += 1;
-            assert!(target.len() > 0);
-            let v = self.shrink_target.record[target[0]];
-            let base = self.shrink_target.record.clone();
-
-            let w = minimize_integer(v, |t| {
-                let mut attempt = base.clone();
-                for i in &target {
-                    attempt[*i] = t
-                }
-                self.incorporate(&attempt)
-            })?;
-            if w != v {
-                targets = self.calc_duplicates();
-            }
-        }
-        Ok(())
-    }
-
-    fn execute(&mut self, buf: &DataStream) -> Result<(bool, TestResult), LoopExitReason> {
-        // TODO: Later there will be caching here
-        let result = self.main_loop.execute(DataSource::from_vec(buf.clone()))?;
-        Ok((self.predicate(&result), result))
-    }
-
-    fn incorporate(&mut self, buf: &DataStream) -> Result<bool, LoopExitReason> {
-        assert!(
-            buf.len() <= self.shrink_target.record.len(),
-            "Expected incorporate to not increase length, but buf.len() = {} \
-             while shrink target was {}",
-            buf.len(),
-            self.shrink_target.record.len()
-        );
-        if buf.len() == self.shrink_target.record.len() {
-            assert!(buf < &self.shrink_target.record);
-        }
-        if self.shrink_target.record.starts_with(buf) {
-            return Ok(false);
-        }
-        let (succeeded, _) = self.execute(buf)?;
-        Ok(succeeded)
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-enum EngineState {
-    AwaitingCompletion,
-    ReadyToProvide,
-}
-
-#[derive(Debug)]
-pub struct Engine {
-    // The next response from the main loop. Once
-    // this is set to Some(Finished(_)) it stays that way,
-    // otherwise it is cleared on access.
-    loop_response: Option<LoopCommand>,
-
-    state: EngineState,
-
-    // Communication channels with the main testing loop
-    handle: Option<thread::JoinHandle<()>>,
-    receiver: Receiver<LoopCommand>,
-    sender: SyncSender<TestResult>,
-}
-
-impl Clone for Engine {
-    fn clone(&self) -> Engine {
-        panic!("BUG: The Engine was unexpectedly cloned");
-    }
-}
-
-impl Engine {
-    pub fn new(max_examples: u64, seed: &[u32]) -> Engine {
-        let (send_local, recv_remote) = sync_channel(1);
-        let (send_remote, recv_local) = sync_channel(1);
-
-        let main_loop = MainGenerationLoop {
-            max_examples: max_examples,
-            random: ChaChaRng::from_seed(seed),
-            sender: send_remote,
-            receiver: recv_remote,
-            best_example: None,
-            valid_examples: 0,
-            invalid_examples: 0,
-            interesting_examples: 0,
-        };
-
-        let handle = thread::Builder::new()
-            .name("Hypothesis main loop".to_string())
-            .spawn(move || {
-                main_loop.run();
-            })
-            .unwrap();
-
-        Engine {
-            loop_response: None,
-            sender: send_local,
-            receiver: recv_local,
-            handle: Some(handle),
-            state: EngineState::ReadyToProvide,
-        }
-    }
-
-    pub fn mark_finished(&mut self, source: DataSource, status: Status) -> () {
-        self.consume_test_result(source.to_result(status))
-    }
-
-    pub fn next_source(&mut self) -> Option<DataSource> {
-        assert!(self.state == EngineState::ReadyToProvide);
-        self.state = EngineState::AwaitingCompletion;
-
-        self.await_loop_response();
-
-        let mut local_result = None;
-        mem::swap(&mut local_result, &mut self.loop_response);
-
-        match local_result {
-            Some(LoopCommand::RunThis(source)) => return Some(source),
-            None => panic!("BUG: Loop response should not be empty at this point"),
-            _ => {
-                self.loop_response = local_result;
-                return None;
-            }
-        }
-    }
-
-    pub fn best_source(&self) -> Option<DataSource> {
-        match &self.loop_response {
-            &Some(LoopCommand::Finished(
-                _,
-                MainGenerationLoop {
-                    best_example: Some(ref result),
-                    ..
-                },
-            )) => Some(DataSource::from_vec(result.record.clone())),
-            _ => None,
-        }
-    }
-
-    fn consume_test_result(&mut self, result: TestResult) -> () {
-        assert!(self.state == EngineState::AwaitingCompletion);
-        self.state = EngineState::ReadyToProvide;
-
-        if self.has_shutdown() {
-            return ();
-        }
-
-        // NB: Deliberately not matching on result. If this fails,
-        // that's OK - it means the loop has shut down and when we ask
-        // for data from it we'll get its shutdown response.
-        let _ = self.sender.send(result);
-    }
-
-    pub fn was_unsatisfiable(&self) -> bool {
-        match &self.loop_response {
-            &Some(LoopCommand::Finished(_, ref main_loop)) => {
-                main_loop.interesting_examples == 0 && main_loop.valid_examples == 0
-            }
-            _ => false,
-        }
-    }
-
-    fn has_shutdown(&mut self) -> bool {
-        match &self.loop_response {
-            &Some(LoopCommand::Finished(..)) => true,
-            _ => false,
-        }
-    }
-
-    fn await_thread_termination(&mut self) {
-        let mut maybe_handle = None;
-        mem::swap(&mut self.handle, &mut maybe_handle);
-        if let Some(handle) = maybe_handle {
-            if let Err(boxed_msg) = handle.join() {
-                // FIXME: This is awful but as far as I can tell this is
-                // genuinely the only way to get the actual message out of the
-                // panic in the child thread! It's boxed as an Any, and the
-                // debug of Any just says "Any". Fortunately the main loop is
-                // very much under our control so this doesn't matter too much
-                // here, but yuck!
-                if let Some(msg) = boxed_msg.downcast_ref::<&str>() {
-                    panic!(msg.to_string());
-                } else if let Some(msg) = boxed_msg.downcast_ref::<String>() {
-                    panic!(msg.clone());
-                } else {
-                    panic!("BUG: Unexpected panic format in main loop");
-                }
-            }
-        }
-    }
-
-    fn await_loop_response(&mut self) -> () {
-        if self.loop_response.is_none() {
-            match self.receiver.recv() {
-                Ok(response) => {
-                    self.loop_response = Some(response);
-                    if self.has_shutdown() {
-                        self.await_thread_termination();
-                    }
-                }
-                Err(_) => {
-                    self.await_thread_termination();
-                    panic!("BUG: Unexpected silent termination of generation loop.")
-                }
-            }
-        }
-    }
-}

data/src/intminimize.rs

@@ -1,149 +0,0 @@
-use std::cmp::min;
-
-const SMALL: u64 = 5;
-
-struct Minimizer<'a, F: 'a> {
-    criterion: &'a mut F,
-    best: u64,
-}
-
-impl<'a, F, T> Minimizer<'a, F>
-where
-    F: 'a + FnMut(u64) -> Result<bool, T>,
-{
-    fn test(&mut self, candidate: u64) -> Result<bool, T> {
-        if candidate == self.best {
-            return Ok(true);
-        }
-        if candidate > self.best {
-            return Ok(false);
-        }
-        let result = (self.criterion)(candidate)?;
-        if result {
-            self.best = candidate;
-        }
-        Ok(result)
-    }
-
-    fn modify<G>(&mut self, g: G) -> Result<bool, T>
-    where
-        G: Fn(u64) -> u64,
-    {
-        let x = g(self.best);
-        self.test(x)
-    }
-}
-
-pub fn minimize_integer<F, T>(start: u64, mut criterion: F) -> Result<u64, T>
-where
-    F: FnMut(u64) -> Result<bool, T>,
-{
-    if start == 0 {
-        return Ok(start);
-    }
-
-    for i in 0..min(start, SMALL) {
-        if criterion(i)? {
-            return Ok(i);
-        }
-    }
-    if start <= SMALL {
-        return Ok(start);
-    }
-
-    let mut minimizer = Minimizer {
-        best: start,
-        criterion: &mut criterion,
-    };
-
-    loop {
-        if !minimizer.modify(|x| x >> 1)? {
-            break;
-        }
-    }
-
-    for i in 0..64 {
-        minimizer.modify(|x| x ^ (1 << i))?;
-    }
-
-    assert!(minimizer.best >= SMALL);
-
-    for i in 0..64 {
-        let left_mask = 1 << i;
-        let mut right_mask = left_mask >> 1;
-        while right_mask != 0 {
-            minimizer.modify(|x| {
-                if x & left_mask == 0 || x & right_mask != 0 {
-                    x
-                } else {
-                    x ^ (right_mask | left_mask)
-                }
-            })?;
-            right_mask >>= 1;
-        }
-    }
-
-    if !minimizer.modify(|x| x - 1)? {
-        return Ok(minimizer.best);
-    }
-
-    let mut lo = 0;
-    let mut hi = minimizer.best;
-    while lo + 1 < hi {
-        let mid = lo + (hi - lo) / 2;
-        if minimizer.test(mid)? {
-            hi = mid;
-        } else {
-            lo = mid;
-        }
-    }
-
-    Ok(minimizer.best)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn non_failing_minimize<F>(start: u64, criterion: F) -> u64
-    where
-        F: Fn(u64) -> bool,
-    {
-        let mut best = start;
-
-        loop {
-            let ran: Result<u64, ()> = minimize_integer(best, |x| Ok(criterion(x)));
-            let result = ran.unwrap();
-            assert!(result <= best);
-            if result == best {
-                return best;
-            }
-            best = result;
-        }
-    }
-
-    #[test]
-    fn minimize_down_to() {
-        let n = non_failing_minimize(100, |x| x >= 10);
-        assert_eq!(n, 10);
-    }
-
-    #[test]
-    fn unset_relevant_bits() {
-        let x = 0b101010101010;
-        let y = 0b111111111111;
-        let n = non_failing_minimize(y, |k| k & x == x);
-        assert_eq!(n, x);
-    }
-
-    #[test]
-    fn sort_bits() {
-        let x: u64 = 0b1011011011000111;
-        let y: u64 = 0b0000001111111111;
-        let c = x.count_ones();
-        assert_eq!(c, y.count_ones());
-
-        let n = non_failing_minimize(x, |k| k.count_ones() == c);
-        assert_eq!(y, n);
-    }
-}