queencheck 0.1.2 → 1.0.0

data/lib/queencheck/result.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+require 'colorize'
+
+module QueenCheck
+  class Result
+    def initialize(properties, is_success, exception = nil)
+      @properties = properties
+      @is_success = is_success == true
+      unless exception.nil?
+        @exception = exception
+        @is_success = false
+      end
+    end
+    attr_reader :properties
+
+    def is_success?; @is_success; end
+    def is_failure?; !@is_success; end
+    def is_exception?; !@exception.nil?; end
+  end
+
+  class ResultReport < Array
+    alias :tests :length
+
+    def initialize(*args)
+      super(*args)
+      @labels = {}
+    end
+
+    def pretty_report
+      justify = count(:all).to_s.size
+      label_justify = @labels.keys.map{|label| label.size}.max
+      [
+        "Tests: ".green + count(:all).to_s.colorize(count(:all) == count(:success) ? :green : :red),
+        "  ✓ Successes  : #{count(:success).to_s.rjust(justify)}#{
+          (@labels.empty? ?  '' : "\n") + @labels.keys.map { |label|
+            "    #{label.ljust(label_justify)} : #{count(label, successes).to_s.rjust(justify)}"
+          }.join("\n")
+        }".green,
+        "  ✗ Failures   : #{count(:failures).to_s.rjust(justify)}#{
+          (@labels.empty? ?  '' : "\n") + @labels.keys.map { |label|
+            "    #{label.ljust(label_justify)} : #{count(label, failures).to_s.rjust(justify)}"
+          }.join("\n")
+        }".yellow,
+        "  ✷ Exceptions : #{count(:exception).to_s.rjust(justify)}#{
+          (@labels.empty? ?  '' : "\n") + @labels.keys.map { |label|
+            "    #{label.ljust(label_justify)} : #{count(label, exceptions).to_s.rjust(justify)}"
+          }.join("\n")
+        }".red
+      ].join("\n")
+    end
+
+    def report(with_label = true)
+      [
+        ["tests", count(:all)],
+        ["success", count(:success)],
+        ["failure", count(:failure)],
+        ["exception", count(:exception)]
+      ] + (
+        if with_label
+          report_label
+        else
+          []
+        end
+      )
+    end
+
+    def report_label
+      @labels.keys.map { | label |
+        [label, count(label)]
+      }
+    end
+
+    def count(label = :all, list = self)
+      case label
+      when :all, :tests
+        self.size
+      when :success, :successes
+        self.successes.size
+      when :failure, :failures
+        self.failures.size
+      when :exception, :exceptions
+        self.exceptions.size
+      else
+        raise ArgumentError, "`#{label}` is not valid label" if !@labels.has_key?(label)
+        list.reject {|result|
+          !@labels[label].call(*result.properties)
+        }.size
+      end
+    end
+
+    def labeling(label, &block)
+      @labels[label] = block
+    end
+
+    def successes
+      self.reject{|result| result.is_failure? }
+    end
+
+    def failures
+      self.reject{|result| result.is_success? }
+    end
+
+    def exceptions
+      self.reject{|result| !result.is_exception? }
+    end
+  end
+end

data/lib/queencheck/rspec.rb

@@ -1,11 +1,52 @@
+require 'queencheck'
+require 'rspec'
 
-begin
-  require 'queencheck'
-rescue LoadError
-  require "pathname"
-  $:.unshift Pathname.new(File.expand_path('../../', __FILE__))
-  require 'queencheck'
-end
+module RSpec
+  module Core
+    class ExampleGroup
+      def self.QueenCheck(name, *args, &block)
+        describe(*[name]) {
+          report = nil
 
-require 'rspec'
-require 'queencheck/rspec/dsl'
+          it "running tests" do
+            report = ::QueenCheck::Testable.new(*args, &block).check
+          end
+
+          it "all tests passes" do
+            report.count(:all).should == report.count(:success)
+          end
+        }
+      end
+
+      def self.verboseQueenCheck(name, *args, &block)
+        describe(*[name]) {
+          assert = proc { | *props |
+            proc{ block.call(*props) }
+          }
+          its = proc { | *props |
+            it("Gen: #{props.map{|i| i.inspect}.join(', ')}", &assert.call(*props))
+          }
+          ::QueenCheck::Testable.new(*args, &its).check
+        }
+      end
+
+      def self.labelingQueenCheck(name, labels, *args, &block)
+        checker = ::QueenCheck::Testable.new(*args, &block)
+        report = checker.check_with_label(labels)
+        describe(*[name]) {
+          it "all tests passes" do
+            report.count(:all).should == report.count(:success)
+          end
+
+          describe "labels" do
+            labels.each_pair do | label, p |
+              it label do
+                report.count(label).should == report.count(label, report.successes)
+              end
+            end
+          end
+        }
+      end
+    end
+  end
+end

data/queencheck.gemspec

@@ -5,15 +5,15 @@
 
 Gem::Specification.new do |s|
   s.name = "queencheck"
