queencheck 0.1.2 → 1.0.0

data/Gemfile

@@ -1,5 +1,7 @@
 source "http://rubygems.org"
 
+gem "colorize", ">= 0.5.8"
+
 group :development, :test do
   gem "rake", ">= 0.9.2.2"
   gem "rspec", ">= 2.8.0"
@@ -17,4 +19,6 @@ group :development do
   gem "guard-yard", ">= 1.0.2"
   gem "yard", ">= 0.7.4"
   gem "yard-tomdoc", ">= 0.3.0"
+  gem "redcarpet"
+  gem "pry"
 end

data/Guardfile

@@ -8,7 +8,7 @@ spork_port = RUBY_VERSION >= '1.9.2' ? 8989 : 8988
 guard 'spork', :cucumber => false, :bundler => false, :rspec_port => spork_port do
 end
 
-guard 'rspec', :version => 2, :cli => "--drb --drb-port #{spork_port} --color --format Fuubar" do
+guard 'rspec', :version => 2, :cli => "--drb --drb-port #{spork_port} --color --format doc" do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
@@ -16,5 +16,6 @@ end
 
 guard 'yard', :plugin => 'yard-tomdoc' do
   watch(%r{lib/.+\.rb})
+  watch(%r{README})
 end
 

data/README.md

