% sudo gem install rushcheck

% sudo ruby setup.rb

% setup.rb help

% darcs get --partial http://rushcheck.rubyforge.org/repos/rushcheck

% darcs pull -a

require 'rubygems'
require_gem 'rushcheck'

require 'rushcheck'

begin
  require 'rubygems'
  require_gem 'rushcheck'
rescue LoadError
  require 'rushcheck'
end

require 'your_library'

RushCheck::Assertion.new(Class1, Class2, ...) do |var1, var2, ...|
  # testing property block
  # this block should return boolean value (true, false or nil)
  # in Ruby
end

ast_zero = 
  RushCheck::Assertion.new() do 
    [].sort == []
  end

ast_one = 
  RushCheck::Assertion.new(Integer) do |x|
    [x].sort == [x]
  end

irb> ast_one.verbose_check
1:
[-1]
2:
[-2]
... (snip) ...
99:
[6]
100:
[1]
OK, passed 100 tests.
true
irb> ast_one.check
OK, passed 100 tests.
true
irb>

ast_two = 
  RushCheck::Assertion.new(Integer, Integer) do |x, y|
    [x, y].sort == [x, y]
  end

irb> ast_two.check
Falsifiable, after 3 tests:
[2, -1]
false
irb>

ast_two_sorted =
  RushCheck::Assertion.new(Integer, Integer) do |x, y|
    RushCheck::guard { x <= y }
    [x, y].sort == [x, y]
  end

irb> ast_two_sorted.check
OK, passed 100 tests.
true
irb>

ast_sort_triv =
  RushCheck::Assertion.new(Integer, Integer) do |x, y|
    RushCheck::guard {x <= y}
    ([x, y].sort == [x, y]).trivial{ x == y }
  end

irb> ast_sort_triv.check
OK, passed 100 tests(14%, trivial).
true

ast_sort_classify =
  RushCheck::Assertion.new(Integer, Integer) do |x, y|
    RushCheck::guard {x <= y}
    test = ([x, y].sort == [x, y])
    test.classify('same'){ x == y }.
      classify('bit diff'){ (x - y).abs == 1 } 
  end

irb> ast_sort_classify.check
OK, passed 100 tests.
18%, same.
11%, bit diff.
true
irb>

  def forall(*cs, &f)
    assert(RushCheck::Claim.new(*cs, &f).check)
  end

  def test_not_empty_after_push
    array = Array.new
    forall(Integer) do |item|
      array.push item
      assert(! array.empty?)
    end
  end

  def forall(*cs, &f)
    RushCheck::Claim.new(*cs, &f).check.should_equal true
  end

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

RushCheck::Assertion.new(Float, String, ...) do |ratio, name,...|
  # testcase
end

malformed_format_string =
  RushCheck::Assertion.new(String) { |s| sprintf(s); true}

malformed_format_string2 =
  RushCheck::Assertion.new(SpecialString) { |s| sprintf(s); true}

irb> malformed_format_string.check
Falsifiable, after 86 tests:
Unexpected exception: #
    ... snip error traces ...
["\n&'e!]hr(%&\031Vi\003 }ss"]
false
irb> malformed_format_string2.check
Falsifiable, after 15 tests:
Unexpected exception: #
["%\037-R"]
false

class YourSpecialString < SpecialString
  @@frequency = { 'alphabet' => 1,
                  'control'  => 0,
                  'number'   => 0,
                  'special'  => 9 }  
end

# for random array of integers
class MyRandomArray < RandomArray; end
MyRandomArray.set_pattern(Integer) {|ary, i| Integer}

MyRandomArray.set_pattern(Integer) do |ary, i|
  if i % 2 == 0
  then Integer
  else String
  end
end

MyRandomArray.set_pattern(Integer) do |ary, i|
  if ary[i].kind_of?(Integer) && ary[i] >= 0
  then String
  else Integer
  end
end 

class MyRandomHash < RandomHash; end
pat = { 'key1' => Integer, 'key2' => String }
MyRandomHash.set_pattern(pat)

class MyRandomProc < RandomProc; end
MyRandomProc.set_pattern([Integer], [Integer])

  for all x, f(g(h(x)) === (f . g)(h (x))
     where f . g is a composition of functions in mathematical way

class Proc
  # application
  def **(other)
    Proc.new do |*args|
      res = other.call(*args)
      call(*res)
    end
  end
end

class MyRandomProc < RandomProc; end

def associativity_integer
  MyRandomProc.set_pattern([Integer], [Integer])
  RushCheck::Assertion.new(MyRandomProc, MyRandomProc, 
                           MyRandomProc, Integer) do
    |f, g, h, x|
    (f ** (g ** h)).call(x) == ((f ** g) ** h).call(x)
  end.check
end

RushCheck::Assertion.new(YourClass) { |obj, ...| ...}

class YourClass
  extend RushCheck::Arbitrary

  def self.arbitrary
    # override the class method arbitrary 
    ...
  end
end

class YourClass
  extend RushCheck::Arbitrary
  include RushCheck::Coarbitrary

  def self.arbitrary
    ...
  end

  def coarbitrary(g)
    ...
  end
end

class Candy

  def initialize(name, price)
    raise unless price >= 0
    @name, @price = name, price
  end

  def foo
    ...
  end

  def bar
    ...
  end

end

class Candy
  extend Arbitrary

  def self.arbitrary
    RushCheck::Gen.create(String, Integer) do |name, price|
      RushCheck::guard { price >= 0 }
      new(name, price)
    end
  end
end

  price = - price if price < 0   # g.guard { price >= 0 }

class Candy
  extend RushCheck::Arbitrary

  def self.arbitrary
    String.arbitrary.bind do |name|
      Integer.arbitrary.bind do |price|
        price = - price if price < 0   # trick as I described above
        RushCheck::Gen.unit(new(name, price))
      end
    end
  end
end

class Candy
  extend RushCheck::Arbitrary

  def self.arbitrary
    RushCheck::Gen.new do |n, r|
      r2 = r
      name, price = [String, Integer].map do |c|
        r1, r2 = r2.split
        c.arbitrary.value(n. r1)
      end
    price = - price if price < 0 # trick
      new(name, price)
    end
  end
end

    RushCheck::guard { price >= 100000 }  # very expensive candy!

lo = 100000
g = RushCheck::Gen.sized { |n| RushCheck::Gen.choose(lo, n + lo)}
xs = [String.arbitrary, g]

Gen.choose(0, 10) # a generator of Integer in (0..10)

Gen.frequency([[3, Integer.arbitrary], [7, String.arbitrary]])
   # return a random integer or a random string (by choosing
   # randomly) Integer:30% String: 70%

class Candy
  extend RushCheck::Arbitrary

  def self.arbitrary
    RushCheck::Gen.lift_array([Integer, String]) do |c| 
      c.arbitrary
    end.bind do |args|
      new(*args)
    end
  end
end

Gen.oneof([Integer.arbitrary, String.arbitrary])
  # return a random integer or a random string (by choosing
  # randomly)

Gen.vector(Integer, 3) # => Gen [Integer, Integer, Integer]