propr 0.2.0

data/lib/propr/runner.rb

@@ -0,0 +1,53 @@
+module Propr
+  class Runner
+    attr_reader :minpass, :maxskip
+
+    def initialize(minpass, maxskip, scale)
+      @minpass, @maxskip, @scale =
+        minpass, maxskip, scale || lambda {|*_| 1 }
+    end
+
+    def run(property, generator)
+      passed  = 0
+      skipped = 0
+      wrapped = Dsl::Check.wrap(generator)
+
+      until passed >= @minpass or skipped >= @maxskip
+        input, _, success =
+          Random.run(wrapped, @scale.call(passed, skipped, @minpass, @maxskip))
+
+        # Generator should've returned an argument list. Except, for convenience,
+        # single-argument properties should have generators which return a single
+        # value, not an argument list, and we'll make it an argument list *here*.
+        input = property.arity == 1 ?
+          [input] : input
+
+        if success
+          begin
+            result = property.call(*input)
+            # result = property.arity == 1 ?
+            #   property.call(input) : property.call(*input)
+
+            if result
+              passed += 1
+            else
+              # Falsifiable
+              return [false, passed, skipped, input]
+            end
+          rescue GuardFailure => e
+            # GuardFailure in property
+            skipped += 1
+          rescue
+            raise Failure.new($!, input, nil, passed, skipped)#, nil, location
+          end
+        else
+          # GuardFailure in generator
+          skipped += 1
+        end
+      end
+
+      # Might have not passed enough tests
+      [passed >= @minpass, passed, skipped, nil]
+    end
+  end
+end

data/lib/propr/shrink/array.rb

@@ -0,0 +1,16 @@
+class Array
+  # @return [Array<Array>]
+  def shrink
+    return Array.new if empty?
+
+    combination(size - 1).to_a.tap do |shrunken|
+      shrunken << []
+      size.times do |n|
+        head = self[0, n]
+        tail = self[n+1..-1]
+        item = self[n]
+        shrunken.concat(item.shrink.map{|m| head + [m] + tail })
+      end
+    end
+  end
+end

data/lib/propr/shrink/bigdecimal.rb

@@ -0,0 +1,17 @@
+require "bigdecimal"
+
+class BigDecimal
+  # @return [Array<BigDecimal>]
+  def shrink
+    limit = 10
+
+    Array.unfold(self) do |seed|
+      limit -= 1
+      zero   = 0
+      seed_  = zero + (seed - zero) / 2
+
+      (limit > 0 && (seed - seed_).abs > 1e-5)
+        .maybe([self + zero - seed, seed_])
+    end
+  end
+end

data/lib/propr/shrink/boolean.rb

@@ -0,0 +1,11 @@
+class TrueClass
+  def shrink
+    [false]
+  end
+end
+
+class FalseClass
+  def shrink
+    []
+  end
+end

data/lib/propr/shrink/date.rb

@@ -0,0 +1,12 @@
+require "date"
+
+class Date
+  # @return [Array<Date>]
+  def shrink
+    Array.unfold(jd) do |seed|
+      zero  = 2415021 # 1900-01-01
+      seed_ = zero + (seed - zero) / 2
+      (seed != seed_).maybe([self + zero - seed, seed_])
+    end
+  end
+end

data/lib/propr/shrink/float.rb

@@ -0,0 +1,17 @@
+require "bigdecimal"
+
+class Float
+  # @return [Array<Float>]
+  def shrink
+    limit = 10
+
+    Array.unfold(self) do |seed|
+      limit -= 1
+      zero   = 0
+      seed_  = zero + (seed - zero) / 2
+
+      (limit > 0 && (seed - seed_).abs >= 1e-5)
+        .maybe([self + zero - seed, seed_])
+    end
+  end
+end

data/lib/propr/shrink/hash.rb

@@ -0,0 +1,18 @@
+class Hash
+  # @return [Array<Hash>]
+  def shrink
+    return Array.new if empty?
+
+    array = to_a
+    array.combination(size - 1).map{|pairs| Hash[pairs] }.tap do |shrunken|
+      shrunken << Hash.new
+
+      size.times do |n|
+        head = array[0, n]
+        tail = array[n+1..-1]
+        k, v = array[n]
+        shrunken.concat(v.shrink.map{|m| Hash[head + [[k, m]] + tail] })
+      end
+    end
+  end
+end

data/lib/propr/shrink/integer.rb

@@ -0,0 +1,10 @@
+class Integer
+  # @return [Enumerator<Integer>]
+  def shrink
+    Array.unfold(self) do |seed|
+      zero  = 0
+      seed_ = zero + (seed - zero) / 2
+      (seed != seed_).maybe([zero + self - seed, seed_])
+    end
+  end
+end

data/lib/propr/shrink/maybe.rb

@@ -0,0 +1,11 @@
+class Fr::Maybe::Some
+  def shrink
+    [Fr.none, map(&:shrink)]
+  end
+end
+
+class Fr::Maybe::None_
+  def shrink
+    []
+  end
+end

