minitest-proptest 0.0.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e01d66af6e62a9d5931cd1da501b08679e8f78a4aa625aa694c28029ae5228a9
-  data.tar.gz: 3d99ae675bbeac0c89c807a535c7400fc0806a223a68c0d1a50eb2cb2917c148
+  metadata.gz: '0596e6f6a66614dba0199eccc4e18a5bf6b869fd0db46dff7636a8772eacb75b'
+  data.tar.gz: a956c579c5bb355a5b687f64109917918870dd7dac1323a18a72d44e4ca623a6
 SHA512:
-  metadata.gz: 2a4abe803c73e8e254dfa2022e5bcbb84f3bdf6c1e502f7fa34d3d95c06dad05f44be371a935907135f8bb7f67cd1240b24835c7cf233e1fd85f52608ed53ac8
-  data.tar.gz: dd81efa85c34580d0d29cfbf21ab5042f0af14f493b7041712a61fd491638c5a6e02d79e758a459a03671110bf057474f9fae34c96c96607e8c0f1e7853c2e31
+  metadata.gz: d6206c7a778b9b55e0674e204afea71721eb8b6e4fe2257691cc1cefd5e76885eff08d648f9a61172806872f1abe5f1b232186fcc803e6fcc560241fd71fac8c
+  data.tar.gz: 1ca1d04ddcdecb9f661e0af6cffc87dda30af6a9b06bb6fe406a5f27ec445a0cf3cd9ac4d9050b4a243ab40d76d066358f6cf9612181cc546a2076b76a7d9041

data/lib/minitest/proptest/gen/value_generator.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Proptest
+    class Gen
+      # Methods for value generation
+      class ValueGenerator
+        attr_accessor :entropy
+        attr_writer :type_parameters
+
+        def self.with_shrink_function(&f)
+          define_method(:shrink_function, &f)
+          self
+        end
+
+        def self.with_score_function(&f)
+          define_method(:score_function, &f)
+          self
+        end
+
+        def self.with_append(bound_min, bound_max, &f)
+          define_singleton_method(:bound_min) { bound_min }
+          define_singleton_method(:bound_max) { bound_max }
+          define_method(:append) do |other|
+            @value = f.call(value, other.value)
+            self
+          end
+          self
+        end
+
+        def self.with_empty(&f)
+          define_singleton_method(:empty) do |gen|
+            temp = new(gen)
+            temp.instance_variable_set(:@value, f.call)
+            temp
+          end
+          self
+        end
+
+        def self.bound_max
+          1
+        end
+
+        def self.bound_min
+          0
+        end
+
+        # append is not expected to be called unless overridden
+        def append(_other)
+          self
+        end
+
+        def self.empty(gen)
+          self.new(gen)
+        end
+
+        def force(v)
+          temp = self.class.new(ArgumentError)
+          temp.instance_variable_set(:@value, v)
+          temp.type_parameters = @type_parameters
+          temp
+        end
+
+        def generate_value
+          gen = @generated.reduce(@generator) do |g, val|
+            g.call(val)
+            g
+          end
+
+          while gen.is_a?(Proc) || gen.is_a?(Method)
+            gen = gen.call(*@type_parameters.map(&:value))
+            gen = gen.value if gen.is_a?(ValueGenerator)
+          end
+
+          gen
+        end
+
+        def value
+          return false if @value == false
+
+          @value ||= generate_value
+        end
+
+        def prefix_entropy_generation(vals)
+          @generated = vals + @generated
+        end
+
+        def score
+          value
+          fs = @type_parameters.map { |x| x.method(:score_function) }
+          score_function(*fs, value)
+        end
+
+        def score_function(v)
+          v.to_i.abs
+        end
+
+        def shrink_candidates
+          fs = @type_parameters.map { |x| x.method(:shrink_function) }
+          os = score
+          candidates = shrink_function(*fs, value)
+          candidates
+            .map    { |c| [force(c).score, c] }
+            .reject { |(s, _)| s > os }
+            .sort   { |x, y| x.first <=> y.first }
+            .uniq
+        end
+
+        def shrink_function(x)
+          [x.itself]
+        end
+
+        def shrink_parameter(x)
+          @shrink_parameter.call(x)
+        end
+
+        # Generator helpers
+
+        def sized(n)
+          entropy.call(n + 1)
+        end
+
+        def one_of(r)
+          r.to_a[sized(r.to_a.length - 1)]
+        end
+      end
+    end
+  end
+end

data/lib/minitest/proptest/gen.rb

@@ -1,128 +1,12 @@
+# frozen_string_literal: true
+
+require 'minitest/proptest/gen/value_generator'
+
 module Minitest
   module Proptest
+    # Generic value generation and shrinking implementations, and
+    # support for built-in types.
     class Gen
