queencheck 0.1.2 → 1.0.0

data/lib/queencheck/core.rb

@@ -1,115 +1,100 @@
-require 'queencheck/config'
+require 'queencheck/exception'
+require 'queencheck/arbitrary'
+require 'queencheck/result'
 
 module QueenCheck
-  def self.new(*args)
-    QueenCheck::Core.new(*args)
-  end
-
-  class Core
-    def initialize(instance, method, *types)
-      @instance = instance
-      @method = method
-      @types = types.map do | type |
-        if type.respond_to?(:arbitrary?) && type.arbitrary?
-          next type
-        elsif type.kind_of?(Symbol)
-          arb = QueenCheck::Arbitrary::Instance.get_by_id(type)
-          next arb if arb
-        end
-        raise QueenCheck::Arbitrary::NotQueenCheckArbitrary, "`#{type}` is not implemented arbitrary"
-      end
+  # QueenCheck Testable Object
+  #
+  # @example
+  #   QueenCheck::Testable.new(Integer, Integer) do | x, y |
+  #     x + y == y + x
+  #   end
+  class Testable
+    # @param [Class(implmented arbitrary) or QueenCheck::Arbitrary or QueenCheck::Gen or Arbitrary Name] arbitraries
+    # @param [Proc] assertion assert proc
+    # @return [QueenCheck::Testable] new Testable instance
+    # @example
+    #   QueenCheck::Testable(Integer, Integer.arbitrary, Integer.arbitrary.gen, :Integer)
+    def initialize(*arbitraries, &assertion)
+      @arbitraries = arbitraries.map { | arbitrary |
+        arb = (
+          if arbitrary.instance_of?(QueenCheck::Arbitrary)
+            arbitrary.gen
+          elsif arbitrary.instance_of?(QueenCheck::Gen)
+            arbitrary
+          else
+            QueenCheck::Arbitrary(arbitrary)
+          end
+        )
+        raise TypeError, "Not Implemented Arbitrary or Gen: #{arbitrary}" if arb.nil?
+        arb.instance_of?(QueenCheck::Arbitrary) ? arb.gen : arb
+      }
+      @assertion = assertion
     end
 
-    def run(config = QueenCheck::Config.new, &block)
-      config = config.kind_of?(Hash) ? QueenCheck::Config.new(config) : config
+    DEFAULT_TEST_COUNT = 100
 
-      stats = QueenCheck::Core::Result.new(config.count)
-
-      config.count.times do | n |
-        range = n.to_f / config.count
-        arguments = []
-        @types.each do | type |
-          arguments.push(type.arbitrary(range))
+    # check assert
+    # @param [Integer] count number of tests
+    # @return [QueenCheck::ResultReport] ResultReport instance
+    def check(count = DEFAULT_TEST_COUNT)
+      results = QueenCheck::ResultReport.new
+      count.times do | n |
+        begin
+          results << self.assert(n.to_f / count)
+        rescue QueenCheck::CanNotRetryMore
+          next
         end
-
-        stats.push(QueenCheck::Core::Task.new(@instance, @method, arguments).run!(&block))
-
-        puts taks.to_s(true) if config.verbose?
       end
-
-      return stats
+      return results
     end
 
-    class Result
-      def initialize(examples)
-        @examples = examples
-        @tasks = []
-      end
-      attr_reader :examples
-
-      def push(obj)
-        @tasks.push(obj)
-      end
-
-      def [](index)
-        @tasks[index]
-      end
-
-      def passes
-        @tasks.reject {|task| !task.is_pass }.length
-      end
-
-      def failures
-        @tasks.reject {|task| task.is_pass }.length
-      end
-
-      def tasks(filter = :pass)
-        @tasks.reject {|task| task.is_pass == (filter == :pass ? false : true) }
+    # check assert with label for report
+    # @param [Hash] labels key is String. value is Proc.
+    # @param [Integer] count number of tests
+    # @return [QueenCheck::ResultReport] ResultReport instance
+    # @example
+    #   prop_int = QueenCheck::Testable(Integer, Integer){|x,y| true }
+    #   prop_int.check_with_label(
+    #     'x > y' => proc {|x,y| x > y}
+    #   )
+    def check_with_label(labels, count = DEFAULT_TEST_COUNT)
+      sets = check(count)
+      labels.each_pair do | label, proc |
+        sets.labeling(label, &proc)
       end
+      return sets
     end
 
-    class Task
-      def initialize(instance, method, args)
-        @is_pass = nil
-        @instance = instance
-        @method = method
-        @arguments = args
-        @result = nil
-        @exception = nil
-      end
-      attr_reader :is_pass, :instance, :method, :arguments, :result, :exception
-
-      def run!(&check_block)
-        return unless @is_pass.nil?
-        func = @method.respond_to?(:call) ? @method : @instance.method(@method)
-
-        begin
-          @result = func.call(*@arguments)
-        rescue Exception => e
-          @exception = e
+    DEFAULT_RETRY_COUNT = 100
+
+    # @param [Float] progress 0 .. 1
+    # @param [Integer] retry_count
+    #
+    # @return [Array<Object, Object ...>] generated values
+    def properties(progress, retry_count = DEFAULT_RETRY_COUNT)
+      @arbitraries.map { | gen |
+        c = 0
+        until (v = gen.value(progress))[1]
+          c += 1
+          raise QueenCheck::CanNotRetryMore, "can not retry generate: #{gen.inspect}" if c >= retry_count
         end
+        v[0]
+      }
+    end
 