data/lib/propr/shrink/nil.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def shrink
+    []
+  end
+end

data/lib/propr/shrink/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def shrink
+    []
+  end
+end

data/lib/propr/shrink/range.rb

@@ -0,0 +1,4 @@
+class Range
+  # def shrink
+  # end
+end

data/lib/propr/shrink/rational.rb

@@ -0,0 +1,4 @@
+class Rational
+  # def shrink
+  # end
+end

data/lib/propr/shrink/set.rb

@@ -0,0 +1,18 @@
+class Set
+  # @return [Array<Set>]
+  def shrink
+    return Array.new if empty?
+
+    array = to_a
+    array.combination(size - 1).map(&:to_set).tap do |shrunken|
+      shrunken << Set.new
+
+      size.times do |n|
+        head = array[0, n]
+        tail = array[n+1..-1]
+        item = array[n]
+        shrunken.concat(item.shrink.map{|m| (head + [m] + tail).to_set })
+      end
+    end
+  end
+end

data/lib/propr/shrink/string.rb

@@ -0,0 +1,19 @@
+class String
+  # @return [Array<String>]
+  def shrink
+    case size
+    when 0 then []
+    when 1
+      shrunken = []
+      shrunken << downcase if self =~ /[[:upper:]]/
+      shrunken << " " if self =~ /(?! )\s/
+      shrunken << "a" if self =~ /[b-z]/
+      shrunken << "A" if self =~ /[B-Z]/
+      shrunken << "0" if self =~ /[1-9]/
+      shrunken << ""
+      shrunken
+    else
+      split(//).shrink.map(&:join)
+    end
+  end
+end

data/lib/propr/shrink/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def shrink
+    to_s.shrink.map(&:to_sym)
+  end
+end

data/lib/propr/shrink/time.rb

@@ -0,0 +1,9 @@
+class Time
+  def shrink
+    Array.unfold(to_f) do |seed|
+      zero  = 0 # 1969-12-31 00:00:00 UTC
+      seed_ = zero + (seed - zero) / 2
+      ((seed - seed_).abs > 1e-2).maybe([self + zero - seed, seed_])
+    end
+  end
+end

data/spec/examples/choose/array.example

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Array, "#random" do
+
+  property("empty") { error? { Array.new.random }}
+    .check
+
+  property("member?"){|xs| guard(!xs.empty?); xs.member?(m.eval xs.random) }
+    .check { Array.random(min: 1) { Integer.random }}
+    .check { Array.random(min: 1) { String.random }}
+
+end

data/spec/examples/choose/hash.example

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Hash, "#random" do
+
+  property("empty") { error? { Hash.new.random }}
+    .check
+
+  property("member?"){|xs| guard(!xs.empty?); k, v = m.eval(xs.random); xs.member?(k) }
+    .check { Hash.random { sequence [Integer.random, String.random] }}
+    .check { Hash.random { sequence [String.random, Integer.random] }}
+
+end

data/spec/examples/choose/range.example

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Range, "#random" do
+
+  property("empty") {|x| fails? { (x...x).random }}
+  # .check { Integer.random }
+  # .check { String.random }
+
+  property("member?"){|xs| guard(!xs.empty?); xs.member?(xs.random) }
+  # .check { Range.random(min: Integer.random, max: Integer.random) }
+  # .check { Range.random(min: String.random, max: String.random) }
+
+end

data/spec/examples/choose/set.example

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Set, "#random" do
+
+  property("empty") { fails? { Set.new.random }}
+  # .check
+
+  property("member?"){|xs| guard(!xs.empty?); xs.member?(xs.random) }
+  # .check { Set.random { Integer.random }}
+  # .check { Set.random { String.random }}
+
+end

data/spec/examples/guard.example

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Propr, "guard" do
+
+  # @todo: Not happy with this scoping issue. We should
+  # be able to use let(:int) { ... } instead.
+  def self.int
+    (0..100).random
+  end
+
+  property("callable from property") do
+    guard(true)
+    true
+  end.check
+
+  property("callable from check") do |x|
+    true
+  end.check { guard(true) }
+
+  property("skips test on unsuitable input") do |n|
+    guard(n > 10)
+    n > 10
+  end.check { int }
+
+  property("supresses unsuitable input") do |n|
+    n > 10
+  end.check { bind(int){|n| bind(guard(n > 10)) { unit(n) }}}
+
+  property("conjunction") do |n|
+    guard(n > 10, n < 90)
+    n > 10 && n < 90
+  end.check { int }
+
+  property("conjunction") do |n|
+    n > 10 && n < 90
+  end.check { bind(int){|n| bind(guard(n > 10, n < 90)) { unit(n) }}}
+
+end

data/spec/examples/random/array.example

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Array, ".random" do
+
+  describe "min and max" do
+    property("bounded"){|a,b| guard a <= b; m.eval(Array.random(min: a, max: b) { m.unit nil }).length >= a }
+      .check{ sequence [Integer.random(min: 0, max: 10), Integer.random(min: 10, max: 50)] }
+
+    property("bounded"){|a,b| guard a <= b; m.eval(Array.random(min: a, max: b) { m.unit nil }).length <= b }
+      .check{ sequence [Integer.random(min: 0, max: 10), Integer.random(min: 10, max: 50)] }
+
+    # @todo: only run once
+    property("empty"){|xs| xs.empty? }
+      .check{ Array.random(min: 0, max: 0) { unit nil }}
+
+    # @todo: only run once
+    property("singleton"){|xs| xs == [nil] }
+      .check{ Array.random(min: 1, max: 1) { unit nil }}
+  end
+
+  describe "items" do
+    property("sequence"){|xs| xs.uniq.length <= 1 }
+      .check{ x = 0; Array.random { unit(x += 1) }}
+
+    property("sequence"){|xs| xs.empty? or xs.first == 1 }
+      .check{ x = 0; Array.random { unit(x += 1) }}
+
+    property("sequence"){|xs| xs.empty? or xs.last == 1 }
+      .check{ x = 0; Array.random { unit(x += 1) }}
+
+    property("repeat"){|xs| xs.uniq.length <= 1 }
+      .check{ Array.random { unit(100) }}
+
+    property("repeat"){|xs| xs == [100]*xs.length }
+      .check{ Array.random { unit(100) }}
+  end
+
+end

data/spec/examples/random/hash.example

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Hash, ".random_vals" do
+
+  generators = [String, Integer, Float, Boolean, Time].map(&:random)
+
+  property("preserves hash keys"){|xs| xs.keys == m.eval(Hash.random_vals(xs)).keys }
+    .check(Hash[a: Integer.random, b: Propr::Random.unit(0)])
+    .check{ Hash.random { sequence [generators.random, unit(unit(0))] }}
+
+  property("evaluates hash values"){|xs| m.eval(Hash.random_vals(xs)).values.all?{|v| String === v }}
+    .check(Hash[a: String.random, b: String.random])
+  # .check{ Hash.random { sequence [Symbol.random, unit(String.random)] }}
+
+  property("evaluates hash values"){|xs| m.eval(Hash.random_vals(xs)).values.all?{|v| v == 0 }}
+    .check{ Hash.random { sequence [Symbol.random, unit(unit(0))] }}
+
+end

data/spec/examples/random/integer.example

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Integer, ".random" do
+
+  property("min"){|n| n >= 0 }
+    .check{ Integer.random(min: 0) }
+
+  property("max"){|n| n <= 0 }
+    .check{ Integer.random(max: 0) }
+
+  property("bounded"){|a,b| guard a <= b; m.eval(Integer.random(min: a, max: b)) >= a }
+    .check{ bind(sequence [Integer.random, Integer.random]){|xs| unit xs.sort }}
+
+  property("bounded"){|a,b| guard a <= b; m.eval(Integer.random(min: a, max: b)) <= b }
+    .check{ bind(sequence [Integer.random, Integer.random]){|xs| unit xs.sort }}
+
+  property("min == max"){|n| m.eval(Integer.random(min: n, max: n)) == n }
+    .check{ Integer.random }
+
+  property("min <= max"){|b,a| guard a >= b; error? { m.eval(Integer.random(min: a + 1, max: b)) }}
+    .check{ bind(sequence [Integer.random, Integer.random]){|xs| unit xs.sort }}
+
+end

data/spec/examples/random/range.example

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Range, ".random" do
+
+  context "min" do
+    property("bounded"){|n| m.eval(Range.random(min: n)).first >= n }
+      .check{ Integer.random }
+  end
+
+  context "max" do
+    property("bounded"){|n| m.eval(Range.random(max: n)).last <= n }
+      .check{ Integer.random }
+  end
+
+  context "min and max" do
+    property("bounded"){|a,b| guard a <= b; m.eval(Range.random(min: a, max: b)).first >= a }
+      .check{ bind(sequence [Integer.random, Integer.random]){|xs| unit xs.sort }}
+
+    property("bounded"){|a,b| guard a <= b; m.eval(Range.random(min: a, max: b)).last <= b }
+      .check{ bind(sequence [Integer.random, Integer.random]){|xs| unit xs.sort }}
+  end
+
+  context "inclusive?" do
+    property("true"){|r| not r.exclude_end? }
+      .check{ Range.random(inclusive?: true, max: Integer::MAX) }
+
+    property("false"){|r| r.exclude_end? }
+      .check{ Range.random(inclusive?: false, min: -Integer::MAX) }
+  end
+
+  context "block" do
+    property "called once" do
+      count = 0
+      range = m.eval(Range.random(inclusive?: true) { m.unit(count += 1) })
+      range.should == (1..1)
+    end.check
+  end
+
+  specify "args required" do
+    expect { Range.random }.to raise_error
+  end
+
+end