-  s.version = "0.0.2"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sho Kusano"]
-  s.date = "2012-02-02"
+  s.date = "2012-02-17"
   s.description = "QueenCheck is random test library. Inspired by QuickCheck library in Haskell."
   s.email = "rosylilly@aduca.org"
   s.extra_rdoc_files = [
-    "README.markdown"
+    "README.md"
   ]
   s.files = [
     ".rspec",
@@ -21,40 +21,40 @@ Gem::Specification.new do |s|
     ".travis.yml",
     "Gemfile",
     "Guardfile",
-    "README.markdown",
+    "README.md",
     "Rakefile",
     "VERSION",
     "lib/queencheck.rb",
+    "lib/queencheck/arbitraries/all.rb",
+    "lib/queencheck/arbitraries/boolean.rb",
+    "lib/queencheck/arbitraries/integer.rb",
+    "lib/queencheck/arbitraries/string.rb",
     "lib/queencheck/arbitrary.rb",
-    "lib/queencheck/array.rb",
-    "lib/queencheck/boolean.rb",
-    "lib/queencheck/config.rb",
+    "lib/queencheck/condition.rb",
     "lib/queencheck/core.rb",
-    "lib/queencheck/elements_of.rb",
-    "lib/queencheck/float.rb",
-    "lib/queencheck/integer.rb",
-    "lib/queencheck/string.rb",
+    "lib/queencheck/exception.rb",
+    "lib/queencheck/gen.rb",
+    "lib/queencheck/result.rb",
     "queencheck.gemspec",
     "spec/queencheck/arbitrary_spec.rb",
     "spec/queencheck/core_spec.rb",
-    "spec/queencheck/elements_of_spec.rb",
-    "spec/queencheck/integer_spec.rb",
-    "spec/queencheck/string_spec.rb",
+    "spec/queencheck/gen_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = "https://github.com/rosylilly/QueenCheck"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.10"
+  s.rubygems_version = "1.8.11"
   s.summary = "like haskell's QuickCheck"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<jeweler>, [">= 1.8.3"])
