rushcheck 0.2

data/lib/rushcheck/config.rb

@@ -0,0 +1,98 @@
+# = Config.rb
+# This file is implemented for the class RushCheckConfig.
+
+# RushCheckConfig is a class which has configurations of tests.
+# This class is needed for several test functions.
+class RushCheckConfig
+
+  attr_reader :max_test, :max_fail, :size, :every
+
+  def self.quick
+    new(100, 1000, 
+        Proc.new{|x| x / 2 + 3},
+        Proc.new do |n, args|
+          s = n.to_s
+          s + ("\b" * s.length)
+        end)
+  end
+
+  def self.verbose 
+    new(100, 1000, 
+        Proc.new{|x| x / 2 + 3},
+        Proc.new do |n, args|
+          n.to_s + ":\n" + args.join("\n") + "\n"
+        end)
+  end
+
+  def initialize(max_test, max_fail, size, every)
+    @max_test, @max_fail, @size, @every = max_test, max_fail, size, every
+  end
+
+  # print results of tests.
+  def done(mesg, ntest, stamps)
+    print mesg + ' ' + ntest.to_s + ' tests'
+
+    bag = stamps.compact.find_all {|x| ! x.empty?}.sort.
+            inject(Hash.new) do |r, m|
+              r[m] = r[m].nil? ? 1 : r[m] + 1
+              r
+            end.sort_by {|k, v| v}.reverse.map do |pair|
+              percentage = ((100 * pair[1]) / ntest).to_s + '%'
+              ([percentage] + pair[0]).join(', ')
+            end
+
+    mes = case bag.length
+          when 0
+            ".\n"
+          when 1
+            '(' + bag[0] + ").\n"
+          else
+            ".\n" + bag.join(".\n") + ".\n"
+          end
+
+    print mes
+  end
+
+  # execute tests
+  def tests(gen, rnd, nt=1, nf=0, stamps=[])
+    ntest, nfail = nt, nf
+    while true
+      if ntest > max_test
+        done('OK, passed', max_test, stamps)
+        tests_result = true
+        break
+      end
+      if nfail > max_fail
+        done('Arguments exhausted after ', ntest, stamps)
+        tests_result = nil
+        break
+      end
+
+      rnd_l, rnd_r = rnd.split
+      result = gen.generate(size.call(ntest), rnd_r)
+      message = every.call(ntest, result.arguments)
+      print message # don't puts
+
+      case result.ok
+      when nil
+        nfail += 1
+        redo
+      when true
+        stamps.push(result.stamp)
+        ntest += 1
+        redo
+      when false
+        error = "Falsifiable, after " + ntest.to_s + " tests:\n" + 
+          result.arguments.join("\n")
+        puts error
+        tests_result = false
+        break
+      else
+        raise(RuntimeError, "RushCheck: illegal result")
+      end
+    end
+    
+    tests_result
+  end
+
+end

data/lib/rushcheck/float.rb

@@ -0,0 +1,43 @@
+# = float.rb
+# an extension to Float class for RushCheck
+
+require 'rushcheck/arbitrary'
+require 'rushcheck/integer'
+require 'rushcheck/random'
+
+class Float
+  
+  extend Arbitrary
+  extend HsRandom
+  
+  include Coarbitrary
+
+  @@min_bound = 0.0
+  @@max_bound = 1.0
+
+  def self.arbitrary
+    Gen.new do |n, r|
+      a, b, c = (1..3).map { Integer.arbitrary.value(n, r) }
+      a + (b / (c.abs + 1))
+    end
+  end
+
+  def self.bound
+    [@@min_bound, @@max_bound]
+  end
+
+  def self.random_range(gen, lo=@@min_bound, hi=@@max_bound)
+    x, g = Integer.random(gen)
+    a, b = Integer.bound
+    r = (lo+hi/2).to_f + ((hi - lo).to_f / (b - a) * x)
+
+    [r, g]
+  end
+
+  def coarbitrary(g)
+    h = truncate
+    t = (self * (10 ** ((self - h).to_s.length - 2))).truncate
+    h.coarbitrary(t.coarbitrary(g))
+  end
+
+end

data/lib/rushcheck/gen.rb

@@ -0,0 +1,189 @@
+# = Gen.rb
+# This file is implemented the type class Gen in Haskell's QuickCheck.
+# Almost all implementations are similar to Haskell's one.
+# Therefore check also the Haskell implementation.
+
+# Gen provides functions for generating test instances.
+class Gen
+
+  # choose is one of primitive generators to create a random Gen object. 
+  # choose returns a Gen object which generates a random value in the
+  # bound. It may useful to implement arbitrary method into your class.
+  def self.choose(lo=nil, hi=nil)
+    rand.fmap {|x| lo.class.random(x, lo, hi)[0] }
+  end
+
+  # elements is one of primitive generators to create a random Gen
+  # object. elements requires an array and returns a Gen object which
+  # generates an object in the array randomly. It may useful to
+  # implement arbitrary method into your class. 
+  def self.elements(xs)
+    raise(RuntimeError, "given argument is empty") if xs.empty?
+
+    choose(0, xs.length - 1).fmap {|i| xs[i] }
+  end
+
+  # frequency is one of primitive generators to create a random Gen
+  # object. frequency requires an array of pairs and returns a Gen
+  # object. The first component of pair should be a positive Integer
+  # and the second one should be a Gen object. The integer acts as a
+  # weight for choosing random Gen object in the array. For example,
+  # frequency([[1, Gen.rand], [2, Integer.arbitrary]]) returns the
+  # random generator Gen.rand in 33%, while another random generator
+  # of Integer (Integer.arbitrary) in 67%.
+  def self.frequency(xs)
+    tot = xs.inject(0) {|r, pair| r + pair[0]}
+    raise(RuntimeError, "Illegal frequency:#{xs.inspect}") if tot == 0
+    choose(0, tot - 1).bind do |n|
+      m = n
+      xs.each do |pair|
+        if m <= pair[0]
+        then break pair[1]
+        else m -= pair[0]
+        end
+      end
+    end 
+  end
+
+  # lift_array is one of primitive generators to create a randam Gen
+  # object. lift_array takes an array and a block which has a
+  # variable. The block should return a Gen object. lift_array returns
+  # a Gen object which generates an array of the result of given block
+  # for applying each member of given array. 
+  def self.lift_array(ary)
+    Gen.new do |n, r|
+      r2 = r
+      ary.map do |c|
+        r1, r2 = r.split
+        yield.value(n, r1)
+      end
+    end
+  end
+
+  # oneof is /one of/ primitive generators to create a random Gen object.
+  # oneof requires an array of Gen objects, and returns a Gen object
+  # which choose a Gen object in the array randomly.
+  # It may useful to implement arbitrary method into your class.
+  def self.oneof(gens)
+    elements(gens).bind {|x| x}
+  end
+
+  # promote is the function to create a Gen object which generates a
+  # procedure (Proc). promote requires a block which takes one
+  # variable and the block should be return a Gen object.
+  # promote returns a Gen object which generate a new procedure
+  # with the given block.
+  # It may useful to implement coarbitrary method into your class.
+  def self.promote
+    new {|n, r| Proc.new {|a| yield(a).value(n, r) } }
+  end
+
+  # rand returns a Gen object which generates a random number
+  # generator. 
+  def self.rand
+    new {|n, r| r}
+  end
+
+  # sized is a combinator which the programmer can use to access the
+  # size bound. It requires a block which takes a variable as an
+  # integer for size. The block should be a function which changes the
+  # size of random instances.
+  def self.sized
+    new {|n, r| yield(n).value(n, r) }
+  end
+
+  # unit is a monadic function which equals the return function in
+  # the Haskell's monad. It requires one variable and returns a Gen
+  # object which generates the given object.
+  def self.unit(x)
+    new {|n, r| x}
+  end
+
+  # vector is one of primitive generators to create a Gen object.
+  # vector takes two variables, while the first one should be class,
+  # and the second one should be length. vector returns a Gen object
+  # which generates an array whose components belongs the given class
+  # and given length.
+  def self.vector(c, len)
+    new do |n, r|
+      r2 = r
+      (1..len).map do 
+        r1, r2 = r2.split
+        c.arbitrary.value(n, r1) 
+      end
+    end
+  end
+
+  # to initialize Gen object, it requires a block which takes two
+  # variables. The first argument of block is assumed as an integer,
+  # and the second one is assumed as a random generator of RandomGen.
+  def initialize(&f)
+    @proc = f    
+  end
+
+  # bind is a monadic function such as Haskel's (>>=).
+  # bind takes a block which has two variables where the first one
+  # is assumed as an integer, and the second one is assumed as a
+  # random generator of RandomGen.
+  def bind
+    self.class.new do |n, r| 
+      r1, r2 = r.split
+      yield(value(n, r1)).value(n, r2)
+    end
+  end
+
+  # value is a method to get the value of the internal procedure.
+  # value takes two variables where the first argument is assumed as
+  # an integer and the second one is assumed as a random generator of
+  # RandomGen. 
+  def value(n, g)
+    @proc.call(n, g)
+  end
+
+  # fmap is a categorical function as same in Haskell.
+  # fmap requires a block which takes one variable.
+  def fmap
+    bind {|x| Gen.unit(yield(x)) }
+  end
+
+  # forall is a function to create a Gen object.
+  # forall requires a block which takes any variables
+  # and returns a Property object. Then forall returns
+  # a generator of the property.
+  def forall
+    bind do |*a|
+      yield(*a).property.bind do |res|
+        res.arguments.push(a.to_s)
+        Gen.unit(res)
+      end
+    end
+  end
+
+  # generate returns the random instance. generates takes two
+  # variables, where the first one should be an integer and the second
+  # should be the random number generator such as StdGen.
+  def generate(n, rnd)
+    s, r = Integer.random(rnd, 0, n)
+    value(s, r)
+  end
+
+  # resize returns another Gen object which resized by the given
+  # paramater. resize takes one variable in Integer.
+  def resize(n)
+    self.class.new {|x, r| value(n, r) }
+  end
+
+  # variant constructs a generator which transforms the random number
+  # seed. variant takes one variable which should be an
+  # Integer. variant is needed to generate rundom functions.
+  def variant(v)
+    self.class.new do |n, r| 
+      g = (1..v).inject(r) do |gen, i| 
+        gen, dummy = gen.split 
+        gen
+      end
+      value(n, g)
+    end
+  end
+
+end