-      class ValueGenerator
-        attr_accessor :entropy
-        attr_writer :type_parameters
-
-        def self.with_shrink_function(&f)
-          define_method(:shrink_function, &f)
-          self
-        end
-
-        def self.with_score_function(&f)
-          define_method(:score_function, &f)
-          self
-        end
-
-        def self.with_append(bound_min, bound_max, &f)
-          define_singleton_method(:bound_max) { bound_max }
-          define_singleton_method(:bound_min) { bound_min }
-          define_method(:append) do |other|
-            @value = f.call(value, other.value)
-            self
-          end
-          self
-        end
-
-        def self.with_empty(&f)
-          define_singleton_method(:empty) do |gen|
-            temp = new(gen)
-            temp.instance_variable_set(:@value, f.call)
-            temp
-          end
-          self
-        end
-
-        def self.bound_max
-          1
-        end
-
-        def self.bound_min
-          0
-        end
-
-        # append is not expected to be called unless overridden
-        def append(other)
-          self
-        end
-
-        def self.empty(gen)
-          self.new(gen)
-        end
-
-        def force(v)
-          temp = self.class.new(ArgumentError)
-          temp.instance_variable_set(:@value, v)
-          temp.type_parameters = @type_parameters
-          temp
-        end
-
-        def generate_value
-          gen = @generated.reduce(@generator) do |gen, val|
-            gen.call(val)
-            gen
-          end
-
-          while gen.is_a?(Proc) || gen.is_a?(Method)
-            gen = gen.call(*@type_parameters.map(&:value))
-            if gen.is_a?(ValueGenerator)
-              gen = gen.value
-            end
-          end
-
-          gen
-        end
-
-        def value
-          return false if @value == false
-          @value ||= generate_value
-        end
-
-        def prefix_entropy_generation(vals)
-          @generated = vals + @generated
-        end
-
-        def score
-          value
-          fs = @type_parameters.map { |x| x.method(:score_function) }
-          score_function(*fs, value)
-        end
-
-        def score_function(v)
-          v.to_i.abs
-        end
-
-        def shrink_candidates
-          fs = @type_parameters.map { |x| x.method(:shrink_function) }
-          os = score
-          candidates = shrink_function(*fs, value)
-          candidates
-            .map    { |c| [force(c).score, c] }
-            .reject { |(s, _)| s > os }
-            .sort   { |x, y| x.first <=> y.first }
-            .uniq
-        end
-
-        def shrink_function(x)
-          [x.itself]
-        end
-
-        def shrink_parameter(x)
-          @shrink_parameter.call(x)
-        end
-
-        # Generator helpers
-
-        def sized(n)
-          entropy.call(n + 1)
-        end
-
-        def one_of(r)
-          r.to_a[sized(r.to_a.length - 1)]
-        end
-      end
-
       class Int8 < Integer; end
       class Int16 < Integer; end
       class Int32 < Integer; end
@@ -146,7 +30,7 @@ module Minitest
       instance_variable_set(:@_generators, {})
 
       def self.create_type_constructor(arity, classes)
-        constructor = ->(c1) do
+        constructor = ->(_c1) do
           if classes.length == arity
             f.call(*classes)
           else
@@ -168,8 +52,8 @@ module Minitest
 
         new_class.define_method(:generator, &f)
 
-        instance_variable_get(:@_generators)[klass] = new_class #.method(:new)
-        self.const_set((klass.name + 'Gen').split('::').last, new_class)
+        instance_variable_get(:@_generators)[klass] = new_class
+        self.const_set("#{klass.name}Gen".split('::').last, new_class)
         new_class
       end
 
@@ -197,11 +81,11 @@ module Minitest
           end
         else
           classgen = ->() do
-            classes[1..-1].map do |c|
-              if c.is_a?(Array)
-                self.for(*c)
+            classes[1..].map do |k|
+              if k.is_a?(Array)
+                self.for(*k)
               else
-                self.for(c)
+                self.for(k)
               end
             end
           end
@@ -235,28 +119,60 @@ module Minitest
 
         until y == 0
           candidates << (x - y)
-          candidates << y
-          # Prevent negative integral from preventing termination
+          candidates << y if y.abs < x.abs
           y = (y / 2.0).to_i
         end
 
         candidates
-          .flat_map { |i| [i - 1, i, i + 1] }
-          .reject   { |i| i.abs >= x.abs }
+      end
+
+      score_float = ->(f) do
+        if f.nan? || f.infinite?
+          0
+        else
+          f.abs.ceil
+        end
       end
 
       float_shrink = ->(x) do
+        return [] if x.nan? || x.infinite? || x.zero?
+
         candidates = [Float::NAN, Float::INFINITY]
         y = x
 
-        until y == 0 || y
+        until y.zero? || y.to_f.infinite? || y.to_f.nan?
           candidates << (x - y)
           y = (y / 2.0).to_i
         end
 
