rantly 0.2.0 → 3.0.0

data/test/rantly_test.rb

@@ -1,284 +1,162 @@
-require 'test/test_helper'
-require 'rantly/property'
+require 'test_helper'
+require 'rantly/minitest_extensions'
 
 module RantlyTest
 end
 
-# check we generate the right kind of data.
-## doesn't check for distribution
-class RantlyTest::Generator < Test::Unit::TestCase
-  def setup
+describe Rantly::Property do
+  before do
     Rantly.gen.reset
   end
-  
-  should "fail test generation" do
-    assert_raises(Rantly::TooManyTries) {
-      property_of { guard range(0,1) < 0 }.check
-    }
-  end
-
-  should "generate literal value by returning itself" do
-    property_of {
-      i = integer
-      [i,literal(i)]
-    }.check { |(a,b)|
-      assert_equal a, b
-    }
-  end
-
-  should "generate integer in range" do
-    property_of {
-      i = integer
-      [i,range(i,i)]
-    }.check { |(a,b)|
-      assert_equal a, b
-    }
-    property_of {
-      lo, hi = [integer(100),integer(100)].sort
-      [lo,hi,range(lo,hi)]
-    }.check { |(lo,hi,int)|
-      assert((lo..hi).include?(int)) 
-    }
-  end
-
-  should "generate Fixnum only" do
-    property_of  { integer }.check { |i| assert i.is_a?(Integer) }
-  end
-
-  should "generate integer less than abs(n)" do
-    property_of {
-      n = range(0,10)
-      [n,integer(n)]
-    }.check {|(n,i)|
-      assert n.abs >= i.abs
-    }
-  end
-
-  should "generate Float" do
-    property_of { float }.check { |f| assert f.is_a?(Float)}
-  end
-
-  should "generate Boolean" do
-    property_of { boolean }.check { |t|
-      assert t == true || t == false
-    }
-  end
-
-  should "generate empty strings" do
-    property_of {
-      sized(0) { string }
-    }.check { |s|
-      assert s.empty?
-    }
-  end
-
-  should "generate strings with the right regexp char classes" do
-    char_classes = Rantly::Chars::CLASSES.keys
-    property_of {
-      char_class = choose(*char_classes)
-      len = range(0,10)
-      sized(len) { [len,char_class,string(char_class)]}
-    }.check { |(len,char_class,str)|
-      t = true
-      chars = Rantly::Chars::CLASSES[char_class]
-      str.each_byte { |c|
-        unless chars.include?(c)
-          t = false
-          break
-        end
-      }
-      assert_equal len, str.length
-      assert t
-    }
-  end
 
-  should "generate strings matching regexp" do
-    property_of {
-      sized(10) { string(/[abcd]/) }
-    }.check { |s|
-      assert s =~ /[abcd]+/
-    }
+  it 'fail test generation' do
+    print "\n### TESTING A FAILING CASE, do not get scared"
+    assert_raises(Rantly::TooManyTries) do
+      property_of { guard range(0, 1).negative? }.check
+    end
   end
 
   # call
 
-  should "call Symbol as method call (no arg)" do
-    property_of {call(:integer)}.check { |i| i.is_a?(Integer)}
+  it 'call Symbol as method call (no arg)' do
+    property_of { call(:integer) }.check { |i| i.is_a?(Integer) }
   end
 
-  should "call Symbol as method call (with arg)" do
-    property_of {
-      n = range(0,100)
-      [n,call(:integer,n)]
-    }.check { |(n,i)|
+  it 'call Symbol as method call (with arg)' do
+    property_of do
+      n = range(0, 100)
+      [n, call(:integer, n)]
+    end.check do |(n, i)|
       assert n.abs >= i.abs
-    }
+    end
   end
 