+      s.add_runtime_dependency(%q<colorize>, [">= 0.5.8"])
       s.add_development_dependency(%q<rake>, [">= 0.9.2.2"])
       s.add_development_dependency(%q<rspec>, [">= 2.8.0"])
       s.add_development_dependency(%q<fuubar>, [">= 0.0.6"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.8.3"])
       s.add_development_dependency(%q<growl>, [">= 1.0.3"])
       s.add_development_dependency(%q<spork>, [">= 0.9.0.rc9"])
       s.add_development_dependency(%q<rb-fsevent>, [">= 0.9.0"])
@@ -64,11 +64,14 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<guard-yard>, [">= 1.0.2"])
       s.add_development_dependency(%q<yard>, [">= 0.7.4"])
       s.add_development_dependency(%q<yard-tomdoc>, [">= 0.3.0"])
+      s.add_development_dependency(%q<redcarpet>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
     else
-      s.add_dependency(%q<jeweler>, [">= 1.8.3"])
+      s.add_dependency(%q<colorize>, [">= 0.5.8"])
       s.add_dependency(%q<rake>, [">= 0.9.2.2"])
       s.add_dependency(%q<rspec>, [">= 2.8.0"])
       s.add_dependency(%q<fuubar>, [">= 0.0.6"])
+      s.add_dependency(%q<jeweler>, [">= 1.8.3"])
       s.add_dependency(%q<growl>, [">= 1.0.3"])
       s.add_dependency(%q<spork>, [">= 0.9.0.rc9"])
       s.add_dependency(%q<rb-fsevent>, [">= 0.9.0"])
@@ -78,12 +81,15 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<guard-yard>, [">= 1.0.2"])
       s.add_dependency(%q<yard>, [">= 0.7.4"])
       s.add_dependency(%q<yard-tomdoc>, [">= 0.3.0"])
+      s.add_dependency(%q<redcarpet>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
     end
   else
-    s.add_dependency(%q<jeweler>, [">= 1.8.3"])
+    s.add_dependency(%q<colorize>, [">= 0.5.8"])
     s.add_dependency(%q<rake>, [">= 0.9.2.2"])
     s.add_dependency(%q<rspec>, [">= 2.8.0"])
     s.add_dependency(%q<fuubar>, [">= 0.0.6"])
+    s.add_dependency(%q<jeweler>, [">= 1.8.3"])
     s.add_dependency(%q<growl>, [">= 1.0.3"])
     s.add_dependency(%q<spork>, [">= 0.9.0.rc9"])
     s.add_dependency(%q<rb-fsevent>, [">= 0.9.0"])
@@ -93,6 +99,8 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<guard-yard>, [">= 1.0.2"])
     s.add_dependency(%q<yard>, [">= 0.7.4"])
     s.add_dependency(%q<yard-tomdoc>, [">= 0.3.0"])
+    s.add_dependency(%q<redcarpet>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
   end
 end
 

data/spec/queencheck/arbitrary_spec.rb

@@ -1,42 +1,16 @@
 require 'queencheck/arbitrary'
 
 describe QueenCheck::Arbitrary do
-  class Example
-    extend QueenCheck::Arbitrary
-  end
-
-  it 'arbitrary' do
-    expect {
-      Example.arbitrary(1)
-    }.to raise_error NotImplementedError
-
-    Example.class_eval do
-      def arbitrary(seed)
+  it "define" do
+    class Klass
+      arbitrary do | progress, rnd |
+        rnd
       end
     end
-  end
-
-  describe 'Original Arbitrary' do
-    it 'new' do
-      arb = QueenCheck::Arbitrary() do | seed |
-        if seed < 0.5
-          10**20
-        else
-          ""
-        end
-      end
 
-      arb.arbitrary?.should be_true
-      arb.arbitrary(0).should eq(10**20)
-      arb.arbitrary(1).should eq("")
-    end
-
-    it 'named search' do
-      arb = QueenCheck::Arbitrary(:sample) { (1..10).to_a[rand(10)] }
-
-      QueenCheck::Arbitrary(:sample).should eq(arb)
-      QueenCheck(Kernel, :p, :sample).should_not be_nil
-    end
+    Klass.arbitrary.should be_instance_of(QueenCheck::Arbitrary)
+    Klass.arbitrary?.should == true
+    Class.arbitrary.should be_nil
+    Class.arbitrary?.should == false
   end
 end
-

data/spec/queencheck/core_spec.rb

@@ -1,42 +1,14 @@
 require 'queencheck'
 
-describe QueenCheck do
-  before(:each) do
-    @checker = QueenCheck.new(3, :+, Integer)
-  end
-
-  it 'quick test' do
-    ret = @checker.run do | result, arguments |
-      result.should == 3 + arguments[0]
-    end
-
-    ret.examples.should eq(100)
-    ret.passes.should eq(100)
-    ret.failures.should eq(0)
-  end
-
-  it 'exception' do
-    div = QueenCheck(5, :/, Integer)
-
-    ret = div.run do | result, arguments, error |
-      if error
-        error.should be_kind_of(ZeroDivisionError)
-      else
-        result.should eq(5 / arguments[0])
-      end
-    end
-
-    ret.examples.should eq(100)
-    ret.passes.should eq(100)
-  end
-
-  describe 'Task' do
-    it 'verbose' do
-      task = QueenCheck::Core::Task.new(1, :+, [1])
-
-      task.run! do | result, arguments, error |
-        result != arguments[0]
-      end
-    end
-  end
-end
+prop_int = QueenCheck::Testable.new(
+  QueenCheck::Gen.choose(0, 100),
+  QueenCheck::Gen.choose(0, 100)
+) { | x, y |
+  x + y == y + x
+}
+
+puts prop_int.check_with_label(
+  "x > y" => proc {|x, y| x > y },
+  "x < y" => proc {|x, y| x < y },
+  "x == y" => proc {|x, y| x == y }
+).pretty_report

data/spec/queencheck/gen_spec.rb

@@ -0,0 +1,68 @@
+require 'queencheck/gen'
+
+describe QueenCheck::Gen do
+  it "initialize" do
+    QueenCheck::Gen.new { | progress, rnd |
+      [progress, rnd]
+    }.should be_instance_of(QueenCheck::Gen)
+  end
+
+  it "#choose" do
+    choose = QueenCheck::Gen.choose(0, 100)
+    choose.should be_instance_of(QueenCheck::Gen)
+    10000.times do | n |
+      v = choose.value(n)[0]
+      v.should >= 0
+      v.should <= 100
+    end
+  end
+
+  it "#one_of" do
+    one_of = QueenCheck::Gen.one_of([
+      QueenCheck::Gen.elements_of([1, 2, 3]),
+      QueenCheck::Gen.choose(5, 10)
+    ])
+
+    10000.times do | n |
+      v = one_of.value(n)[0]
+      v.should >= 1
+      v.should <= 10
+      v.should_not == 4
+    end
+  end
+
+  it "#where" do
+    gen = QueenCheck::Gen.choose(0, 10)
+
+    include_gen = gen.where(
+      :include => [0,2,3]
+    ).where(
+      :not_equal => 0
+    )
+    10000.times do | n |
+      v = include_gen.value(n)
+      [2, 3].include?(v[0]).should == v[1]
+    end
+  end
+
+  it "#frequency" do
+    gen = QueenCheck::Gen.frequency([
+      [1, QueenCheck::Gen.elements_of([0])],
+      [3, QueenCheck::Gen.elements_of([1])]
+    ])
+
+    stat = {
+      :a => 0,
+      :b => 0
+    }
+    10000.times do | n |
+      v = gen.value(n)
+      if v[0] == 0
+        stat[:a] += 1
+      else
+        stat[:b] += 1
+      end
+    end
+    stat[:a].should <= stat[:b]
+  end
+end