-        candidates
-          .flat_map { |i| [i - 1, i, i + 1] }
-          .reject   { |i| i.abs >= x.abs }
+        score = score_float.call(x)
+        candidates.reduce([]) do |cs, c|
+          cs + (score_float.call(c) < score ? [c.to_f] : [])
+        end
+      end
+
+      score_complex = ->(c) do
+        r = if c.real.to_f.nan? || c.real.to_f.infinite?
+              0
+            else
+              c.real.abs.ceil
+            end
+        i = if c.imaginary.to_f.nan? || c.imaginary.to_f.infinite?
+              0
+            else
+              c.imaginary.abs.ceil
+            end
+        r + i
+      end
+
+      complex_shrink = ->(x) do
+        rs = float_shrink.call(x.real)
+        is = float_shrink.call(x.imaginary)
+
+        score = score_complex.call(x)
+        rs.flat_map { |real| is.map { |imag| Complex(real, imag) } }
+          .reject { |c| score_complex.call(c) >= score }
+          .uniq
       end
 
       # List shrink adapted from QuickCheck
@@ -268,7 +184,7 @@ module Minitest
         elsif xs2.empty?
           [[]]
         else
-          [xs2] + list_remove.call(k, (n-k), xs2).map { |ys| xs1 + ys }
+          [xs2] + list_remove.call(k, (n - k), xs2).map { |ys| xs1 + ys }
         end
       end
 
@@ -308,11 +224,39 @@ module Minitest
         else
           h1 = xs1.reduce({}) { |c, e| c.merge({ e => h[e] }) }
           h2 = xs2.reduce({}) { |c, e| c.merge({ e => h[e] }) }
-          [h1, h2] + list_remove.call(k, (n-k), h2).map { |ys| h1.merge(ys.to_h) }
+          [h1, h2] + list_remove.call(k, (n - k), h2).map { |ys| h1.merge(ys.to_h) }
+        end
+      end
+
+      range_shrink = ->(f, r) do
+        xs = f.call(r.first)
+        ys = f.call(r.last)
+
+        xs.flat_map { |x| ys.map { |y| x <= y ? (x..y) : (y..x) } }
+      end
+
+      score_rational = ->(r) do
+        (r.numerator * r.denominator).abs
+      end
+
+      rational_shrink = ->(r) do
+        ns = integral_shrink.call(r.numerator)
+        ds = integral_shrink.call(r.denominator)
+
+        score = score_rational.call(r)
+        ns.flat_map do |n|
+          ds.reduce([]) do |rs, d|
+            if d.zero?
+              rs
+            else
+              rational = Rational(n, d)
+              rs + (score_rational.call(rational) < score ? [rational] : [])
+            end
+          end
         end
       end
 
-      hash_shrink = ->(fk, fv, h) do
+      hash_shrink = ->(_fk, _fv, h) do
         candidates = []
         n          = h.length
         k          = n
@@ -333,40 +277,40 @@ module Minitest
           -(((r & (MAX_SIZE ^ SIGN_BIT)) - 1) ^ (MAX_SIZE ^ SIGN_BIT))
         end
       end.with_shrink_function do |i|
-        i = if (i & SIGN_BIT).zero?
+        j = if (i & SIGN_BIT).zero?
               i
             else
               -(((i & (MAX_SIZE ^ SIGN_BIT)) - 1) ^ (MAX_SIZE ^ SIGN_BIT))
             end
-        integral_shrink.call(i)
+        integral_shrink.call(j)
       end
 
       generator_for(Int8) do
         r = sized(0xff)
         (r & 0x80).zero? ? r : -(((r & 0x7f) - 1) ^ 0x7f)
       end.with_shrink_function do |i|
-        i = (i & 0x80).zero? ? i : -(((i & 0x7f) - 1) ^ 0x7f)
-        integral_shrink.call(i)
+        j = (i & 0x80).zero? ? i : -(((i & 0x7f) - 1) ^ 0x7f)
+        integral_shrink.call(j)
       end
 
       generator_for(Int16) do
         r = sized(0xffff)
         (r & 0x8000).zero? ? r : -(((r & 0x7fff) - 1) ^ 0x7fff)
       end.with_shrink_function do |i|
-        i = (i & 0x8000).zero? ? i : -(((i & 0x7fff) - 1) ^ 0x7fff)
-        integral_shrink.call(i)
+        j = (i & 0x8000).zero? ? i : -(((i & 0x7fff) - 1) ^ 0x7fff)
+        integral_shrink.call(j)
       end
 
       generator_for(Int32) do
         r = sized(0xffffffff)
         (r & 0x80000000).zero? ? r : -(((r & 0x7fffffff) - 1) ^ 0x7fffffff)
       end.with_shrink_function do |i|
-        i = if (i & 0x80000000).zero?
+        j = if (i & 0x80000000).zero?
               i
             else
               -(((i & 0x7fffffff) - 1) ^ 0x7fffffff)
             end
-        integral_shrink.call(i)
+        integral_shrink.call(j)
       end
 
       generator_for(Int64) do
