hypothesis-specs 0.0.3

data/lib/hypothesis/testcase.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hypothesis
+  # A TestCase class provides a concrete representation of
+  # an executing test case. You do not normally need to use this
+  # within the body of the test, but it exists to be used as
+  # an argument to {Hypothesis::Possibilities::built_as}.
+  # @!visibility private
+  class TestCase
+    # @!visibility private
+    attr_reader :draws, :print_log, :print_draws, :wrapped_data
+
+    # @!visibility private
+    def initialize(wrapped_data, print_draws: false, record_draws: false)
+      @wrapped_data = wrapped_data
+
+      @draws = [] if record_draws
+      @print_log = [] if print_draws
+      @depth = 0
+    end
+
+    def assume(condition)
+      raise UnsatisfiedAssumption unless condition
+    end
+
+    # @!visibility private
+    def any(possible = nil, name: nil, &block)
+      top_level = @depth.zero?
+
+      begin
+        @depth += 1
+        possible ||= block
+        result = possible.provide(&block)
+        if top_level
+          draws&.push(result)
+          print_log&.push([name, result.inspect])
+        end
+        result
+      ensure
+        @depth -= 1
+      end
+    end
+  end
+end

data/lib/hypothesis/world.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Hypothesis
+  module World
+    class << self
+        attr_accessor :current_engine
+    end
+  end
+end

data/src/data.rs

@@ -0,0 +1,99 @@
+// Module representing core data types that Hypothesis
+// needs.
+
+use rand::{ChaChaRng, Rng};
+
+pub type DataStream = Vec<u64>;
+
+#[derive(Debug, Clone)]
+pub struct FailedDraw;
+
+#[derive(Debug, Clone)]
+enum BitGenerator {
+    Random(ChaChaRng),
+    Recorded(DataStream),
+}
+
+// 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,
+}
+
+impl DataSource {
+    pub fn bits(&mut self, n_bits: u64) -> Result<u64, FailedDraw> {
+        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);
+    }
+
+    fn new(generator: BitGenerator) -> DataSource {
+        return DataSource {
+            bitgenerator: generator,
+            record: DataStream::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 to_result(self, status: Status) -> TestResult {
+        TestResult {
+            record: self.record,
+            status: status,
+        }
+    }
+}
+
+// Status indicates the result that we got from completing
+// a single test execution.
+#[derive(Debug, Clone, Eq, PartialEq)]
+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,
+}

data/src/distributions.rs

@@ -0,0 +1,238 @@
+use data::{DataSource, FailedDraw};
+
+use std::collections::BinaryHeap;
+use std::mem;
+use std::cmp::{Ord, Ordering, PartialOrd, Reverse};
+
+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)?;
+    return Ok(probe >= u64::max_value() - truthy + 1);
+}
+
+pub fn bounded_int(source: &mut DataSource, max: u64) -> Draw<u64> {
+    let bitlength = 64 - max.leading_zeros() as u64;
+    if bitlength == 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,
+        }
+    }
+
+    fn draw_until(&self, source: &mut DataSource, value: bool) -> Result<(), FailedDraw> {
+        // Force a draw until we get the desired outcome. By having this we get much better
+        // shrinking when min_size or max_size are set because all decisions are represented
+        // somewhere in the bit stream.
+        loop {
+            let d = weighted(source, self.p_continue)?;
+            if d == value {
+                return Ok(());
+            }
+        }
+    }
+
+    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.current_count < self.min_count {
+            self.draw_until(source, true)?;
+            self.current_count += 1;
+            return Ok(true);
+        } else if self.current_count >= self.max_count {
+            self.draw_until(source, false)?;
+            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

@@ -0,0 +1,400 @@
+// 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::sync::mpsc::{sync_channel, Receiver, SyncSender};
+use std::thread;
+use std::mem;
+
+use data::{DataSource, DataStream, Status, TestResult};
+
+#[derive(Debug, Clone)]
+enum LoopExitReason {
+    Complete,
+    MaxExamples,
+    //MaxShrinks,
+    Shutdown,
+    //Error(String),
+}
+
+#[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,
+    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,
+        }
+    }
+
+    fn predicate(&mut self, result: &TestResult) -> bool {
+        let succeeded = (self._predicate)(result);
+        if succeeded {
+            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.binary_search_blocks()?;
+            self.remove_intervals()?;
+        }
+        Ok(())
+    }
+
+    fn remove_intervals(&mut self) -> StepResult {
+        // TODO: Actually track the data we need to make this
+        // not quadratic.
+        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 binary_search_blocks(&mut self) -> StepResult {
+        let mut i = 0;
+
+        let mut attempt = self.shrink_target.record.clone();
+
+        while i < self.shrink_target.record.len() {
+            assert!(attempt.len() >= self.shrink_target.record.len());
+
+            let mut hi = self.shrink_target.record[i];
+
+            if hi > 0 {
+                attempt[i] = 0;
+                let zeroed = self.incorporate(&attempt)?;
+                if !zeroed {
+                    let mut lo = 0;
+                    // Binary search to find the smallest value we can
+                    // replace this with.
+                    while lo + 1 < hi {
+                        let mid = lo + (hi - lo) / 2;
+                        attempt[i] = mid;
+                        let succeeded = self.incorporate(&attempt)?;
+                        if succeeded {
+                            attempt = self.shrink_target.record.clone();
+                            hi = mid;
+                        } else {
+                            attempt[i] = self.shrink_target.record[i];
+                            lo = mid;
+                        }
+                    }
+                    attempt[i] = hi;
+                } else {
+                    attempt = self.shrink_target.record.clone();
+                }
+            }
+
+            i += 1;
+        }
+
+        Ok(())
+    }
+
+    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 result = self.main_loop.execute(DataSource::from_vec(buf.clone()))?;
+        return Ok(self.predicate(&result));
+    }
+}
+
+#[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.")
+                }
+            }
+        }
+    }
+}