rushcheck 0.5 → 0.6

data/Rakefile

@@ -6,10 +6,18 @@ require 'rubygems'
 require 'rake'
 require 'rake/gempackagetask'
 
+RUSHCHECK_VERSION="0.6"
+task :default => ["dist", "gem"]
+
+task :dist do
+  system "darcs dist -d rushcheck-#{RUSHCHECK_VERSION}"
+  system "mv rushcheck-#{RUSHCHECK_VERSION}.tar.gz pkg/"
+end
+
 spec = Gem::Specification.new do |s|
   s.name      = 'rushcheck'
   s.summary   = "A lightweight random testing tool"
-  s.version   = "0.5"
+  s.version   = RUSHCHECK_VERSION
   s.author    = 'Daisuke IKEGAMI'
   s.email     = 'ikegami@madscientist.jp'
   s.homepage  = 'http://rushcheck.rubyforge.org'

data/Rakefile.in

@@ -6,10 +6,18 @@ require 'rubygems'
 require 'rake'
 require 'rake/gempackagetask'
 
+RUSHCHECK_VERSION="@VERSION@"
+task :default => ["dist", "gem"]
+
+task :dist do
+  system "darcs dist -d rushcheck-#{RUSHCHECK_VERSION}"
+  system "mv rushcheck-#{RUSHCHECK_VERSION}.tar.gz pkg/"
+end
+
 spec = Gem::Specification.new do |s|
   s.name      = 'rushcheck'
   s.summary   = "A lightweight random testing tool"
-  s.version   = "@VERSION@"
+  s.version   = RUSHCHECK_VERSION
   s.author    = 'Daisuke IKEGAMI'
   s.email     = 'ikegami@madscientist.jp'
   s.homepage  = 'http://rushcheck.rubyforge.org'

data/data/rushcheck/doc/rushcheck.thtml

@@ -19,6 +19,8 @@ h1. Index
 ## <a href="#Watching the statistics">Watching the statistics</a>
 ### <a href="#trivial">'trivial'</a>
 ### <a href="#classify">'classify'</a>
+# <a href="Combining unit testing and RushCheck">Combining unit testing and RushCheck</a>
+# <a href="Combining RSpec and RushCheck">Combining RSpec and RushCheck</a>
 ## <a href="#With another basic classes for assertions">With another basic classes for assertions</a>
 ### <a href="#SpecialString">SpecialString</a>
 ### <a href="#Array and RandomArray">Array and RandomArray</a>
@@ -307,6 +309,59 @@ true
 irb>
 </pre>
 
+h2. <a name="Combining unit testing and RushCheck">Combining unit testing and RushCheck</a>
+
+The library 'test/unit' of Ruby is useful for unit testing. Here is a trick to use 'test/unit'.
+
+<pre>
+  def forall(*cs, &f)
+    assert(RushCheck::Claim.new(*cs, &f).check)
+  end
+</pre>
+
+The class Claim is a subclass of Assertion. The meaning is almost similar to Assertion, however
+Claim does not check the result value of the given block 'f'. Because assertions in 'test/unit'
+such as 'assert_equal' does not return any result, but return nil, we don't need to check the
+result values of a sequence of assertions. Nevertheless we can check the testcase because
+the assertions in 'test/unit' raises an exception if the testcase is failed.
+
+Example:
+<pre>
+  def test_not_empty_after_push
+    array = Array.new
+    forall(Integer) do |item|
+      array.push item
+      assert(! array.empty?)
+    end
+  end
+</pre>
+
+h2. <a name="Combining RSpec and RushCheck">Combining RSpec and RushCheck</a>
+"RSpec":http://rspec.rubyforge.org is another testing framework which helps Behaviour Driven Development (BDD).
+To combine RSpec and RushCheck, the following trick maybe useful and easy to read:
+<pre>
+  def forall(*cs, &f)
+    RushCheck::Claim.new(*cs, &f).check.should_equal true
+  end
+</pre>
+
+Then, for example, we can write a specification of Array#push as follows:
+<pre>
+context "An empty array" do
+
+  specify "should not be empty after 'push'" do
+    forall(Integer) do |item|
+      array = Array.new
+      array.push item
+      array.should_not_be_empty
+    end
+  end
+
+end
+</pre>
+
+See also 'examples/rspec' in the distribution of RushCheck for details.
+
 h2. <a name="With another basic classes for assertions">With another basic classes for assertions</a>
 
 In previous sections, we have seen how to check assertions for any

data/data/rushcheck/examples/proc.rb

@@ -13,7 +13,7 @@ class Proc
   end
 end
 