@@ -377,12 +321,12 @@ module Minitest
           -(((r & 0x7fffffffffffffff) - 1) ^ 0x7fffffffffffffff)
         end
       end.with_shrink_function do |i|
-        i = if (i & 0x8000000000000000).zero?
+        j = if (i & 0x8000000000000000).zero?
               i
             else
               -(((i & 0x7fffffffffffffff) - 1) ^ 0x7fffffffffffffff)
             end
-        integral_shrink.call(i)
+        integral_shrink.call(j)
       end
 
       generator_for(UInt8) do
@@ -416,67 +360,51 @@ module Minitest
         (0..3)
           .map { |y| ((bits & (0xff << (8 * y))) >> (8 * y)).chr }
           .join
-          .unpack('f')
-          .first
+          .unpack1('f')
       end.with_shrink_function do |f|
         float_shrink.call(f)
-      end.with_score_function do |f|
-        if f.nan? || f.infinite?
-          0
-        else
-          f.abs.ceil
-        end
-      end
+      end.with_score_function(&score_float)
 
-      generator_for(Float64) do
-        bits = sized(0xffffffffffffffff)
+      float64build = ->(bits) do
         (0..7)
           .map { |y| ((bits & (0xff << (8 * y))) >> (8 * y)).chr }
           .join
-          .unpack('d')
-          .first
+          .unpack1('d')
+      end
+
+      generator_for(Float64) do
+        bits = sized(0xffffffffffffffff)
+        float64build.call(bits)
       end.with_shrink_function do |f|
         float_shrink.call(f)
-      end.with_score_function do |f|
-        if f.nan? || f.infinite?
-          0
-        else
-          f.abs.ceil
-        end
-      end
+      end.with_score_function(&score_float)
 
       generator_for(Float) do
         bits = sized(0xffffffffffffffff)
-        (0..7)
-          .map { |y| ((bits & (0xff << (8 * y))) >> (8 * y)).chr }
-          .join
-          .unpack('d')
-          .first
+        float64build.call(bits)
       end.with_shrink_function do |f|
         float_shrink.call(f)
-      end.with_score_function do |f|
-        if f.nan? || f.infinite?
-          0
-        else
-          f.abs.ceil
-        end
-      end
+      end.with_score_function(&score_float)
+
+      generator_for(Complex) do
+        real = sized(0xffffffffffffffff)
+        imag = sized(0xffffffffffffffff)
+        Complex(float64build.call(real), float64build.call(imag))
+      end.with_shrink_function do |c|
+        complex_shrink.call(c)
+      end.with_score_function(&score_complex)
 
       generator_for(ASCIIChar) do
         sized(0x7f).chr
       end.with_shrink_function do |c|
         integral_shrink.call(c.ord).reject(&:negative?).map(&:chr)
-      end.with_score_function do |c|
-        c.ord
-      end
+      end.with_score_function(&:ord)
 
       generator_for(Char) do
         sized(0xff).chr
       end.with_shrink_function do |c|
         integral_shrink.call(c.ord).reject(&:negative?).map(&:chr)
-      end.with_score_function do |c|
-        c.ord
-      end
+      end.with_score_function(&:ord)
 
       generator_for(String) do
         sized(0xff).chr
@@ -490,7 +418,7 @@ module Minitest
         end
       end.with_append(0, 0x20) do |x, y|
         x + y
-      end.with_empty { "" }
+      end.with_empty { '' }
 
       generator_for(Array) do |x|
         [x]
@@ -513,10 +441,33 @@ module Minitest
         end
       end.with_append(0, 0x10) do |xm, ym|
         xm.merge(ym)
-      end.with_empty { Hash.new }
+      end.with_empty { {} }
+
+      generator_for(Range) do |x|
+        (x..x)
+      end.with_shrink_function(&range_shrink).with_score_function do |f, r|
+        r.to_a.reduce(1) do |c, x|
+          y = f.call(x).abs
+          c * (y > 0 ? y + 1 : 1)
+        end.to_i * r.to_a.length
+      end.with_append(2, 2) do |ra, rb|
+        xs = [ra.first, ra.last, rb.first, rb.last].sort
+        (xs.first..xs.last)
+      end
+
+      generator_for(Rational) do
+        n = sized(MAX_SIZE)
+        d = sized(MAX_SIZE - 1) + 1
+        if (n & SIGN_BIT).zero?
+          Rational(n, d)
+        else
+          Rational(-(((n & (MAX_SIZE ^ SIGN_BIT)) - 1) ^ (MAX_SIZE ^ SIGN_BIT)), d)
+        end
+      end.with_shrink_function(&rational_shrink)
+         .with_score_function(&score_rational)
 
       generator_for(Bool) do
-        sized(0x1).even? ? false : true
+        sized(0x1).odd?
       end.with_score_function do |_|
         1
       end

data/lib/minitest/proptest/property.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 module Minitest
   module Proptest
+    # Property evaluation - status, scoring, shrinking
     class Property
+      require 'minitest/assertions'
+      include Minitest::Assertions
+
+      attr_reader :calls, :result, :status, :trivial
+
+      attr_accessor :assertions
 
-      attr_reader :result, :status, :trivial
       def initialize(
         # The function which proves the property
         test_proc,
@@ -19,7 +27,10 @@ module Minitest
         max_size: 0x100,
         # Maximum number of shrink attempts (default of half of max unsigned int
         # on the system architecture adopted from QuickCheck
-        max_shrinks: 0x7fffffffffffffff
+        max_shrinks: 0x7fffffffffffffff,
+        # Previously discovered counter-example.  If this exists, it should be
+        # run before any test cases are generated.
+        previous_failure: []
       )
         @test_proc         = test_proc
         @random            = random.call
@@ -30,15 +41,19 @@ module Minitest
         @max_shrinks       = max_shrinks
         @status            = Status.unknown
         @trivial           = false
+        @valid_test_case   = true
         @result            = nil
         @exception         = nil
         @calls             = 0
+        @assertions        = 0
         @valid_test_cases  = 0
         @generated         = []
         @arbitrary         = nil
+        @previous_failure  = previous_failure.to_a
       end
 
       def run!
+        rerun!
         iterate!
         shrink!
       end
@@ -54,33 +69,43 @@ module Minitest
         end
       end
 
+      def where(&b)
+        @valid_test_case &= b.call
+      end
+
       def explain
         prop = if @status.valid?
-                 "The property was proved to satsfaction across " +
+                 'The property was proved to satsfaction across ' \
                    "#{@valid_test_cases} assertions."
                elsif @status.invalid?
-                 "The property was determined to be invalid due to " +
-                   "#{@exception.class.name}: #{@exception.message}\n" +
-                   @exception.backtrace.map { |l| "    #{l}" }.join("\n")
+                 'The property was determined to be invalid due to ' \
+                   "#{@exception.class.name}: #{@exception.message}\n" \
+                   "#{@exception.backtrace.map { |l| "    #{l}" }.join("\n")}"
                elsif @status.overrun?
-                 "The property attempted to generate more than #{@max_size} " +
-                   "bytes of entropy, violating the property's maximum size." +
-                   "This might be rectified by increasing max_size."
+                 "The property attempted to generate more than #{@max_size} " \
+                   "bytes of entropy, violating the property's maximum " \
+                   'size.  This might be rectified by increasing max_size.'
                elsif @status.unknown?
-                 "The property has not yet been tested."
+                 'The property has not yet been tested.'
                elsif @status.interesting?
-                 "The property has found the following counterexample after " +
-                   "#{@valid_test_cases} valid " +
-                   "example#{@valid_test_cases == 1 ? '' : 's'}:\n" +
-                   @generated.map(&:value).inspect
+                 'The property has found the following counterexample after ' \
+                   "#{@valid_test_cases} valid " \
+                   "example#{@valid_test_cases == 1 ? '' : 's'}:\n" \
+                   "#{@generated.map(&:value).inspect}"
+               elsif @status.exhausted?
+                 "The property was unable to generate #{@max_success} test " \
+                   'cases before generating ' \
+                   "#{@max_success * @max_discard_ratio} rejected test " \
+                   "cases.  This might be a problem with the property's " \
+                   '`where` blocks.'
                end
         trivial = if @trivial
-                    "\nThe test does not appear to use any generated values " +
-                      "and as such is likely not generating much value.  " +
-                      "Consider reworking this test to make use of arbitrary " +
-                      "data."
+                    "\nThe test does not appear to use any generated values " \
+                      'and as such is likely not generating much value.  ' \
+                      'Consider reworking this test to make use of arbitrary ' \
+                      'data.'
                   else
-                    ""
+                    ''
                   end
         prop + trivial
       end
@@ -88,27 +113,84 @@ module Minitest
       private
 
       def iterate!
-        while continue_iterate? && @result.nil? && @valid_test_cases <= @max_success / 2
+        while continue_iterate? && @result.nil? && @valid_test_cases <= @max_success
+          @valid_test_case = true
           @generated = []
           @generator = ::Minitest::Proptest::Gen.new(@random)
           @calls += 1
-          if instance_eval(&@test_proc)
+
+          success = begin
+                      instance_eval(&@test_proc)
+                    rescue Minitest::Assertion
+                      if @valid_test_case
+                        @result = @generated
+                        @status = Status.interesting
+                      end
+                    rescue => e
+                      raise e if @valid_test_case
+                    end
+          if @valid_test_case && success
             @status = Status.valid if @status.unknown?
             @valid_test_cases += 1
-          else
+          elsif @valid_test_case
             @result = @generated
             @status = Status.interesting
           end
+
+          @status = Status.exhausted if @calls >= @max_success * (@max_discard_ratio + 1)
           @trivial = true if @generated.empty?
         end
       rescue => e
         @status = Status.invalid
         @exception = e