-  should "call Array by calling first element as method, the rest as args" do
-    assert_raise(RuntimeError) {
-      Rantly.gen.value {
+  it 'call Array by calling first element as method, the rest as args' do
+    assert_raises(RuntimeError) do
+      Rantly.gen.value do
         call []
-      }
-    }
-    property_of {
+      end
+    end
+    property_of do
       i = integer
-      [i,call(choose([:literal,i],[:range,i,i]))]
-    }.check { |(a,b)|
+      [i, call(choose([:literal, i], [:range, i, i]))]
+    end.check do |(a, b)|
       assert_equal a, b
-    }
+    end
   end
-  
-  should "call Proc with generator.instance_eval" do
-    property_of {
-      call Proc.new { true }
-    }.check { |o|
+
+  it 'call Proc with generator.instance_eval' do
+    property_of do
+      call proc { true }
+    end.check do |o|
       assert_equal true, o
-    }
-    property_of {
-      i0 = range(0,100)
-      i1,s = call Proc.new {
-        range(i0+1,i0+100)
+    end
+    property_of do
+      i0 = range(0, 100)
+      i1 = call proc {
+        range(i0 + 1, i0 + 100)
       }
-      [i0,i1]
-    }.check { |(i0,i1)|
-      assert i0.is_a?(Fixnum) && i1.is_a?(Fixnum)
-      assert i0 != i1
+      [i0, i1]
+    end.check do |(i0, i1)|
+      assert i0.is_a?(Integer) && i1.is_a?(Integer)
       assert i1 > i0
-    }
+      assert i1 <= (i0 + 100)
+    end
   end
-  
-  should "raise if calling on any other value" do
-    assert_raise(RuntimeError) {
+
+  it 'raise if calling on any other value' do
+    assert_raises(RuntimeError) do
       Rantly.gen.call 0
-    }
+    end
   end
 
   # branch
 
-  should "branch by Rantly#calling one of the args" do
-    property_of {
+  it 'branch by Rantly#calling one of the args' do
+    property_of do
       branch :integer, :integer, :integer
-    }.check { |o|
-      assert o.is_a?(Fixnum)
-    }
-    property_of {
+    end.check do |o|
+      assert o.is_a?(Integer)
+    end
+    property_of do
       sized(10) { branch :integer, :string }
-    }.check { |o|
-      assert o.is_a?(Fixnum) || o.is_a?(String)
-    }
+    end.check do |o|
+      assert o.is_a?(Integer) || o.is_a?(String)
+    end
   end
 
-  
   # choose
-  
-  should "choose a value from args " do
-    property_of {
+
+  it 'choose a value from args ' do
+    property_of do
       choose
-    }.check {|o|
+    end.check do |o|
       assert_nil o
-    }
-    property_of {
+    end
+    property_of do
       choose 1
-    }.check { |o|
+    end.check do |o|
       assert_equal 1, o
-    }
-    property_of {
-      choose 1,2
-    }.check { |o|
-      assert o == 1 || o == 2
-    }
-    property_of {
-      arr = sized(10) { array(:integer) }
-      choose(*arr) 
-    }.check { |o|
-      assert o.is_a?(Fixnum)
-    }
-    property_of {
+    end
+    property_of do
+      choose 1, 2
+    end.check do |o|
+      assert [1, 2].include? o
+    end
+    property_of do
+      arr = sized(10) { array { integer } }
+      choose(*arr)
+    end.check do |o|
+      assert o.is_a?(Integer)
+    end
+    property_of do
       # array of array of ints
-      arr = sized(10) { array(Proc.new { array(:integer)})}
+      arr = sized(10) { array { array { integer } } }
       # choose an array from an array of arrays of ints
       choose(*arr)
-    }.check { |arr|
+    end.check do |arr|
       assert arr.is_a?(Array)
-      assert arr.all? { |o| o.is_a?(Fixnum)}
-    }
+      assert arr.all? { |o| o.is_a?(Integer) }
+    end
   end
 
   # freq
 
-  should "not pick an element with 0 frequency" do
-    property_of {
-      sized(10) {
-        array Proc.new { freq([0,:string],[1,:integer]) }
-      }
-    }.check { |arr|
-      assert arr.all? { |o| o.is_a?(Integer)}
-    }
+  it 'not pick an element with 0 frequency' do
+    property_of do
+      sized(10) do
+        array { freq([0, :string], [1, :integer]) }
+      end
+    end.check do |arr|
+      assert arr.all? { |o| o.is_a?(Integer) }
+    end
   end
 
-  should "handle degenerate freq pairs" do
-    assert_raise(RuntimeError) {
-      Rantly.gen.value {
+  it 'handle degenerate freq pairs' do
+    assert_raises(RuntimeError) do
+      Rantly.gen.value do
         freq
-      }
-    }
-    property_of {
+      end
+    end
+    property_of do
       i = integer
-      [i,freq([:literal,i])]
-    }.check { |(a,b)|
+      [i, freq([:literal, i])]
+    end.check do |(a, b)|
       assert_equal a, b
-    }
+    end
   end
+end
 
-  # array
+# TODO: Determine type of tests required here.
 
-  should "generate empty array" do
-    property_of {
-      sized(0) { array(:integer)}
-    }.check { |o|
-      assert o.empty?
-    }
-  end
-  
-  should "generate the right sized nested arrays" do
-    property_of {
-      size1 = range(5,10)
-      size2 = range(0,size1-1)
-      array = sized(size1) { array(Proc.new { sized(size2) { array(:integer)}})}
-      [size1,array]
-    }.check { |(size1,outter_array)|
-      assert_equal size1, outter_array.size
-      assert outter_array.all? { |inner_array| inner_array.size < size1 }
-    }
-  end
-  
-  should "generate array with right types" do
-    property_of {
-      sized(10) { array :integer,:string,:float }
-    }.check { |arr|
-      assert arr.all? { |o|
-        case o
-        when Fixnum, Float, String
-          true
-        else
-          false
-        end
-      }
-    }
+# check we generate the right kind of data.
+## doesn't check for distribution
+class RantlyTest::Generator < Minitest::Test
+  def setup
+    Rantly.gen.reset
   end
-
-  # should "raise if generating an array without size" do
-#     assert_raise(RuntimeError) {
-#       Rantly.gen.value { array(:integer) }
-#     }
-#   end
-
 end
-  
-
 
 # TODO: check that distributions of different methods look roughly correct.
-class RantlyTest::Distribution
-  
+class RantlyTest::Distribution < Minitest::Test
 end

data/test/shrinks_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+require 'rantly/shrinks'
+require 'rantly/minitest_extensions'
+
+module RantlyTest
+end
+
+module RantlyTest::Shrinkers
+end
+
+describe Integer do
+  it 'not be able to shrink 0 integer' do
+    assert !0.shrinkable?
+  end
+
+  it 'shrink positive integers to something less than itself' do
+    assert(3.shrink < 3)
+    assert(2.shrink < 2)
+    assert_equal(0, 1.shrink)
+  end
+
+  it 'shrink negative integers to something larger than itself' do
+    assert(-3.shrink > -3)
+    assert(-2.shrink > -2)
+    assert_equal(0, -1.shrink)
+  end
+
+  it 'shrink 0 to itself' do
+    # hmm. should this be undefined?
+    assert_equal 0.shrink, 0
+  end
+end
+
+describe String do
+  it 'not be able to shrink empty string' do
+    assert !''.shrinkable?
+  end
+
+  it 'shrink a string one char shorter' do
+    property_of do
+      sized(10) { string }
+    end.check do |str|
+      assert_equal 9, str.shrink.length
+    end
+  end
+end
+
+describe Tuple do
+  it 'not be able to shrink empty tuple' do
+    assert !Tuple.new([]).shrinkable?
+  end
+
+  it 'shrink tuple by trying to shrink the last shrinkable element available' do
+    assert_equal [1, 0], Tuple.new([1, 1]).shrink.array
+    assert_equal [1, 0, 0], Tuple.new([1, 1, 0]).shrink.array
+  end
+
+  it 'do not remove element from array when no element is shrinkable' do
+    property_of do
+      n = integer(1..10)
+      a = Tuple.new(Array.new(n, 0))
+      [n, a]
+    end.check do |n, a|
+      assert_equal n, a.shrink.length
+    end
+  end
+end
+
+describe Hash do
+  it 'not be able to shrink empty hash' do
+    assert !{}.shrinkable?
+  end
+
+  it 'shrink a value if one of the values is shrinkable' do
+    assert_equal({ foo: 0, bar: 0 }, { foo: 1, bar: 0 }.shrink)
+    assert_equal({ foo: 0, bar: 0 }, { foo: 0, bar: 1 }.shrink)
+  end
+
+  it 'shrink by deleting an element in it if none of the values is shrinkable' do
+    assert_equal({}, { foo: 0 }.shrink)
+  end
+end
+
+describe 'Shrinker Test' do
+  it 'shrink data to smallest value that fails assertion' do
+    print "\n### TESTING A FAILING CASE, do not get scared"
+    # We try to generate an array of 10 elements, filled with ones.
+    # The property we try to test is that non of the element is
+    # larger than 1, and the array's length is less than 4.
+    test = property_of do
+      a = Deflating.new(Array.new(10, 1))
+      i = Random.rand(a.length)
+      a[i] = 1
+      a
+    end
+    assert_raises MiniTest::Assertion do
+      test.check do |a|
+        assert(a.array.none?(&:positive?) && a.length < 4, 'contains 1')
+      end
+    end
+
+    assert_equal [1], test.shrunk_failed_data.array
+  end
+end

data/test/test_helper.rb

@@ -1,11 +1,15 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
+# Require simplecov and coveralls before rantly application code.
+require 'simplecov'
+SimpleCov.start
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+begin
+  # Coveralls is marked as an _optional_ dependency, so don't
+  # throw a fit if it's not there.
+  require 'coveralls'
+  Coveralls.wear!
+rescue LoadError
+end
 
+# Require rantly.
+require 'minitest/autorun'
 require 'rantly'
-
-class Test::Unit::TestCase
-end

metadata

@@ -1,71 +1,76 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rantly
-version: !ruby/object:Gem::Version 
-  version: 0.2.0
+version: !ruby/object:Gem::Version
+  version: 3.0.0
 platform: ruby
-authors: 
+authors:
+- Ana María Martínez Gómez
 - Howard Yeh
-autorequire: 
+- Anthony Bargnesi
+- Eric Bischoff
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2010-01-04 00:00:00 -08:00
-default_executable: 
+date: 2024-10-21 00:00:00.000000000 Z
 dependencies: []
-
-description: 
-email: hayeah@gmail.com
+description:
+email:
+- anamma06@gmail.com
+- hayeah@gmail.com
+- abargnesi@gmail.com
+- ebischoff@nerim.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
-- README.textile
-files: 
-- .document
-- .gitignore
+- README.md
+- CHANGELOG.md
+files:
+- ".document"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
 - LICENSE
-- README.textile
+- README.md
 - Rakefile
 - VERSION.yml
 - lib/rantly.rb
 - lib/rantly/data.rb
 - lib/rantly/generator.rb
+- lib/rantly/minitest.rb
+- lib/rantly/minitest_extensions.rb
 - lib/rantly/property.rb
+- lib/rantly/rspec.rb
+- lib/rantly/rspec_extensions.rb
+- lib/rantly/shrinks.rb
 - lib/rantly/silly.rb
 - lib/rantly/spec.rb
+- lib/rantly/testunit_extensions.rb
 - rantly.gemspec
 - test/rantly_test.rb
+- test/shrinks_test.rb
 - test/test_helper.rb
-has_rdoc: true
-homepage: http://github.com/hayeah/rantly
-licenses: []
-
-post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+homepage: https://github.com/rantly-rb/rantly
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.5
-signing_key: 
-specification_version: 3
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
 summary: Ruby Imperative Random Data Generator and Quickcheck
-test_files: 
-- test/rantly_test.rb
-- test/test_helper.rb
+test_files: []

data/.gitignore

@@ -1,5 +0,0 @@
-*.sw?
-.DS_Store
-coverage
-rdoc
-pkg