-        @is_pass = !!check_block.call(@result, @arguments, @exception) if check_block
-
-        return self
-      end
-
-      def to_s(verbose = false)
-        if verbose
-          "<#{@instance.class.name}:#{@instance.object_id}>\##{@method.kind_of?(Method) ? @method.name : '::lambda::'}(" +
-          @arguments.map { |arg| "#{arg.class.name}:#{arg}" }.join(', ') +
-          ") => <#{@result.class.name}:#{@result}>" +
-          (!@is_pass ? " !! #{@exception.class.name}: #{@exception.message}" : '')
-        else
-          "#{@instance.class.name}\##{@method.respond_to?(:call) ? '::lambda::' : @method}(" +
-          @arguments.map {|arg| "#{arg}" } .join(', ') +
-          ") => #{@result}" + (!@is_pass ? "! #{@exception.class.name}: #{@exception.message}": '')
-        end
+    # run assert
+    # @param [Float] progress 0 .. 1
+    # @return [QueenCheck::Result] assert result
+    def assert(progress)
+      begin
+        props = properties(progress)
+        is_success = @assertion.call(*props)
+      rescue => ex
+        is_success = false
+        exception = ex
       end
+      QueenCheck::Result.new(props, is_success, exception)
     end
   end
 end
-
-def QueenCheck(*args)
-  QueenCheck.new(*args)
-end

data/lib/queencheck/exception.rb

@@ -0,0 +1,4 @@
+module QueenCheck
+  class CanNotRetryMore < SystemStackError
+  end
+end

data/lib/queencheck/gen.rb