-        raise e
+      end
+
+      def rerun!
+        return if @previous_failure.empty?
+
+        old_generator  = @generator
+        old_random     = @random
+        old_arbitrary  = @arbitrary
+
+        index = -1
+        @arbitrary = ->(*classes) do
+          index += 1
+          raise IndexError if index >= @previous_failure.length
+
+          a = @generator.for(*classes)
+          a = a.force(@previous_failure[index])
+          @generated << a
+          @previous_failure[index]
+        end
+
+        @generator = ::Minitest::Proptest::Gen.new(@random)
+        success = begin
+                    instance_eval(&@test_proc)
+                  rescue Minitest::Assertion
+                    !@valid_test_case
+                  rescue => e
+                    if @valid_test_case
+                      @status = Status.invalid
+                      @exception = e
+                      false
+                    end
+                  end
+        if success || !@valid_test_case
+          @generated = []
+        elsif @valid_test_case
+          @result = @generated
+          @status = Status.interesting
+        end
+
+        # Clean up after we're done
+        @generator = old_generator
+        @random    = old_random
+        @arbitrary = old_arbitrary
       end
 
       def shrink!
         return if @result.nil?
+
         old_random     = @random
         old_generator  = @generator
         best_score     = @generated.map(&:score).reduce(&:+)
@@ -117,10 +199,10 @@ module Minitest
         old_arbitrary  = @arbitrary
 
         to_test = candidates
-          .map    { |x| x.map { |y| [y] } }
-          .reduce { |c, e| c.flat_map { |a| e.map { |b| a + b } } }
-          .sort   { |x, y| x.map(&:first).reduce(&:+) <=> y.map(&:first).reduce(&:+) }
-          .uniq
+                  .map    { |x| x.map { |y| [y] } }
+                  .reduce { |c, e| c.flat_map { |a| e.map { |b| a + b } } }
+                  .sort   { |x, y| x.map(&:first).reduce(&:+) <=> y.map(&:first).reduce(&:+) }
+                  .uniq
         run = { run: 0, index: -1 }
 
         @arbitrary = ->(*classes) do
@@ -134,15 +216,28 @@ module Minitest
         end
 
         while continue_shrink? && run[:run] < to_test.length
-          @generated  = []
-          run[:index] = -1
+          @generated       = []
+          run[:index]      = -1
+          @valid_test_case = true
 
           @generator = ::Minitest::Proptest::Gen.new(@random)
           if to_test[run[:run]].map(&:first).reduce(&:+) < best_score
-            unless instance_eval(&@test_proc)
+            success = begin
+                        instance_eval(&@test_proc)
+                      rescue Minitest::Assertion
+                        false
+                      rescue => e
+                        next unless @valid_test_case
+
+                        @status = Status.invalid
+                        @excption = e
+                        break
+                      end
+
+            if !success && @valid_test_case
+              # The first hit is guaranteed to be the best scoring due to the
+              # shrink candidates are pre-sorted.
               best_generated = @generated
-              # Because we pre-sorted our shrink candidates, the first hit is
-              # necessarily the best scoring
               break
             end
           end
@@ -162,14 +257,14 @@ module Minitest
         !@trivial &&
           !@status.invalid? &&
           !@status.overrun? &&
-          @valid_test_cases < @max_success &&
-          @calls < @max_success * @max_discard_ratio
+          !@status.exhausted? &&
+          @valid_test_cases < @max_success
       end
 
       def continue_shrink?
         !@trivial &&
           !@status.invalid? &&
-          !@status.overrun?
+          !@status.overrun? &&
           @calls < @max_shrinks
       end
     end

data/lib/minitest/proptest/status.rb

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 module Minitest
   module Proptest
     # Sum type representing the possible statuses of a test run.
     # Invalid, Overrun, and Interesting represent different failure classes.
+    # Exhausted represents having generated too many invalid test cases to
+    # verify the property.  This precipitates as a failure class (the property is
+    # not proved) but can be a matter of inappropriate predicates in `where`
+    # blocks.
     # Unknown represents a lack of information about the test run (typically
     # having not run to satisfaction).
     # Valid represents a test which has run to satisfaction.
@@ -21,16 +27,21 @@ module Minitest
       class Valid < Status
       end
 
+      class Exhausted < Status
+      end
+
       invalid     = Invalid.new.freeze
       interesting = Interesting.new.freeze
       overrun     = Overrun.new.freeze
       unknown     = Unknown.new.freeze
+      exhausted   = Exhausted.new.freeze
       valid       = Valid.new.freeze
 
       define_singleton_method(:invalid)     { invalid }
       define_singleton_method(:interesting) { interesting }
       define_singleton_method(:overrun)     { overrun }
       define_singleton_method(:unknown)     { unknown }
+      define_singleton_method(:exhausted)   { exhausted }
       define_singleton_method(:valid)       { valid }
 
       def invalid?