@@ -0,0 +1,119 @@
+# QueenCheck [![Build Status](https://secure.travis-ci.org/rosylilly/QueenCheck.png)](http://travis-ci.org/rosylilly/QueenCheck) [![Gem Status](https://gemnasium.com/rosylilly/QueenCheck.png)](https://gemnasium.com/rosylilly/QueenCheck)
+
+QueenCheck is random test library.
+
+Inspired by QuickCheck library in Haskell.
+
+## Usage
+
+    $ gem install queencheck
+
+or
+
+    $ git clone git://github.com/rosylilly/QueenCheck.git QueenCheck
+    $ cd QueenCheck
+    $ bundle install
+    $ bundle exec rake install
+
+## CI Report
+
+[See Travis-CI](http://travis-ci.org/#!/rosylilly/QueenCheck)
+
+## Abstract
+
+let's start DDT(Data Driven Testing)
+
+    require 'queencheck'
+
+    def plus(x, y)
+      x + y
+    end
+
+    prop_Plus = QueenCheck::Testable.new(Integer, Integer) do | x, y |
+      plus(x, y) == x + y
+    end
+    puts prop_Plus.check.pretty_report
+    # Tests: 100
+    #   ✓ Successes  : 100
+    #   ✗ Failures   :   0
+    #   ✷ Exceptions :   0
+
+with `exception`, `labeling` and `where`
+
+    def div(x, y)
+      x / y # => raise ZeroDividedError if y == 0
+    end
+
+    prop_Div = QueenCheck::Testable.new(Integer, Integer) do | x, y |
+      div(x, y) == x / y
+    end
+    puts prop_Div.check.pretty_report
+    # Tests: 100
+    #   ✓ Successes  :  99
+    #   ✗ Failures   :   1
+    #   ✷ Exceptions :   1
+
+    puts prop_Div.check_with_label(
+      "x > y" => proc{|x,y| x > y },
+      "x < y" => proc{|x,y| x < y },
+      "x = y" => proc{|x,y| x == y },
+      "x is 0" => proc{|x,y| x.zero? },
+      "y is 0" => proc{|x,y| y.zero? }
+    ).pretty_report
+    # Tests: 100
+    #  ✓ Successes  :  99
+    #    x > y  :  43
+    #    x < y  :  56
+    #    x = y  :   0
+    #    x is 0 :   0
+    #    y is 0 :   0
+    #  ✗ Failures   :   1
+    #    x > y  :   0
+    #    x < y  :   0
+    #    x = y  :   1
+    #    x is 0 :   1
+    #    y is 0 :   1
+    #  ✷ Exceptions :   1
+    #    x > y  :   0
+    #    x < y  :   0
+    #    x = y  :   1
+    #    x is 0 :   1
+    #    y is 0 :   1
+
+    int_generater = Integer.arbitrary.gen # => QueenCheck::Gen
+    nonzero_integer = int_generater.where{|num| !num.zero? }
+    prop_DivSuccess = QueenCheck::Testable.new(nonzero_integer, nonzero_integer) do | x, y |
+      div(x, y) == x / y
+    end
+    puts prop_DivSuccess.check_with_label(
+      "x > y" => proc{|x,y| x > y },
+      "x < y" => proc{|x,y| x < y },
+      "x = y" => proc{|x,y| x == y },
+      "x is 0" => proc{|x,y| x.zero? },
+      "y is 0" => proc{|x,y| y.zero? }
+    ).pretty_report
+    # Tests: 99
+    #   ✓ Successes  : 99
+    #     x > y  : 55
+    #     x < y  : 44
+    #     x = y  :  0
+    #     x is 0 :  0
+    #     y is 0 :  0
+    #   ✗ Failures   :  0
+    #     x > y  :  0
+    #     x < y  :  0
+    #     x = y  :  0
+    #     x is 0 :  0
+    #     y is 0 :  0
+    #   ✷ Exceptions :  0
+    #     x > y  :  0
+    #     x < y  :  0
+    #     x = y  :  0
+    #     x is 0 :  0
+    #     y is 0 :  0
+
+## Help me
+
+please fork [QueenCheck repository](https://github.com/rosylilly/QueenCheck).
+
+__I'm waiting for the code review of you !__

data/Rakefile

@@ -28,3 +28,14 @@ begin
 rescue LoadError
   puts "YARD not available. Install it with: bundle install"
 end
+
+begin
+  require 'pry'
+
+  task "pry" do
+    require './lib/queencheck'
+    binding.pry
+  end
+rescue LoadError
+  puts "Pry not available. Install it with: gem intall pry"
+end

data/VERSION

@@ -1 +1 @@
-0.1.2
+1.0.0

data/lib/queencheck.rb

@@ -1,17 +1,20 @@
-require "pathname"
-$:.unshift Pathname.new(File.expand_path('../', __FILE__))
+# QueenCheck is Test Utility Library like Quick Check in Haskell.
+#
+# == Examples:
+# 
+#     QueenCheck(Integer, Integer) do | x, y |
+#       x + y == y + x
+#     end
+module QueenCheck
+  # QueenCheck Version
+  VERSION = '1.0.0'
+end
 
+$: << File.dirname(File.expand_path(__FILE__))
 require 'queencheck/core'
 require 'queencheck/arbitrary'
+require 'queencheck/gen'
+require 'queencheck/condition'
+require 'queencheck/exception'
 
-require 'queencheck/integer'
-require 'queencheck/float'
-require 'queencheck/boolean'
-require 'queencheck/array'
-require 'queencheck/string'
-
-module QueenCheck
-  unless defined? Version
-    Version = `cat #{Pathname.new(File.expand_path('../../', __FILE__))}/VERSION`.strip
-  end
-end
+require 'queencheck/arbitraries/all'

data/lib/queencheck/arbitraries/all.rb

@@ -0,0 +1,5 @@
+# require all default arbitrary
+
+require 'queencheck/arbitraries/boolean'
+require 'queencheck/arbitraries/integer'
+require 'queencheck/arbitraries/string'

data/lib/queencheck/arbitraries/boolean.rb

@@ -0,0 +1,5 @@
+require 'queencheck/arbitrary'
+
+class Boolean
+  arbitrary QueenCheck::Gen.elements_of([true, false])
+end

data/lib/queencheck/arbitraries/integer.rb

@@ -0,0 +1,17 @@
+require 'queencheck/arbitrary'
+
+class Integer
+  arbitrary QueenCheck::Gen.quadratic(1<<20).bind { |n|
+    QueenCheck::Gen.rand.resize(-(n.ceil), n.ceil)
+  }
+end
+
+class Fixnum
+  arbitrary Integer.arbitrary.gen
+end
+
+class Bignum
+  arbitrary QueenCheck::Gen.quadratic(1<<20, 1, (1 << (0.size * 8))).bind {|n|
+    QueenCheck::Gen.rand.resize(-(n.ceil), n.ceil)
+  }
+end

data/lib/queencheck/arbitraries/string.rb

@@ -0,0 +1,39 @@
+require 'queencheck/arbitrary'
+
+module QueenCheck
+  class ASCIIChar
+    arbitrary QueenCheck::Gen.choose(0, 127).bind { | c |
+      QueenCheck::Gen.unit(c.chr)
+    }
+  end
+
+  class Alphabet
+    class LowerCase
+      arbitrary QueenCheck::Gen.choose(97, 122).bind { | c |
+        QueenCheck::Gen.unit(c.chr)
+      }
+    end
+
+    class UpperCase
+      arbitrary QueenCheck::Gen.choose(65, 90).bind { | c |
+        QueenCheck::Gen.unit(c.chr)
+      }
+    end
+
+    arbitrary QueenCheck::Gen.one_of([LowerCase.arbitrary.gen, UpperCase.arbitrary.gen])
+  end
+end
+
+class String
+  arbitrary QueenCheck::Gen.quadratic(20000).bind { | length |
+    if length.zero?
+      QueenCheck::Gen.unit("")
+    else
+      QueenCheck::Gen.rand.resize(1, length).fmap { | r |
+        str = []
+        r.times { str << QueenCheck::ASCIIChar.arbitrary.gen.value(0)[0] }
+        str.join()
+      }
+    end
+  }
+end

data/lib/queencheck/arbitrary.rb

@@ -1,56 +1,100 @@
+require 'queencheck/gen'
 
 module QueenCheck
   class << self
-    def Arbitrary(name = nil, &block)
-      if block.nil? && !name.nil?
-        return QueenCheck::Arbitrary::Instance.get_by_id(name)
-      else
-        return QueenCheck::Arbitrary::Instance.new(name, &block)
-      end
-      nil
+    # set or get arbitrary
+    # @overload Arbitrary(name)
+    #   @param [#name or #to_s] name arbitrary name
+    #   @return [QueenCheck::Arbitrary]
+    # @overload Arbitrary(name, gen)
+    #   @param [#name or #to_s] name arbitrary name
+    #   @param [QueenCheck::Gen or Proc] gen arbitrary generator
+    #   @return [Symbol or String] stored arbitrary name
+    # @overload Arbitrary(name, &block)
+    #   @param [#name or #to_s] name arbitrary name
+    #   @param [Proc] block arbitrary generator source
+    #   @return [Symbol or String] stored arbitrary name
+    def Arbitrary(name, gen = nil, &block)
+      generator = gen || block
+
+      generator.nil? ? Arbitrary.from_dic(name) : Arbitrary.new(name, generator)
     end
   end
-  module Arbitrary
-    class NotQueenCheckArbitrary < StandardError; end
 
-    def arbitrary?; true; end
+  # QueenCheck Arbitrary class
+  # @example
+  #   QueenCheck::Arbitrary(Integer, QueenCheck::Gen.unit(0))
+  class Arbitrary
+    @@dictionary = {}
 
-    def arbitrary(seed)
-      raise NotImplementedError
+    # new instance of QueenCheck::Arbitrary
+    # @overload initialize(name, gen)
+    #   @param [#name or #to_s] name arbitrary name
+    #   @param [QueenCheck::Gen or Proc] gen arbitrary generater
+    # @overload initialize(name, &block)
+    #   @param [#name or #to_s] name arbitrary name
+    #   @param [Proc] block arbitrary generater source
+    def initialize(name, gen, &block)
+      gen = block || gen
+      @gen = gen.instance_of?(QueenCheck::Gen) ? gen : QueenCheck::Gen.new(&gen)
+      @name = QueenCheck::Arbitrary.to_dic(name, self)
     end
 
-    def set_arbitrary(&block)
-      self.module_eval do
-        sig = class << self; self; end
-        sig.send(:define_method, :arbitrary, &block)
-      end
+    # @return [Symbol or String] arbitrary name
+    attr_reader :name
+    # @return [QueenCheck::Gen] arbitrary generater
+    attr_reader :gen
+
+
+    # store arbitrary to dictionary
+    # @param [#name or #to_s] name arbitrary name
+    # @param [QueenCheck::Arbitrary] arb store arbitrary
+    # @return [Symbol or String] stored arbitrary name
+    def self.to_dic(name, arb)
+      name = name.respond_to?(:name) ? name.name : name.to_s
+      @@dictionary[name] = arb
+      return name
     end
 
-    class Instance
-      @@collection = {}
-      def self.get_by_id(name); return @@collection[name.to_s.to_sym]; end
-      def self.collection=(c); @@collection = c; end
-      def self.collection; @@collection; end
-
-      def initialize(name = nil, &block)
-        raise ArgumentError, "require block" if block.nil?
-        @arbitrary_proc = block
-        @name = name.to_s.to_sym unless name.nil?
-        unless @name.nil?
-          @@collection[@name] = self
-        end
-      end
-      attr_reader :name
-
-      def arbitrary?; true; end
-
-      def arbitrary(seed)
-        @arbitrary_proc.call(seed)
-      end
+    # get arbitrary from dictionary
+    # @param [#name or #to_s] name arbitrary name
+    # @return [QueenCheck::Arbitrary or nil] QueenCheck::Arbitrary where hit name dictionary
+    def self.from_dic(name)
+      name = name.respond_to?(:name) ? name.name : name.to_s
+      @@dictionary[name]
     end
   end
 end
 
-class BasicObject
-  def arbitrary?; false; end
+class Class
+  # set arbitrary to class or get arbitrary of class
+  # @overload arbitrary
+  #   get arbitrary of class
+  #   @return [QueenCheck::Arbitrary] arbitrary of class
+  # @overload arbitrary(gen)
+  #   set arbitrary of class
+  #   @param [QueenCheck::Gen] gen generater of arbitrary
+  # @overload arbitrary(&block)
+  #   set arbitrary of class
+  #   @param [Proc] block proc of new QueenCheck::Gen instance
+  # @return [QueenCheck::Arbitrary] arbitrary of class
+  # @example
+  #   class Klass
+  #     arbitrary QueenCheck::Gen.choose(0, 100)
+  #     #=> QueenCheck::Arbitrary
+  #   end
+  #   Klass.arbitrary #=> QueenCheck::Arbitrary
+  #
+  #   # set arbitrary
+  #   Klass.arbitrary {|p, r| Klass.new }
+  # @see QueenCheck.Arbitrary
+  def arbitrary(gen = nil, &block)
+    QueenCheck::Arbitrary(name, gen || block)
+  end
+
+  # check implemented arbitrary on class
+  # @return [Boolean] implemented arbitrary
+  def arbitrary?
+    !QueenCheck::Arbitrary(name).nil?
+  end
 end

data/lib/queencheck/condition.rb

@@ -0,0 +1,112 @@
+module QueenCheck
+  # QueenCheck condition class
+  # @example
+  #   QueenCheck::Alphabet::LowerCase.arbitrary.gen.where(:include? => ['a', 'b', 'c'])
+  class Condition
+    # @yield [value] generated value
+    # @yieldreturn [Boolean] matched?
+    def initialize(&condition)
+      @condition = condition
+    end
+
+    # @param [Object] n any value
+    # @return [Boolean] condition matched
+    def match?(n)
+      @condition.call(n)
+    end
+
+    # @visibility private
+    # @macro def_not
+    #   @method not_$1
+    #   not $1
+    #   @param (see QueenCheck::Condition.$1)
+    #   @scope class
+    #   @visibility public
+    #   @return [QueenCheck::Condition]
+    #   @see QueenCheck::Condition.$1
+    def self.def_not(method_name)
+      not_proc = proc { | *args |
+        cond = self.method(method_name).call(*args)
+        class << cond
+          def match?(n)
+            !@condition.call(n)
+          end
+        end
+
+        return cond
+      }
+
+      (class << self; self; end).instance_eval do
+        define_method('not_' + method_name.to_s, &not_proc)
+      end
+    end
+
+    # check value in ary
+    # 
+    # @param [Array] ary
+    # @return [QueenCheck::Condition]
+    def self.include?(ary)
+      new { |n|
+        ary.include?(n)
+      }
+    end
+    def_not :include?
+
+    # check instance of klass
+    # @param [Class] klass
+    # @return [QueenCheck::Condition]
+    def self.instance_of?(klass)
+      new { |n|
+        n.instance_of?(klass)
+      }
+    end
+    def_not :instance_of?
+
+    # check respond to method
+    # @param [Symbol, String] method method name
+    # @return [QueenCheck::Condition]
+    def self.respond_to?(method)
+      new { |n|
+        n.respond_to?(method)
+      }
+    end
+    def_not :respond_to?
+
+    # check nil
+    # @return [QueenCheck::Condition]
+    def self.nil?()
+      new { |n|
+        n.nil?
+      }
+    end
+    def_not :nil?
+
+    # check empty
+    # @return [QueenCheck::Condition]
+    def self.empty?()
+      new { |n|
+        n.empty?
+      }
+    end
+    def_not :empty?
+
+    # check equal m
+    # @param [Object] m
+    # @return [QueenCheck::Condition]
+    def self.equal?(m)
+      new { |n|
+        n == m
+      }
+    end
+    def_not :equal?
+
+    # check orderd array
+    # @return [QueenCheck::Condition]
+    def self.orderd?
+      new { |n|
+        n.sort == n
+      }
+    end
+    def_not :orderd?
+  end
+end