-class MyRandomProc < RushCheck::RandomProc; end
+class MyRandomProc < RandomProc; end
 
 def associativity_integer
   MyRandomProc.set_pattern([Integer], [Integer])

data/data/rushcheck/examples/rspec/stack.rb

@@ -0,0 +1,42 @@
+# This example is quoted from the RSpec tutorial.
+# check also http://rspec.rubyforge.org/tutorials/index.html
+
+class StackUnderflowError < RuntimeError; end
+class StackOverflowError  < RuntimeError; end
+
+class Stack
+
+  SIZE = 5
+
+  def initialize
+    @items = []
+  end
+  
+  def empty?
+    @items.empty?
+  end
+
+  def length
+    @items.length
+  end
+
+  def full?
+    @items.length == SIZE
+  end
+
+  def push(item)
+    raise StackOverflowError  if full?
+    @items.push item
+  end
+
+  def pop
+    raise StackUnderflowError if empty?
+    @items.pop
+  end
+
+  def peek
+    raise StackUnderflowError if empty?
+    @items.last
+  end
+
+end

data/data/rushcheck/examples/rspec/stack_spec.rb

@@ -0,0 +1,223 @@
+# This example is quoted from the RSpec tutorial and also
+# test/spec.
+# check also 
+#   http://rspec.rubyforge.org/tutorials/index.html
+#   http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/217242
+#
+# To execute this example, you have to follow
+# 1. install rspec
+#    % sudo gem install rspec
+# 2. then, execute the 'spec' command
+#    % spec stack_spec.rb -f s
+#
+# On my PowerBook PC, this example takes about 50 seconds.
+
+begin
+  require 'rubygems'
+  require_gem 'rushcheck'
+rescue LoadError
+  require 'rushcheck'
+end
+
+def forall(*cs, &f)
+  RushCheck::Claim.new(*cs, &f).check.should_equal true
+end
+
+require 'stack'
+
+context "An empty stack" do
+
+  specify "should not be empty after 'push'" do
+    forall(Integer) do |item|
+      stack = Stack.new
+      stack.push item
+      stack.should_not_be_empty
+    end
+  end
+
+end
+
+# setup for general stack
+class NotEmptyAndFullStack < Stack
+  extend RushCheck::Arbitrary
+
+  def self.arbitrary
+    stack = self.new
+    RushCheck::Gen.choose(1, SIZE-2).bind do |size|
+      RushCheck::Gen.vector(String, size).fmap do |ary|
+        ary.each { |i| stack.push i }
+        stack
+      end
+    end
+  end
+end
+
+context "A stack (in general)" do
+
+  setup do
+    puts "  This test consumes time. Please wait few seconds."
+  end
+
+  specify "should add the top when sent 'push'" do
+    forall(NotEmptyAndFullStack, String) do |stack, item|
+      stack.push item
+      stack.peek.should_equal item
+    end
+  end
+
+  specify "should NOT remove the top item when sent 'peek'" do
+    forall(NotEmptyAndFullStack, Integer) do |stack, item| 
+      stack.push item
+      stack.peek.should_equal item
+      stack.peek.should_equal item
+    end
+  end
+
+ specify "should return the top item when sent 'pop'" do
+   forall(NotEmptyAndFullStack, Integer) do |stack, item| 
+     stack.push item
+     stack.pop.should_equal item
+   end
+ end
+
+  specify "should remove the top item when sent 'pop'" do
+    forall(NotEmptyAndFullStack, Integer, Integer) do |stack, dummy, item| 
+      stack.push item
+      stack.push dummy
+      stack.pop
+      stack.pop.should_equal item
+    end
+  end
+
+end
+
+context "An empty stack" do
+
+  specify "should be empty" do
+    Stack.new.should_be_empty
+  end
+
+  specify "should no longer be empty" do
+    forall(Integer) do |item|
+      stack = Stack.new
+      stack.push item
+      stack.should_not_be_empty
+    end
+  end
+
+  specify "should complain when sent 'peek'" do
+    lambda { Stack.new.peek }.should_raise StackUnderflowError
+  end
+
+  specify "should complain when sent 'pop'" do
+    lambda { Stack.new.pop }.should_raise StackUnderflowError
+  end
+end
+
+context "An almost empty stack (with one item)" do
+  specify "should not be empty" do
+    forall(Integer) do |item|
+      stack = Stack.new
+      stack.push item
+      stack.should_not_be_empty
+    end
+  end
+  
+  specify "should remain not empty after 'peek'" do
+    forall(Integer) do |item|
+      stack = Stack.new
+      stack.push item
+      stack.peek
+      stack.should_not_be_empty
+    end
+  end
+  
+  specify "should become empty after 'pop'" do
+    forall(Integer) do |item|
+      stack = Stack.new
+      stack.push item
+      stack.pop
+      stack.should_be_empty
+    end
+  end
+  
+end
+
+# setup for almost full stack
+class AlmostFullStack < Stack
+  extend RushCheck::Arbitrary
+
+  def self.arbitrary
+    stack = self.new
+    RushCheck::Gen.vector(String, SIZE-1).fmap do |ary|
+      ary.each { |i| stack.push i }
+      stack
+    end
+  end
+end
+
+context "An almost full stack (with one item less than capacity)" do
+
+  setup do
+     puts "  This test consumes time. Please wait few seconds."
+  end
+
+  specify "should not be full" do
+    forall(AlmostFullStack) do |stack|
+      stack.should.not.be.full
+    end
+  end
+  
+  specify "should become full when sent 'push'" do
+    forall(AlmostFullStack, Integer) do |stack, item|
+      stack.push item
+      stack.should.be.full
+    end
+  end
+end
+
+# setup for full stack
+class FullStack < Stack
+  extend RushCheck::Arbitrary
+
+  def self.arbitrary
+    stack = self.new
+    RushCheck::Gen.vector(String, SIZE).fmap do |ary|
+      ary.each { |i| stack.push i }
+      stack
+    end
+  end
+end
+
+context "A full stack" do
+  
+   setup do
+      puts "  This test consumes time. Please wait few seconds."
+   end
+
+  specify "should be full" do
+    forall(FullStack) do |stack|
+      stack.should.be.full
+    end
+  end
+  
+  specify "should remain full after 'peek'" do
+    forall(FullStack) do |stack|
+      stack.peek
+      stack.should.be.full
+    end
+  end
+  
+  specify "should no longer be full after 'pop'" do
+    forall(FullStack) do |stack|
+      stack.pop
+      stack.should.not.be.full
+    end
+  end
+
+  specify "should complain on 'push'" do
+    forall(FullStack, Integer) do |stack, item|
+      lambda { stack.push item }.should.raise StackOverflowError
+    end
+  end
+end

data/data/rushcheck/rdoc/classes/RushCheck/Arbitrary.src/M000035.html

@@ -10,7 +10,7 @@
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
-  <pre><span class="ruby-comment cmt"># File rushcheck/arbitrary.rb, line 16</span>
+  <pre><span class="ruby-comment cmt"># File rushcheck/arbitrary.rb, line 30</span>
     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">arbitrary</span>
       <span class="ruby-identifier">raise</span>(<span class="ruby-constant">NotImplementedError</span>, <span class="ruby-value str">&quot;This method should be overrided.&quot;</span>)
     <span class="ruby-keyword kw">end</span></pre>

data/data/rushcheck/rdoc/classes/RushCheck/Assertion.html

@@ -97,10 +97,21 @@ href="../Integer.html">Integer</a>, <a href="../String.html">String</a>) do
 end
 </p>
 <p>
+The return value of the body of testcase is checked by the method
+&#8216;check&#8217;.
+</p>
+<p>
 Note that the number of arguments in the block must be equal to the number
-of arguments of <a href="Assertion.html#M000073">Assertion.new</a>. See
-also the <a href="../RushCheck.html">RushCheck</a> tutorial and several
-examples.
+of arguments of <a href="Assertion.html#M000073">Assertion.new</a>.
+However, for a curried block, we can write also
+</p>
+<pre>
+  Assertion.new(*cs) {|*xs| ...}
+</pre>
+<p>
+See also class <a href="Claim.html">Claim</a>, which is a subclass of <a
+href="Assertion.html">Assertion</a> See also the <a
+href="../RushCheck.html">RushCheck</a> tutorial and several examples.
 </p>
 
     </div>

data/data/rushcheck/rdoc/classes/RushCheck/Assertion.src/M000073.html

@@ -10,9 +10,8 @@
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
-  <pre><span class="ruby-comment cmt"># File rushcheck/assertion.rb, line 28</span>
+  <pre><span class="ruby-comment cmt"># File rushcheck/assertion.rb, line 35</span>
     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">xs</span>, <span class="ruby-operator">&amp;</span><span class="ruby-identifier">f</span>)
-      <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">f</span>.<span class="ruby-identifier">arity</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">xs</span>.<span class="ruby-identifier">length</span>
       <span class="ruby-ivar">@inputs</span> = <span class="ruby-identifier">xs</span>[<span class="ruby-value">0</span><span class="ruby-operator">..</span>(<span class="ruby-identifier">f</span>.<span class="ruby-identifier">arity</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)]
       <span class="ruby-ivar">@proc</span> = <span class="ruby-identifier">f</span>
     <span class="ruby-keyword kw">end</span></pre>