@@ -45,6 +56,10 @@ module Minitest
         self.is_a?(Unknown)
       end
 
+      def exhausted?
+        self.is_a?(Exhausted)
+      end
+
       def valid?
         self.is_a?(Valid)
       end

data/lib/minitest/proptest/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module Proptest
-    VERSION = '0.0.2'
+    VERSION = '0.2.0'
   end
 end

data/lib/minitest/proptest.rb

@@ -1,20 +1,150 @@
+# frozen_string_literal: true
+
 require 'minitest'
 require 'minitest/proptest/gen'
 require 'minitest/proptest/property'
 require 'minitest/proptest/status'
 require 'minitest/proptest/version'
+require 'yaml'
 
 module Minitest
+  class ResultsDatabase < Minitest::AbstractReporter
+    def initialize(pathname)
+      super()
+
+      results = if File.file?(pathname)
+                  YAML.load_file(pathname)
+                else
+                  {}
+                end
+      self.class.instance_variable_set(:@_results, results) unless self.class.instance_variable_defined?(:@_results)
+    end
+
+    def report
+      return unless Proptest.use_db?
+
+      File.write(Proptest.result_db, self.class.instance_variable_get(:@_results).to_yaml)
+    end
+
+    def lookup(file, classname, methodname)
+      self.class.instance_variable_get(:@_results)
+          .dig(file, classname, methodname)
+          .to_a
+    end
+
+    def record_failure(file, classname, methodname, generated)
+      return unless Proptest.use_db?
+
+      results = self.class.instance_variable_get(:@_results)
+      results[file] ||= {}
+      results[file][classname] ||= {}
+      results[file][classname][methodname] = generated
+    end
+
+    def strike_failure(file, classname, methodname)
+      return unless Proptest.use_db?
+
+      results = self.class.instance_variable_get(:@_results)
+      return unless results.key?(file)
+
+      return unless results[file].key?(classname)
+
+      results[file][classname].delete(methodname)
+      results[file].delete(classname) if results[file][classname].empty?
+      results.delete(file) if results[file].empty?
+    end
+  end
+
   module Proptest
     DEFAULT_RANDOM = Random.method(:new)
     DEFAULT_MAX_SUCCESS = 100
     DEFAULT_MAX_DISCARD_RATIO = 10
     DEFAULT_MAX_SIZE = 0x100
     DEFAULT_MAX_SHRINKS = (((1 << (1.size * 8)) - 1) / 2)
+    DEFAULT_DB_LOCATION = File.join(Dir.pwd, '.proptest_failures.yml')
+
+    self.instance_variable_set(:@_random, DEFAULT_RANDOM)
+    self.instance_variable_set(:@_max_success, DEFAULT_MAX_SUCCESS)
+    self.instance_variable_set(:@_max_discard_ratio, DEFAULT_MAX_DISCARD_RATIO)
+    self.instance_variable_set(:@_max_size, DEFAULT_MAX_SIZE)
+    self.instance_variable_set(:@_max_shrinks, DEFAULT_MAX_SHRINKS)
+    self.instance_variable_set(:@_result_db, DEFAULT_DB_LOCATION)
+    self.instance_variable_set(:@_use_db, false)
 
     def self.set_seed(seed)
       self.instance_variable_set(:@_random_seed, seed)
     end
+
+    def self.max_success=(success)
+      self.instance_variable_set(:@_max_success, success)
+    end
+
+    def self.max_discard_ratio=(discards)
+      self.instance_variable_set(:@_max_discard_ratio, discards)
+    end
+
+    def self.max_size=(size)
+      self.instance_variable_set(:@_max_size, size)
+    end
+
+    def self.max_shrinks=(shrinks)
+      self.instance_variable_set(:@_max_shrinks, shrinks)
+    end
+
+    def self.result_db=(location)
+      self.instance_variable_set(:@_result_db, File.expand_path(location))
+    end
+
+    def self.use_db!(use = true)
+      self.instance_variable_set(:@_use_db, use)
+    end
+
+    def self.seed
+      self.instance_variable_get(:@_random_seed)
+    end
+
+    def self.max_success
+      self.instance_variable_get(:@_max_success)
+    end
+
+    def self.max_discard_ratio
+      self.instance_variable_get(:@_max_discard_ratio)
+    end
+
+    def self.max_size
+      self.instance_variable_get(:@_max_size)
+    end
+
+    def self.max_shrinks
+      self.instance_variable_get(:@_max_shrinks)
+    end
+
+    def self.result_db
+      self.instance_variable_get(:@_result_db)
+    end
+
+    def self.use_db?
+      self.instance_variable_get(:@_use_db)
+    end
+
+    def self.record_failure(file, classname, methodname, generated)
+      self.instance_variable_get(:@_results)
+          .record_failure(file, classname, methodname, generated)
+    end
+
+    def self.strike_failure(file, classname, methodname)
+      self.instance_variable_get(:@_results)
+          .strike_failure(file, classname, methodname)
+    end
+
+    def self.reporter
+      return self.instance_variable_get(:@_results) if self.instance_variable_defined?(:@_results)
+
+      reporter = Minitest::ResultsDatabase.new(result_db)
+      self.instance_variable_set(:@_results, reporter)
+
+      reporter
+    end
   end
 end
 

