minitest-proptest 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2f1cde4cf0a022319a3336a06e5509275ea420b5b36d39835f938c6ef830fae
-  data.tar.gz: 50a1ce6ade048840831ad943840c914cda998da1e6f7b98c07d02b7ee859d2db
+  metadata.gz: '0596e6f6a66614dba0199eccc4e18a5bf6b869fd0db46dff7636a8772eacb75b'
+  data.tar.gz: a956c579c5bb355a5b687f64109917918870dd7dac1323a18a72d44e4ca623a6
 SHA512:
-  metadata.gz: 6af2348e841f27a7401a64cc777dde8aad6a1487289cea278ecb6ec2771602143bce354dad192c55d2c57c4aa828ed6a34842d048a1dcb41d45d09fcc5e9e96a
-  data.tar.gz: 8919b2d754966201a1f489c0b6594128e36fcf3301774cbabb0f67848b363d2702143829301042e0c8344dc0950c62995f2bf10147d94e4bbedc1e5f853cf063
+  metadata.gz: d6206c7a778b9b55e0674e204afea71721eb8b6e4fe2257691cc1cefd5e76885eff08d648f9a61172806872f1abe5f1b232186fcc803e6fcc560241fd71fac8c
+  data.tar.gz: 1ca1d04ddcdecb9f661e0af6cffc87dda30af6a9b06bb6fe406a5f27ec445a0cf3cd9ac4d9050b4a243ab40d76d066358f6cf9612181cc546a2076b76a7d9041

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,7 +4,12 @@ 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
@@ -36,9 +41,11 @@ 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
@@ -62,6 +69,10 @@ 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 ' \
@@ -81,6 +92,12 @@ module Minitest
                    "#{@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 " \
@@ -96,17 +113,31 @@ 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
@@ -133,9 +164,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
@@ -174,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)
-              best_generated = @generated
+            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
               break
             end
           end
@@ -202,8 +257,8 @@ 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?

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.0'
   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) }
@@ -73,11 +71,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.0
 platform: ruby
 authors:
 - Tina Wuest
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-13 00:00:00.000000000 Z
+date: 2024-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest