rushcheck 0.3 → 0.4

data/lib/rushcheck/random.rb

@@ -10,206 +10,209 @@
 # This file provides two module RandomGen, HsRandom, two classes
 # StdGen and TheStdGen.
 
+module RushCheck
 
-# The module RandomGen is an abstract module. This is included
-# to add instance methods. The author considers that few developers 
-# need to read this implementation. See StdGen as an example.
-# Check also Haskell's System.Random library.
-module RandomGen
-  
-  # gen_next should be overrided as an instance method.
-  # It is assumed that gen_next returns an array with length 2.
-  # Here, call 'Foo' the class which includes RandomGen.
-  # The first components of the result should be an integer, and the
-  # last components should be an object which belongs to the class
-  # Foo. 
-  def gen_next
-    raise_not_implemented_error
-  end
+  # The module RandomGen is an abstract module. This is included
+  # to add instance methods. The author considers that few developers 
+  # need to read this implementation. See StdGen as an example.
+  # Check also Haskell's System.Random library.
+  module RandomGen
+    
+    # gen_next should be overrided as an instance method.
+    # It is assumed that gen_next returns an array with length 2.
+    # Here, call 'Foo' the class which includes RandomGen.
+    # The first components of the result should be an integer, and the
+    # last components should be an object which belongs to the class
+    # Foo. 
+    def gen_next
+      raise_not_implemented_error
+    end
 
-  # split should be overrided as an instance method.
-  # It is assumed that split returns an array with length 2.
-  # Here, call 'Foo' the class which includes RandomGen.
-  # Then the components of the result are objects which belongs to the
-  # class Foo.
-  def split
-    raise_not_implemented_error
-  end
+    # split should be overrided as an instance method.
+    # It is assumed that split returns an array with length 2.
+    # Here, call 'Foo' the class which includes RandomGen.
+    # Then the components of the result are objects which belongs to the
+    # class Foo.
+    def split
+      raise_not_implemented_error
+    end
 
-  # gen_range should be overrided as an instance method.
-  # It is assumed that split returns an array with length 2.
-  # Here, call 'Foo' the class which includes RandomGen.
-  # Then the components of the result are integers where
-  # the first components should be the lowest bound of
-  # the first components of gen_next. Another should be
-  # the highest bound of the first components of gen_next.
-  def gen_range
-    raise_not_implemented_error
-  end
+    # gen_range should be overrided as an instance method.
+    # It is assumed that split returns an array with length 2.
+    # Here, call 'Foo' the class which includes RandomGen.
+    # Then the components of the result are integers where
+    # the first components should be the lowest bound of
+    # the first components of gen_next. Another should be
+    # the highest bound of the first components of gen_next.
+    def gen_range
+      raise_not_implemented_error
+    end
 
-  private 
-  def raise_not_implemented_error
-    raise(NotImplementedError, "This method should be overrided.")
-  end
+    private 
+    def raise_not_implemented_error
+      raise(NotImplementedError, "This method should be overrided.")
+    end
 
-end
+  end
 
-# StdGen is a class (and the unique class) which includes RandomGen.
-# This class provides a functional random number generator.
-class StdGen 
+  # StdGen is a class (and the unique class) which includes RandomGen.
+  # This class provides a functional random number generator.
+  class StdGen 
 
-  include RandomGen
+    include RushCheck::RandomGen
 
-  @@min_bound = -(2**30)
-  @@max_bound = 2**30 - 1
+    @@min_bound = -(2**30)
+    @@max_bound = 2**30 - 1
 
-  # left and right are two seeds of random number generator.
-  attr_reader :left, :right
-  def initialize(left=nil, right=nil)
-    @left, @right = [left, right].map do |x| 
-      if x.nil?
-      then random
-      else in_range(x) 
+    # left and right are two seeds of random number generator.
+    attr_reader :left, :right
+    def initialize(left=nil, right=nil)
+      @left, @right = [left, right].map do |x| 
+        if x.nil?
+        then random
+        else in_range(x) 
+        end
       end
     end
-  end
 
-  # gen_next returns an array with length 2. The first component of
-  # result is a random integer. The last component is a new StdGen
-  # object as a new random number generator. See also RandomGen.
-  def gen_next
-    s, t = [@left, @right].map {|x| random(x) }
-    z = ((s - t) % (@@max_bound - @@min_bound)) + @@min_bound
+    # gen_next returns an array with length 2. The first component of
+    # result is a random integer. The last component is a new StdGen
+    # object as a new random number generator. See also RandomGen.
+    def gen_next
+      s, t = [@left, @right].map {|x| random(x) }
+      z = ((s - t) % (@@max_bound - @@min_bound)) + @@min_bound
 
-    [z, StdGen.new(s, t)]
-  end
+      [z, RushCheck::StdGen.new(s, t)]
+    end
 
-  # split returns an array with length 2. The components are
-  # two new StdGen objects as two new random number generators.
-  def split
-    g = gen_next[1]
-    s, t = g.left, g.right
+    # split returns an array with length 2. The components are
+    # two new StdGen objects as two new random number generators.
+    def split
+      g = gen_next[1]
+      s, t = g.left, g.right
 
-    [StdGen.new(s + 1, t), StdGen.new(s, t + 1)]
-  end
+      [RushCheck::StdGen.new(s + 1, t), RushCheck::StdGen.new(s, t + 1)]
+    end
 
-  # gen_range returns an array with length 2 which represents
-  # a bound of generated random numbers.
-  def gen_range
-    [@@min_bound, @@max_bound]
-  end
+    # gen_range returns an array with length 2 which represents
+    # a bound of generated random numbers.
+    def gen_range
+      [@@min_bound, @@max_bound]
+    end
 
-  def to_s
-    @left.to_s + ' ' + @right.to_s
-  end
+    def to_s
+      @left.to_s + ' ' + @right.to_s
+    end
 
-  private
-  def random(s=nil)
-    if s.nil? then srand else srand s end
-    rand(@@max_bound - @@min_bound) + @@min_bound
-  end
+    private
+    def random(s=nil)
+      if s.nil? then srand else srand s end
+      rand(@@max_bound - @@min_bound) + @@min_bound
+    end
+
+    def in_range(n)
+      (n % (@@max_bound - @@min_bound)) + @@min_bound
+    end
 
-  def in_range(n)
-    (n % (@@max_bound - @@min_bound)) + @@min_bound
   end
 
-end
 
+  require 'singleton'
 
-require 'singleton'
+  # TheStdGen is a singleton class to get the unique random number
+  # generator using StdGen. TheStdGen includes ruby's Singleton module.
+  class TheStdGen 
 
-# TheStdGen is a singleton class to get the unique random number
-# generator using StdGen. TheStdGen includes ruby's Singleton module.
-class TheStdGen 
+    include Singleton
+    include RushCheck::RandomGen  
 
-  include RandomGen  
-  include Singleton
+    def initialize
+      @gen = RushCheck::StdGen.new
+    end
 
-  def initialize
-    @gen = StdGen.new
-  end
+    def gen_next
+      @gen, result = @gen.split
+      
+      result.gen_next
+    end
 
-  def gen_next
-    @gen, result = @gen.split
-    
-    result.gen_next
-  end
+    def split
+      result = @gen.split
+      @gen = @gen.gen_next[1]
 
-  def split
-    result = @gen.split
-    @gen = @gen.gen_next[1]
+      result
+    end
 
-    result
-  end
+    def gen_range
+      @gen.gen_range
+    end
 
-  def gen_range
-    @gen.gen_range
   end
 
-end
 
+  # HsRandom module provides several random number function with the
+  # functional random generator. This module is implemented Haskell\'s
+  # System.Random library. This module assumes that the class which
+  # includes HsRandom should have an instance method random_range to
+  # generate a random number and a new random number generator.
+  # It assumes also that the class which includes HsRandom should have
+  # a class method bound to give a bound of random numbers.
+  module HsRandom
 
-# HsRandom module provides several random number function with the
-# functional random generator. This module is implemented Haskell\'s
-# System.Random library. This module assumes that the class which
-# includes HsRandom should have an instance method random_range to
-# generate a random number and a new random number generator.
-# It assumes also that the class which includes HsRandom should have
-# a class method bound to give a bound of random numbers.
-module HsRandom
-
-  # random requires the functional random number generater (StdGen
-  # object) and optionally requires the bound of random numbers.
-  # It returns an array with length 2, where the first component
-  # should be a new random number, and the last should be a new random
-  # number generator.
-  def random(gen, lo=nil, hi=nil)
-    lo = bound[0] if lo.nil?
-    hi = bound[1] if hi.nil?
-    random_range(gen, hi, lo) if lo > hi
-
-    random_range(gen, lo, hi)
-  end
+    # random requires the functional random number generater (StdGen
+    # object) and optionally requires the bound of random numbers.
+    # It returns an array with length 2, where the first component
+    # should be a new random number, and the last should be a new random
+    # number generator.
+    def random(gen, lo=nil, hi=nil)
+      lo = bound[0] if lo.nil?
+      hi = bound[1] if hi.nil?
+      random_range(gen, hi, lo) if lo > hi
+
+      random_range(gen, lo, hi)
+    end
 
-  # random_array requires the functional random number generater
-  # (StdGen object). Optionally, it requires the length of results and
-  # the bound of random numbers. This method returns different result
-  # whether the second argument length is nil or not. When the second
-  # argument is nil, then random_array returns a Proc which takes one
-  # variable as an integer and return a new random value, such as an
-  # infinite sequence of random numbers. Otherwise, the second
-  # argument of random_array is not nil but some integer, then
-  # random_array returns an array of random numbers with the length.
-  def random_array(gen, len=nil, lo=nil, hi=nil)
-    g = gen
-    if len.nil?
-    then
-      Proc.new do |i|
-        (i+1).times do
+    # random_array requires the functional random number generater
+    # (StdGen object). Optionally, it requires the length of results and
+    # the bound of random numbers. This method returns different result
+    # whether the second argument length is nil or not. When the second
+    # argument is nil, then random_array returns a Proc which takes one
+    # variable as an integer and return a new random value, such as an
+    # infinite sequence of random numbers. Otherwise, the second
+    # argument of random_array is not nil but some integer, then
+    # random_array returns an array of random numbers with the length.
+    def random_array(gen, len=nil, lo=nil, hi=nil)
+      g = gen
+      if len.nil?
+      then
+        Proc.new do |i|
+          (i+1).times do
+            v, g = random(g, lo, hi)
+          end
+          v
+        end
+      else
+        (1..len).map do
           v, g = random(g, lo, hi)
+          v
         end
-        v
-      end
-    else
-      (1..len).map do
-        v, g = random(g, lo, hi)
-        v
       end
     end
-  end
 
-  # random_std requires optionally the bound of random numbers.
-  # It returns an array with length 2, where the first component
-  # should be a new random number, and the last should be a new random
-  # number generator. This method uses the unique standard random
-  # generator TheStdGen.
-  def random_std(lo=nil, hi=nil)
-    random(TheStdGen.instance, lo, hi)
-  end
+    # random_std requires optionally the bound of random numbers.
+    # It returns an array with length 2, where the first component
+    # should be a new random number, and the last should be a new random
+    # number generator. This method uses the unique standard random
+    # generator TheStdGen.
+    def random_std(lo=nil, hi=nil)
+      random(RushCheck::TheStdGen.instance, lo, hi)
+    end
+
+    def random_range(gen, lo=nil, hi=nil)
+      raise(NotImplementedError, "This method should be overrided.")
+    end
+    private :random_range
 
-  def random_range(gen, lo=nil, hi=nil)
-    raise(NotImplementedError, "This method should be overrided.")
   end
-  private :random_range
 
 end

data/lib/rushcheck/result.rb

@@ -5,22 +5,26 @@
 require 'rushcheck/property'
 require 'rushcheck/testable'
 
-class Result
+module RushCheck
 
-  include Testable
+  class Result
 
-  def self.nothing
-    Result.new(false)
-  end
+    include RushCheck::Testable
 
-  attr_reader :ok, :stamp, :arguments
-  def initialize(ok=nil, stamp=[], arguments=[])
-    @ok, @stamp, @arguments = ok, stamp, arguments
-  end
+    def self.nothing
+      RushCheck::Result.new(false)
+    end
+
+    attr_reader :ok, :stamp, :arguments
+    def initialize(ok=nil, stamp=[], arguments=[])
+      @ok, @stamp, @arguments = ok, stamp, arguments
+    end
+
+    def result
+      RushCheck::Property.new(@ok, @stamp, @arguments)
+    end
+    alias property :result
 
-  def result
-    Property.new(@ok, @stamp, @arguments)
   end
-  alias property :result
 
 end

data/lib/rushcheck/string.rb

@@ -9,19 +9,19 @@ require 'rushcheck/random'
 
 class String
 
-  extend Arbitrary
-  extend HsRandom
+  extend RushCheck::Arbitrary
+  extend RushCheck::HsRandom
 
-  include Coarbitrary
+  include RushCheck::Coarbitrary
 
   @@min_range = 0
   @@max_range = 1024
 
   def self.arbitrary
-    Gen.sized do |n|
-      Gen.choose(0, n).bind do |len|
-        Gen.vector(Integer, len).bind do |xs|
-          Gen.unit(xs.map{|x| (x % 128).chr}.join)
+    RushCheck::Gen.sized do |n|
+      RushCheck::Gen.choose(0, n).bind do |len|
+        RushCheck::Gen.vector(Integer, len).fmap do |xs|
+          xs.map{|x| (x % 128).chr}.join
         end
       end
     end
@@ -80,17 +80,17 @@ class SpecialString < String
     [f['alphabet'],f['control'],f['number'],f['special']].zip(
     [ @@alphabet,   @@control,   @@number,   @@special]) do 
       |weight, table|
-        gen = Gen.oneof(table.map {|n| Gen.unit(n.chr)})
+        gen = RushCheck::Gen.oneof(table.map {|n| RushCheck::Gen.unit(n.chr)})
         frq << [weight, gen]
     end
 
-    Gen.sized do |m|
-      Gen.choose(0, m).bind do |len|
-        Gen.new do |n, r|
+    RushCheck::Gen.sized do |m|
+      RushCheck::Gen.choose(0, m).bind do |len|
+        RushCheck::Gen.new do |n, r|
           r2 = r
           (1..len).map do
             r1, r2 = r2.split
-            Gen.frequency(frq).value(n, r1)
+            RushCheck::Gen.frequency(frq).value(n, r1)
           end.join
         end
       end

data/lib/rushcheck/testable.rb

@@ -3,39 +3,113 @@
 # See also QuickCheck in Haskell
 
 require 'rushcheck/config'
+require 'rushcheck/random'
+require 'rushcheck/testresult'
 
-module Testable 
+module RushCheck
 
-  def property
-    raise(NotImplementedError, "This method should be overrided.")    
-  end
+  module Testable 
 
-  def check(config=RushCheckConfig.quick)
-    config.tests(property.gen, TheStdGen.instance)
-  end
-  alias quick_check :check
-  alias quickcheck  :check
+    def property
+      raise(NotImplementedError, "This method should be overrided.")    
+    end
 
-  def classify(name)
-    yield ? label(name) : property
-  end
+    def check(config=RushCheck::Config.quick)
+      config.tests(property.gen, RushCheck::TheStdGen.instance)
+    end
+    alias quick_check :check
+    alias quickcheck  :check
 
-  def imply
-    yield ? property : Result.nothing.result
-  end
+    def classify(name)
+      yield ? label(name) : property
+    end
 
-  def label(s)
-    Property.new(property.gen.fmap {|res| res.stamp << s.to_s; res })
-  end
-  alias collect :label
+    def imply
+      yield ? property : RushCheck::Result.nothing.result
+    end
 
-  def test
-    check(RushCheckConfig.verbose)
-  end
-  alias verbose_check :test
+    def label(s)
+      RushCheck::Property.new(property.gen.fmap {|res| res.stamp << s.to_s; res })
+    end
+    alias collect :label
+
+    def run(opts)
+      RushCheck::Config.batch(opts.ntests, opts.debug?).
+        tests_batch(property, RushCheck::StdGen.new(0))
+    end
 
-  def trivial
-    classify('trivial') { yield }
+    def rjustify(n, s)
+      ' ' * [0, n - s.length].max + s
+    end
+    private :rjustify
+
+    def try_test(ts)
+      ntests = 1
+      count  = 0
+      others = []
+      if ! ts.empty?
+        ts.each do |t|
+          begin
+            r = t.call(opts)
+            case r
+            when RushCheck::TestOk
+              puts "."
+              ntests += 1
+              count  += r.ntests
+            when RushCheck::TestExausted
+              puts "?"
+              ntests += 1
+              count += r.ntests
+            when RushCheck::TestFailed
+              puts "#"
+              ntests += 1
+              others << [r.results, ntests, r.ntests]
+              count += r.ntests
+            else
+              raise(RuntimeError, "RushCheck: illegal result")
+            end
+          rescue
+            puts "*"
+            ntests += 1
+            next
+          end
+        end
+      end
+      print(rjustify([0, 35-ntests].max, " (") + count.to_s + ")\n")
+      others
+    end
+    private :try_test
+
+    def final_run(f, n, no, name)
+      puts
+      puts "    ** test " + n.to_s + " of " + name + " failed with the binding(s)"
+      f.each do |v|
+        puts "    **  " + v.to_s
+      end
+      puts
+    end
+    private :final_run
+
+    def run_tests(name, opts, tests)
+      print(rjustify(25, name) + " : ")
+      f = try_test(tests)
+      f.each { |f, n, no| final_run(f, n, no, name) }
+      nil
+    end
+
+    def test
+      check(RushCheck::Config.verbose)
+    end
+    alias verbose_check :test
+
+    def testcase
+      Proc.new {|opts| run(opts)}
+    end
+
+    def trivial
+      classify('trivial') { yield }
+    end
   end
 
 end
+

data/lib/rushcheck/testoptions.rb

@@ -0,0 +1,20 @@
+# = testoptions.rb
+# define class TestOptions for a batch process for RushCheck
+
+module RushCheck
+
+  class TestOptions
+
+    attr_reader :ntests, :length
+    def initialize(ntests=100, length=1, debug=false)
+      @ntests, @length, @debug = ntests, length, debug
+    end
+
+    def debug?
+      @debug
+    end
+
+  end
+
+end
+

data/lib/rushcheck/testresult.rb

@@ -0,0 +1,25 @@
+# = testresult.rb
+# 
+
+module RushCheck
+
+  class TestResult
+    attr_reader :message, :ntests, :stamps
+    def initialize(message, ntests, stamps)
+      @message, @ntest, @stamps = message, ntests, stamps
+    end
+  end
+
+  class TestOk < TestResult; end
+
+  class TestExausted < TestResult; end
+
+  class TestFailed
+    attr_reader :results, :ntests
+    def initialize(results, ntests)
+      @results, @ntests = results, ntests
+    end
+  end
+
+end
+

data/lib/{rushcheck/rushcheck.rb → rushcheck.rb}

@@ -5,13 +5,14 @@
 require 'rushcheck/arbitrary'
 require 'rushcheck/assertion'
 require 'rushcheck/gen'
+require 'rushcheck/guard'
 require 'rushcheck/random'
 require 'rushcheck/testable'
 
 require 'rushcheck/array'
 require 'rushcheck/bool'
+require 'rushcheck/float'
 require 'rushcheck/hash'
 require 'rushcheck/integer'
-require 'rushcheck/float'
 require 'rushcheck/proc'
 require 'rushcheck/string'