@@ -0,0 +1,254 @@
+require 'queencheck/condition'
+
+module QueenCheck
+  class Gen
+    DEFAULT_BOUND = 1000
+
+    # @param [Hash] options generater options
+    # @option options [Integer] :min bound min
+    # @option options [Integer] :max bound max
+    # @option options [Array<QueenCheck::Condition>] :conditions array of conditions
+    # @yield [p, r] progress and random int
+    def initialize(options = {}, &block)
+      @proc = block
+
+      @bound_min  = options['min'] || options[:min] || 0
+      @bound_max  = options['max'] || options[:max] || DEFAULT_BOUND
+      @conditions = options['conditions'] || options[:conditions] || []
+    end
+
+    # get value form generater
+    #
+    # @param [Float] progress 0 .. 1
+    # @return [Array<Any, Boolean>] Any Value & Condition Matched
+    def value(progress)
+      v = @proc.call(progress, random)
+
+      cond = @conditions.inject(true) { | bool, cond |
+        bool && cond.match?(v)
+      }
+
+      return [v, cond]
+    end
+
+    # @return [Integer] random int in @bound_min .. @bound_max
+    def random
+      (@bound_min + rand * (@bound_max - @bound_min)).to_i
+    end
+
+    # @return [Hash] option
+    def option
+      {
+        :min        => @bound_min,
+        :max        => @bound_max,
+        :conditions => @conditions
+      }
+    end
+
+    # @private
+    def inspect
+      "<QueenCheck::Gen: {#{@proc.to_s}}>"
+    end
+
+    # resize bound of generater
+    #
+    # @param [Integer] lo lower bound
+    # @param [Integer] hi higher bound
+    # @example
+    #     QueenCheck::Gen.rand.resize(-100, 100) == QueenCheck::Gen.choose(-100, 100)
+    # @return [QueenCheck::Gen]
+    def resize(lo, hi)
+      self.class.new(option.merge({
+        :min => lo,
+        :max => hi
+      }), &@proc)
+    end
+
+    # bind function
+    # @yield [x] x is generated value
+    # @yieldreturn [QueenCheck::Gen]
+    # @return [QueenCheck::Gen]
+    def bind
+      self.class.new(option) { | p, r |
+        yield(value(p)[0]).value(p)[0]
+      }
+    end
+
+    # @yield [x] x is generated value
+    # @yieldreturn [Object]
+    # @return [QueenCheck::Gen]
+    def fmap
+      bind { | x |
+        self.class.unit(yield(x))
+      }
+    end
+
+    # set conditions
+    #
+    # @overload where(conditions)
+    #   @param [Hash] conditions { conditon_name => condition_param }
+    #   @option conditions [QueenCheck::Condition] any_primitive_condition see QueenCheck::Condition
+    # @overload where(){|value| ... }
+    #   @yield [value] value is generated value
+    #   @yieldreturn [Boolean]
+    #
+    # @see QueenCheck::Condition
+    #
+    # @return [QueenCheck::Gen] new generater
+    #
+    # @example
+    #     QueenCheck::Gen.elements_of(['a', 'b', 'c']).where(
+    #       :include? => ['1', 'a', 'A'],
+    #       :equal? => 'a'
+    #     )
+    #
+    #     QueenCheck::Gen.choose(0, 100).where { |v|
+    #       v.odd?
+    #     }
+    def where(conditions = {}, &block)
+      self.class.new(option.merge({
+        :conditions => @conditions + conditions.to_a.map { | el |
+          cond = el[0].to_s.sub(/([^\?])$/){$1 + '?'}
+          QueenCheck::Condition.method(cond).call(el[1])
+        } + (
+          !block.nil? ? [QueenCheck::Condition.new(&block)] : []
+        )
+      }), &@proc)
+    end
+
+    ## class methods:
+   
+    # choose value where >= lo and <= hi
+    # @param [Integer] lo bound min
+    # @param [Integer] hi bound max
+    # @example
+    #   QueenCheck::Gen.choose(0, 100)
+    # @return [QueenCheck::Gen]
+    def self.choose(lo, hi)
+      elements_of((lo .. hi).to_a)
+    end
+
+    # choose value from ary
+    # @param [Array] ary
+    # @example
+    #   QueenCheck::Gen.elements_of([0, 1, 2])
+    # @return [QueenCheck::Gen]
+    def self.elements_of(ary)
+      new({
+        :min => 0,
+        :max => ary.size
+      }) { | p, r |
+        ary[r]
+      }
+    end
+
+    # one of generater
+    # @param [Array<QueenCheck::Gen>] ary list of Generaters
+    # @example
+    #   QueenCheck::Gen.one_of([
+    #     QueenCheck::Gen.elements_of([0, 1, 3]),
+    #     QueenCheck::Gen.elements_of(["A", "B", "C"])
+    #   ])
+    # @return [QueenCheck::Gen]
+    def self.one_of(ary)
+      elements_of(ary).bind { | gen |
+        gen.instance_of?(QueenCheck::Gen) ? gen : (
+          gen.instance_of?(QueenCheck::Arbitrary) ? 
+            gen.gen : QueenCheck::Arbitrary(gen).gen
+        )
+      }
+    end
+
+    # frequency generater
+    # @param [Array<[weight[Integer], QueenCheck::Gen]>] ary list of pairs weight and generater
+    # @example
+    #   QueenCheck::Gen.frequency([
+    #     [1, QueenCheck::Gen.elements_of(['a', 'b', 'c'])],
+    #     [2, QueenCheck::Gen.elements_of(['1', '2', '3'])]
+    #   ])
+    #   # propability of 1/3 => 'a', 'b' or 'c'
+    #   # propability of 2/3 => '1', '2' or '3'
+    # @return [QueenCheck::Gen]
+    def self.frequency(ary)
+      generaters = []
+      ary.each do | pair |
+        pair[0].times do 
+          generaters << pair[1]
+        end
+      end
+      raise ArgumentsError, "frequency: illigal weight total N > 0" if generaters.empty?
+
+      one_of(generaters)
+    end
+
+    # random generater
+    # @example
+    #   QueenCheck::Gen.rand.resize(-100, 100)
+    # @return [QueenCheck::Gen]
+    def self.rand
+      new { | p, r |
+        r
+      }
+    end
+
+    # unit generater
+    # @param [Object] n any object
+    # @example
+    #   QueenCheck::Gen.unit(1)
+    #   # always generate 1
+    # @return [QueenCheck::Gen]
+    def self.unit(n)
+      new {
+        n
+      }
+    end
+
+    # progress generater
+    # @return [QueenCheck::Gen]
+    def self.progress
+      new { | p, r |
+        p
+      }
+    end
+
+    # step up generater
+    # @param [Array<[weight, Gen]>] ary
+    # @example
+    #   QueenCheck::Gen.step_up([
+    #     [1, QueenCheck::Gen.elements_of(['a', 'b', 'c'])],
+    #     [2, QueenCheck::Gen.elements_of(['A', 'B', 'C'])]
+    #   ])
+    # @return [QueenCheck::Gen]
+    def self.step_up(ary)
+      total = ary.inject(0) { | total, pair | total + pair.first }
+
+      self.progress.bind { |p, r|
+        index = total * p
+
+        gen = nil
+        ary.each do | pair |
+          gen = pair.last 
+          break if index <= pair.first
+          index -= pair.first
+        end
+
+        gen.instance_of?(QueenCheck::Gen) ? gen : (
+          gen.instance_of?(QueenCheck::Arbitrary) ? 
+            gen.gen : QueenCheck::Arbitrary(gen).gen
+        )
+      }
+    end
+
+    # quadratic function (general form) generater
+    # f(x) = ax^2 + bx + c
+    # @param [Integer] a factor a
+    # @param [Integer] b facror b
+    # @param [Integer] c factor c
+    # @return [QueenCheck::Gen]
+    def self.quadratic(a, b = 1, c = 0)
+      new { |p, r|
+        (a * (p ** 2)) + (b * p) + c
+      }
+    end
+  end
+end