data/data/rushcheck/rdoc/classes/RushCheck/Assertion.src/M000074.html

@@ -10,41 +10,14 @@
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
-  <pre><span class="ruby-comment cmt"># File rushcheck/assertion.rb, line 34</span>
+  <pre><span class="ruby-comment cmt"># File rushcheck/assertion.rb, line 79</span>
     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">property</span>
-      <span class="ruby-identifier">g</span> = <span class="ruby-constant">RushCheck</span><span class="ruby-operator">::</span><span class="ruby-constant">Gen</span>.<span class="ruby-identifier">new</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">n</span>, <span class="ruby-identifier">r</span><span class="ruby-operator">|</span>
-        <span class="ruby-identifier">r2</span> = <span class="ruby-identifier">r</span>
-        <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@inputs</span>
-        <span class="ruby-keyword kw">then</span>
-          <span class="ruby-ivar">@inputs</span>.<span class="ruby-identifier">map</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">c</span><span class="ruby-operator">|</span>
-            <span class="ruby-identifier">r1</span>, <span class="ruby-identifier">r2</span> = <span class="ruby-identifier">r2</span>.<span class="ruby-identifier">split</span>
-            <span class="ruby-identifier">c</span>.<span class="ruby-identifier">arbitrary</span>.<span class="ruby-identifier">value</span>(<span class="ruby-identifier">n</span>, <span class="ruby-identifier">r1</span>)
-          <span class="ruby-keyword kw">end</span>
-        <span class="ruby-keyword kw">else</span>
-          []
+      <span class="ruby-identifier">_property</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">args</span><span class="ruby-operator">|</span>
+        <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@proc</span>.<span class="ruby-identifier">call</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
+        <span class="ruby-keyword kw">then</span> <span class="ruby-constant">RushCheck</span><span class="ruby-operator">::</span><span class="ruby-constant">Result</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">true</span>)
+        <span class="ruby-keyword kw">else</span> <span class="ruby-constant">RushCheck</span><span class="ruby-operator">::</span><span class="ruby-constant">Result</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">false</span>)
         <span class="ruby-keyword kw">end</span>
-      <span class="ruby-keyword kw">end</span>.<span class="ruby-identifier">bind</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">args</span><span class="ruby-operator">|</span>
-        <span class="ruby-identifier">test</span> = <span class="ruby-keyword kw">begin</span>
-                 <span class="ruby-ivar">@proc</span>.<span class="ruby-identifier">call</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
-               <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">Exception</span> =<span class="ruby-operator">&gt;</span> <span class="ruby-identifier">ex</span>
-                 <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">ex</span>
-                 <span class="ruby-keyword kw">when</span> <span class="ruby-constant">RushCheck</span><span class="ruby-operator">::</span><span class="ruby-constant">GuardException</span>
-                   <span class="ruby-constant">RushCheck</span><span class="ruby-operator">::</span><span class="ruby-constant">Result</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">nil</span>)
-                 <span class="ruby-keyword kw">else</span>
-                   <span class="ruby-identifier">err</span> = <span class="ruby-node">&quot;Unexpected exception: #{ex.inspect}\n&quot;</span> <span class="ruby-operator">+</span> 
-                     <span class="ruby-identifier">ex</span>.<span class="ruby-identifier">backtrace</span>.<span class="ruby-identifier">join</span>(<span class="ruby-value str">&quot;\n&quot;</span>)
-                   <span class="ruby-constant">RushCheck</span><span class="ruby-operator">::</span><span class="ruby-constant">Result</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword kw">false</span>, [], [<span class="ruby-identifier">err</span>])
-                 <span class="ruby-keyword kw">end</span>
-               <span class="ruby-keyword kw">end</span>
-        <span class="ruby-comment cmt"># not use ensure here because ensure clause</span>
-        <span class="ruby-comment cmt"># does not return values</span>
-        <span class="ruby-identifier">test</span>.<span class="ruby-identifier">property</span>.<span class="ruby-identifier">gen</span>.<span class="ruby-identifier">fmap</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">res</span><span class="ruby-operator">|</span>
-          <span class="ruby-identifier">res</span>.<span class="ruby-identifier">arguments</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">inspect</span>
-          <span class="ruby-identifier">res</span>
-        <span class="ruby-keyword kw">end</span>
-      <span class="ruby-keyword kw">end</span>
-
-      <span class="ruby-constant">RushCheck</span><span class="ruby-operator">::</span><span class="ruby-constant">Property</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">g</span>)
+        }
     <span class="ruby-keyword kw">end</span></pre>
 </body>
 </html>