minitest-proptest 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2f1cde4cf0a022319a3336a06e5509275ea420b5b36d39835f938c6ef830fae
-  data.tar.gz: 50a1ce6ade048840831ad943840c914cda998da1e6f7b98c07d02b7ee859d2db
+  metadata.gz: 61aa3a3421a7b1996cf35540600199e11d18bbf5959d96866f994be97f372bcf
+  data.tar.gz: f89adae15e67f595c56f274d034b18e3e325fe097865ef60f42a7d49f7509214
 SHA512:
-  metadata.gz: 6af2348e841f27a7401a64cc777dde8aad6a1487289cea278ecb6ec2771602143bce354dad192c55d2c57c4aa828ed6a34842d048a1dcb41d45d09fcc5e9e96a
-  data.tar.gz: 8919b2d754966201a1f489c0b6594128e36fcf3301774cbabb0f67848b363d2702143829301042e0c8344dc0950c62995f2bf10147d94e4bbedc1e5f853cf063
+  metadata.gz: 6c114584acb4f0d59d93958c65e665a5acde52dce3083f1a1343e8cc85962ec11f4e8e582821bf86002cb2e02cfe45d255fe653450944fdc573112168a734520
+  data.tar.gz: 4f23345243cb106aa1fca9e4d9a4c87c6c20e22407e2564990de246cb81c95f96a2e8138a3991121ab24a2b2bfa9bf5066a7cdc3b639f0880d6e1170bd214652

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

@@ -19,8 +19,8 @@ module Minitest
         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_singleton_method(:bound_max) { bound_max }
           define_method(:append) do |other|
             @value = f.call(value, other.value)
             self

data/lib/minitest/proptest/gen.rb

@@ -119,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
@@ -196,6 +228,34 @@ module Minitest
         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
         candidates = []
         n          = h.length
@@ -303,45 +363,36 @@ module Minitest
           .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
           .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
-          .unpack1('d')
+        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
@@ -392,6 +443,29 @@ module Minitest
         xm.merge(ym)
       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).odd?
       end.with_score_function do |_|

data/lib/minitest/proptest/property.rb

@@ -4,11 +4,20 @@ module Minitest
   module Proptest
     # Property evaluation - status, scoring, shrinking
     class Property
-      attr_reader :result, :status, :trivial
+      require 'minitest/assertions'
+      include Minitest::Assertions
+
+      attr_reader :calls, :result, :status, :trivial
+
+      attr_accessor :assertions
 
       def initialize(
         # The function which proves the property
         test_proc,
+        # The file in which our property lives
+        filename,
+        # The method containing our property
+        methodname,
         # Any class which provides `rand` accepting both an Integer and a Range
         # is acceptable.  The default value is Ruby's standard Mersenne Twister
         # implementation.
@@ -28,6 +37,8 @@ module Minitest
         previous_failure: []
       )
         @test_proc         = test_proc
+        @filename          = filename
+        @methodname        = methodname
         @random            = random.call
         @generator         = ::Minitest::Proptest::Gen.new(@random)
         @max_success       = max_success
@@ -36,13 +47,16 @@ 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
+        @local_variables   = {}
       end
 
       def run!
@@ -51,17 +65,6 @@ module Minitest
         shrink!
       end
 
-      def arbitrary(*classes)
-        if @arbitrary
-          @arbitrary.call(*classes)
-        else
-          a = @generator.for(*classes)
-          @generated << a
-          @status = Status.overrun unless @generated.length <= @max_size
-          a.value
-        end
-      end
-
       def explain
         prop = if @status.valid?
                  'The property was proved to satsfaction across ' \
@@ -77,10 +80,26 @@ module Minitest
                elsif @status.unknown?
                  '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}"