data/lib/rushcheck/guard.rb

@@ -0,0 +1,27 @@
+# = guard.rb
+# This provides class Guard
+
+class RushCheckGuard < StandardError; end
+
+# class Guard is used for RushCheck internally and many user
+# don't care about this class.
+class Guard
+
+  def guard_raise(c)
+    begin
+      yield
+    rescue Exception => ex
+      case ex
+      when c
+        raise RushCheckGuard
+      else
+        raise ex
+      end
+    end
+  end
+
+  def guard
+    raise RushCheckGuard unless yield
+  end
+
+end

data/lib/rushcheck/hash.rb

@@ -0,0 +1,45 @@
+# = hash.rb
+# a random generator of Hash
+require 'rushcheck/arbitrary'
+require 'rushcheck/gen'
+require 'rushcheck/testable'
+
+# RandomHash is a subclass of Hash which provides a random generator
+# of hash. Programmer can make a subclass of RandomHash to make user
+# defined random generator of Hash.
+class RandomHash < Hash
+
+  extend Arbitrary
+  include Coarbitrary
+
+  # class method set_pattern takes a hash object of
+  # random pattern. For example, the following pattern
+  #   pat = { 'key1' => Integer, 'key2' => String }
+  # means that an arbitrary hash is randomly generated
+  # which has two keys (say 'key1' and 'key2') and
+  # has indicated random object as its values.
+  def self.set_pattern(pat)
+    @@pat = pat
+  end
+  
+  def self.arbitrary
+    Gen.new do |n, r|
+      h = {}
+      r2 = r
+      @@pat.keys.each do |k|
+        r1, r2 = r2.split
+        h[k] = @@pat[k].arbitrary.value(n, r1)
+      end
+      h
+    end
+  end
+
+  def coarbitrary(g)
+    r = g.variant(0)
+    values.each do |c|
+      r = c.coarbitrary(r.variant(1))
+    end
+    r
+  end
+
+end

data/lib/rushcheck/integer.rb

@@ -0,0 +1,43 @@
+# = integer.rb
+# an extension to Integer class for RushCheck
+#
+
+require 'rushcheck/arbitrary'
+require 'rushcheck/gen'
+require 'rushcheck/random'
+
+# ruby's Integer class is extended to use RushCheck library.
+# See also HsRandom, Arbitrary and Coarbitrary.
+class Integer
+  extend HsRandom
+  extend Arbitrary
+  include Coarbitrary
+
+  @@max_bound =  2**30 - 1
+  @@min_bound = -(2**30)
+
+  # this method is needed to include HsRandom.
+  def self.bound
+    [@@min_bound, @@max_bound]
+  end
+
+  # this method is needed to use Arbitrary.
+  def self.arbitrary
+    Gen.sized {|n| Gen.choose(-n, n) }
+  end
+
+  # this method is needed to include HsRandom.
+  def self.random_range(gen, lo=@@min_bound, hi=@@max_bound)
+    raise(RuntimeError, "illegal arguments:#{lo}, #{hi}") if hi - lo + 1 == 0
+    v, g = gen.gen_next
+
+    [(v % (hi - lo + 1)) + lo, g]
+  end
+
+  # this method is needed to use Coarbitrary.
+  def coarbitrary(g)
+    m = (self >= 0) ? 2 * self  : (-2) * self + 1
+    g.variant(m)
+  end
+
+end

data/lib/rushcheck/proc.rb

@@ -0,0 +1,53 @@
+# = proc.rb
+# The file provides a random generator of procedure.
+# See also examples/proc.rb
+
+require 'rushcheck/arbitrary'
+require 'rushcheck/gen'
+require 'rushcheck/testable'
+
+class RandomProc < Proc
+
+  extend Arbitrary
+  include Coarbitrary
+  include Testable
+
+  def self.set_pattern(inputs, outputs)
+    @@inputs, @@outputs = inputs, outputs
+  end
+
+  def self.arbitrary
+    Gen.new do |n, r|
+      Proc.new do |*args|
+        gens = if args.empty?
+               then @@outputs.map {|c| c.arbitrary }
+               else args.map do |v|
+                      @@outputs.map do |c|
+                        v.coarbitrary(c.arbitrary)
+                      end
+                    end.flatten
+               end
+        Gen.oneof(gens).value(n, r)
+      end
+    end
+  end
+
+  def coarbitrary(g)
+    Gen.new do |n, r|
+      r2 = r
+      args = @@inputs.map do |c| 
+        r1, r2 = r2.split
+        c.arbitrary.value(n, r1)
+      end
+
+      call(*args).coarbitrary(g)
+    end
+  end
+
+  def property
+    Gen.lift_array(@@inputs) {|c| c.arbitrary }.forall do |*args|
+      call(*args)
+    end
+  end
+
+end

data/lib/rushcheck/property.rb

@@ -0,0 +1,29 @@
+# = property.rb
+# This file defines properties of testcase
+# class Property is used for RushCheck internally
+require 'rushcheck/gen'
+require 'rushcheck/result'
+require 'rushcheck/testable'
+
+class Property
+
+  include Testable
+
+  attr_reader :gen
+  def initialize(obj=nil, stamp=[], arguments=[])
+    case obj
+    when nil, true, false
+      result = Result.new(obj, stamp, arguments)
+      @gen    = Gen.unit(result)
+    when Gen
+      @gen = obj
+    else
+      raise(RuntimeError, "illegal arguments")
+    end
+  end
+
+  def property
+    self
+  end
+
+end