data/lib/minitest/proptest_plugin.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'minitest'
 require 'minitest/proptest'
 require 'minitest/proptest/gen'
 require 'minitest/proptest/property'
 require 'minitest/proptest/status'
 require 'minitest/proptest/version'
+require 'yaml'
 
 module Minitest
   def self.plugin_proptest_init(options)
@@ -18,15 +21,35 @@ module Minitest
       end
     end
 
-    if options.has_key?(:seed)
-      Proptest.set_seed(options[:seed])
+    self.reporter << Proptest.reporter
+
+    Proptest.set_seed(options[:seed]) if options.key?(:seed)
+  end
+
+  def self.plugin_proptest_options(opts, _options)
+    opts.on('--max-success', Integer, "Maximum number of successful cases to verify for each property (Default: #{Minitest::Proptest::DEFAULT_MAX_SUCCESS})") do |max_success|
+      Proptest.max_success = max_success
+    end
+    opts.on('--max-discard-ratio', Integer, "Maximum ratio of successful cases versus discarded cases per property (Default: #{Minitest::Proptest::DEFAULT_MAX_DISCARD_RATIO}:1)") do |max_success|
+      Proptest.max_success = max_success
+    end
+    opts.on('--max-size', Integer, "Maximum amount of entropy a single case may use in bytes (Default: #{Minitest::Proptest::DEFAULT_MAX_SIZE} bytes)") do |max_size|
+      Proptest.max_size = max_size
+    end
+    opts.on('--max-shrinks', Integer, "Maximum number of shrink iterations a single failure reduction may use (Default: #{Minitest::Proptest::DEFAULT_MAX_SHRINKS})") do |max_shrinks|
+      Proptest.max_shrinks = max_shrinks
+    end
+    opts.on('--results-db', String, "Location of the file to persist most recent failure cases.  Implies --use-db.  (Default: #{Minitest::Proptest::DEFAULT_DB_LOCATION})") do |db_path|
+      Proptest.result_db = db_path
+      Proptest.use_db!
+    end
+    opts.on('--use-db', 'Persist previous failures in a database and use them before generating new values.  Helps prevent flaky builds.  (Default: false)') do
+      Proptest.use_db!
     end
   end
 
   module Assertions
     def property(&f)
-      self.assertions += 1
-
       random_thunk = if Proptest.instance_variable_defined?(:@_random_seed)
                        r = Proptest.instance_variable_get(:@_random_seed)
                        ->() { Proptest::DEFAULT_RANDOM.call(r) }
@@ -34,17 +57,29 @@ module Minitest
                        Proptest::DEFAULT_RANDOM
                      end
 
+      file, methodname = caller.first.split(/:\d+:in +/)
+      classname = self.class.name
+      methodname.gsub!(/(?:^`|'$)/, '')
+
       prop = Minitest::Proptest::Property.new(
         f,
         random: random_thunk,
-        max_success: Proptest::DEFAULT_MAX_SUCCESS,
-        max_discard_ratio: Proptest::DEFAULT_MAX_DISCARD_RATIO,
-        max_size: Proptest::DEFAULT_MAX_SIZE,
-        max_shrinks: Proptest::DEFAULT_MAX_SHRINKS
+        max_success: Proptest.max_success,
+        max_discard_ratio: Proptest.max_discard_ratio,
+        max_size: Proptest.max_size,
+        max_shrinks: Proptest.max_shrinks,
+        previous_failure: Proptest.reporter.lookup(file, classname, methodname)
       )
       prop.run!
+      self.assertions += prop.calls
+
+      if prop.status.valid? && !prop.trivial
+        Proptest.strike_failure(file, classname, methodname)
+      else
+        unless prop.status.exhausted? || prop.status.invalid?
+          Proptest.record_failure(file, classname, methodname, prop.result.map(&:value))
+        end
 
-      unless prop.status.valid? && !prop.trivial
         raise Minitest::Assertion, prop.explain
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-proptest
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Tina Wuest
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2024-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -33,6 +33,7 @@ extra_rdoc_files: []
 files:
 - lib/minitest/proptest.rb
 - lib/minitest/proptest/gen.rb
+- lib/minitest/proptest/gen/value_generator.rb
 - lib/minitest/proptest/property.rb
 - lib/minitest/proptest/status.rb
 - lib/minitest/proptest/version.rb
@@ -44,6 +45,7 @@ metadata:
   homepage_uri: https://github.com/wuest/minitest-proptest
   source_code_uri: https://github.com/wuest/minitest-proptest
   changelog_uri: https://github.com/wuest/minitest-proptest/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -59,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Property testing in Minitest