+                 info = 'A counterexample to a property has been found after ' \
+                        "#{@valid_test_cases} valid " \
+                        "example#{@valid_test_cases == 1 ? '' : 's'}.\n"
+                 var_info = if @local_variables.empty?
+                              'Variables local to the property were unable ' \
+                                'to be determined.  This is usually a bug.'
+                            else
+                              "The values at the time of the failure were:\n"
+                            end
+                 vars = @local_variables
+                        .map { |k, v| "\t#{k}: #{v.inspect}" }
+                        .join("\n")
+
+                 info + var_info + vars
+               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 " \
@@ -95,18 +114,47 @@ module Minitest
 
       private
 
+      def arbitrary(*classes)
+        if @arbitrary
+          @arbitrary.call(*classes)
+        else
+          a = @generator.for(*classes)
+          @generated << a
+          @status = Status.overrun unless @generated.length <= @max_size
+          a.value
+        end
+      end
+
+      def where(&b)
+        @valid_test_case &= b.call
+      end
+
       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
@@ -133,9 +181,20 @@ module Minitest
         end
 
         @generator = ::Minitest::Proptest::Gen.new(@random)
-        if instance_eval(&@test_proc)
+        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 = []
-        else
+        elsif @valid_test_case
           @result = @generated
           @status = Status.interesting
         end
@@ -156,6 +215,17 @@ module Minitest
         candidates     = @generated.map(&:shrink_candidates)
         old_arbitrary  = @arbitrary
 
+        local_variables = {}
+        tracepoint = TracePoint.new(:b_return) do |trace|
+          if trace.path == @filename && trace.method_id.to_s == @methodname
+            b     = trace.binding
+            vs    = b.local_variables
+            known = vs.to_h { |lv| [lv.to_s, b.local_variable_get(lv)] }
+            local_variables.delete_if { true }
+            local_variables.merge!(known)
+          end
+        end
+
         to_test = candidates
                   .map    { |x| x.map { |y| [y] } }
                   .reduce { |c, e| c.flat_map { |a| e.map { |b| a + b } } }
@@ -174,15 +244,31 @@ 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)
-              best_generated = @generated
-              # The first hit is guaranteed to be the best scoring due to the
+            success = begin
+                        tracepoint.enable
+                        instance_eval(&@test_proc)
+                      rescue Minitest::Assertion
+                        false
+                      rescue => e
+                        next unless @valid_test_case
+
+                        @status = Status.invalid
+                        @excption = e
+                        break
+                      ensure
+                        tracepoint.disable
+                      end
+
+            if !success && @valid_test_case
+              # The first hit is guaranteed to be the best scoring since the
               # shrink candidates are pre-sorted.
+              best_generated = @generated
               break
             end
           end
@@ -190,20 +276,22 @@ module Minitest
           @calls    += 1
           run[:run] += 1
         end
+
         # Clean up after we're done
-        @generated = best_generated
-        @result    = best_generated
-        @generator = old_generator
-        @random    = old_random
-        @arbitrary = old_arbitrary
+        @generated       = best_generated
+        @result          = best_generated
+        @generator       = old_generator
+        @random          = old_random
+        @arbitrary       = old_arbitrary
+        @local_variables = local_variables
       end
 
       def continue_iterate?
         !@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?

data/lib/minitest/proptest/status.rb

@@ -4,6 +4,10 @@ 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.
@@ -23,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?
@@ -47,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.1.0'
+    VERSION = '0.2.1'
   end
 end

data/lib/minitest/proptest_plugin.rb

@@ -50,8 +50,6 @@ module Minitest
 
   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) }
@@ -65,6 +63,8 @@ module Minitest
 
       prop = Minitest::Proptest::Property.new(
         f,
+        file,
+        methodname,
         random: random_thunk,
         max_success: Proptest.max_success,
         max_discard_ratio: Proptest.max_discard_ratio,
@@ -73,11 +73,14 @@ module Minitest
         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
-        Proptest.record_failure(file, classname, methodname, prop.result.map(&:value))
+        unless prop.status.exhausted? || prop.status.invalid?
+          Proptest.record_failure(file, classname, methodname, prop.result.map(&:value))
+        end
 
         raise Minitest::Assertion, prop.explain
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-proptest
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Tina Wuest
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-13 00:00:00.000000000 Z
+date: 2024-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest