stig 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 537946887fe8b354b53d3d239b4910b9bcf9064c
+  data.tar.gz: 9039195f3278ccdd1a8616899e4faf9851704234
+SHA512:
+  metadata.gz: ec59581cf608be129b4b87f33d2bba035316c06a95c32f7f97569ffa145a8bf1e1bc1393e1091780f4a7e52fa7ae697cfb09610a0ee250d209b81e0829569790
+  data.tar.gz: 8f96bb1d14955d99a06f3b95a91c36170e65ec05236629962249425757d3a3c934cdfca9c46a84ec4d4533f95c23d85a86e3164bcd4cabb29410563c19fe72ce

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+vLg���>}�J������R��
=�yP!t����:L���;����Ԣ��)ۻDPS`��/!����{�a[{��%�m1|䕿��:���kh���(y���G �$&kd���D
+/<!f~�c�(��4���L��H/F�s�E#tGJw�(�^�9e��B��r�ox�k�!H'E᳇��Fuc�2I��PN�w⮙��h'8�$����@�o�EҤk�ॗ�a,*N�6�k��ڡ����thX_�����0�e��<

data.tar.gz.sig

@@ -0,0 +1 @@
+RKh':�R�R�t��w�����'|_`t>f����|Y��Λk�Bz.��}��]9a�����`\�/�D{�D;�H���*O�� ����dC�6=��s��b���f�ܯjtE�qh[n���n�>����\9`"{�AN�n�<����AlE2d>�K,��VK&2����D�.4�,�p��[�a�Ui��e9���B9��N�²�'g�Db�o��t���*%�?O�(CF��˴�{���;�Z+n/V�E�iA|�8N�

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Jip van Reijsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# stig
+
+Simple test input generation.
+
+## What is it
+
+Stig is a small library for property based testing in Ruby. It runs a test
+multiple times (100 by default) with randomly generated input. Stig is test
+framework agnostic, so can be used with any test framework.
+
+## Usage
+
+An example using [cutest][cutest]. `test` and `assert_raise` come from cutest.
+
+```ruby
+require "stig"
+
+test "doesn't parse random input" do
+  Stig.property(String) do |string|
+    assert_raise { Library.parse(string) }
+  end
+end
+```
+
+`Stig.property` takes one or more generators and a predicate block. A generator
+is an object implementing `#call` or `#random`. A predicate block is a block
+that returns `true` for passed tests and `false` for failed test.
+
+**Note**: In the above example `String` is used as generator. Stig doesn't
+monkey-patch any classes. Refinements are used instead.
+
+Stig ships with a few built in generators, such as `Date`, `Integer` and 
+`String`. They can be found under the `Stig::Generators` namespace. It's easy to
+write your own generators using `Stig.generator` and `Stig.generator_for`.
+
+An example of creating a custom generator using `Stig.generator`.
+
+```ruby
+Person = Struct.new(:name, :age)
+
+person_generator = generator do
+  Person.new Generators::String.random, Generators::Integer.random(99)
+end
+
+person_generator.call
+# => #<struct Person name="M#uVfd7\tx\x1Eri]\x1F\x7F", age=95>
+```
+
+An example of creating a custom generator using `Stig.generator_for`.
+
+```ruby
+Person = Struct.new(:name, :age) do
+  def self.random
+    new Generators::String.random, Generators::Integer.random(99)
+  end
+end
+
+person_generator = generator_for(Person)
+
+person_generator.call
+# => #<struct Person name="-\x069|\x0F\x03Llq", age=6>
+```
+
+To configure the number of tests stig should run set the environment variable 
+`STIG_NUMBER_OF_RUNS` to the desired number of test runs.
+
+[cutest]: https://github.com/djanowski/cutest
+
+## Installation
+
+`gem install stig`
+
+Stig requires Ruby 2.0.0 or higher.
+
+## License
+
+See the LICENSE file.

data/lib/stig.rb

@@ -0,0 +1,134 @@
+require "stig/refinements"
+
+using Stig::Refinements
+
+module Stig
+  # Public: Number of tests that should be run.
+  NUMBER_OF_RUNS = (ENV["STIG_NUMBER_OF_RUNS"] || 100).to_i
+  
+  # Public: Raised when a test failed.
+  class AssertionFailed < StandardError; end
+
+  module_function
+
+  # Public: Tests a property with randomly generated input. The input comes from
+  # Generators, which are passed as arguments. The property is described in the 
+  # block. A test has failed when the block returns a falsy value (false or 
+  # nil).
+  #
+  # types - An object implementing #call or #random.
+  # block - A block that describes the property.
+  #
+  # Examples
+  # 
+  #   property(String, String) do |a,b|
+  #     assert (a + b).start_with?(a)
+  #   end
+  #   
+  #   property(-> { rand(10) }) do |a|
+  #     assert a.between?(0, 10)
+  #   end
+  #
+  # Returns true.
+  # Raises ArgumentError when an invalid generator was supplied.
+  # Raises ArgumentError when no generators were supplied.
+  # Raises ArgumentError when a generator generates too few values.
+  # Raises ArgumentError when no block was supplied.
+  # Raises Stig::AssertionFailed when a test failed.
+  def property(*types, &block)
+    offenders = types.reject do |type|
+      type.respond_to?(:call) || type.respond_to?(:random)
+    end
+
+    unless offenders.empty?
+      msg = "no #call or #random implemented for #{offenders.join ", "}"
+      raise ArgumentError, msg
+    end
+
+    unless block_given?
+      raise ArgumentError, "a block is required"
+    end
+
+    if types.empty?
+      raise ArgumentError, "no generators given, consider a unit test"
+    end
+
+    methods = types.map do |type|
+      type.respond_to?(:call) ? :call : :random
+    end
+
+    types_and_method = types.zip(methods)
+
+    1.upto(NUMBER_OF_RUNS) do |i|
+      input = types_and_method.map { |type, method| type.send(method) }
+
+      result = yield(*input)
+
+      unless result
+        parameters = block.parameters.map(&:last).first(input.size)
+        formatted  = parameters.zip(input).map do |a,v|
+          "- #{a} => #{v.inspect} (#{v.class})"
+        end
+
+        message = "Failed after #{i} test(s) with input\n" \
+        "#{formatted.join "\n"}"
+
+        raise AssertionFailed, message
+      end
+    end
+
+    return true
+  rescue StopIteration
+    offender = types
+      .select { |type| type.respond_to?(:peek) }
+      .find { |gen| gen.peek && false rescue true }
+
+    raise ArgumentError, "#{offender} generates too few values"
+  end
+
+  # Public: Creates a generator from a block.
+  #
+  # args  - Any arguments that should be passed to the block.
+  # block - A block returning a random value.
+  #
+  # Examples
+  #
+  #   float_generator = Stig.generator do
+  #     rand
+  #   end
+  #
+  #   number_generator = Stig.generator(1, 100) do |min, max
+  #     rand(min..max)
+  #   end
+  #
+  # Returns a Proc.
+  # Raises ArgumentError if no block was passed.
+  def generator(*args, &block)
+    unless block_given?
+      raise ArgumentError, "no block given"
+    end
+
+    args.empty? ? block : proc { yield(*args) }
+  end
+
+  # Public: Creates a generator from an object. The object should respond to
+  # #random.
+  #
+  # object - An object implementing #random.
+  # args   - Any arguments that should be passed to object#random.
+  #
+  # Examples
+  #
+  #   # Assuming Integer.random is implemented and takes two arguments.
+  #   integer_generator = generator_for(Integer, 1, 10)
+  #
+  # Returns a Proc.
+  # Raises ArgumentError if `object` does not respond to #random.
+  def generator_for(object, *args)
+    unless object.respond_to?(:random)
+      raise ArgumentError, "no #random implemented for #{object}"
+    end
+
+    generator(*args, &object.method(:random))
+  end
+end

data/lib/stig/generators.rb

@@ -0,0 +1,8 @@
+require "stig/generators/array"
+require "stig/generators/character"
+require "stig/generators/date"
+require "stig/generators/float"
+require "stig/generators/integer"
+require "stig/generators/string"
+require "stig/generators/symbol"
+require "stig/generators/time"

data/lib/stig/generators/array.rb

@@ -0,0 +1,31 @@
+module Stig
+  module Generators
+    module Array
+      # Public: Generates an random Array. Elements are generated by a 
+      # generator. Size is variable, use a Range with equal start and end for a
+      # fixed size.
+      #
+      # generator - An object implementing #call or #random.
+      # size      - A maximum size Integer or Range (default: 1..10).
+      #
+      # Returns an Array.
+      # Raises ArgumentError when an invalid generator was supplied.
+      def self.random(generator, size = 1..10)
+        unless generator.respond_to?(:call) || generator.respond_to?(:random)
+          msg = "no #call or #random implemented for #{generator}"
+          raise ArgumentError, msg
+        end
+
+        method = generator.respond_to?(:call) ? :call : :random
+
+        array = []
+
+        rand(size).times do
+          array << generator.send(method)
+        end
+
+        array
+      end
+    end
+  end
+end

data/lib/stig/generators/character.rb

@@ -0,0 +1,22 @@
+module Stig
+  module Generators
+    module Character
+      ASCII     = 0.upto(127).map(&:chr)
+      PRINTABLE = 32.upto(126).map(&:chr)
+      DIGITS    = 48.upto(57).map(&:chr)
+      UPPERCASE = 65.upto(90).map(&:chr)
+      LOWERCASE = 97.upto(122).map(&:chr)
+      ALPHABET  = UPPERCASE + LOWERCASE
+
+      # Public: Generates a random character.
+      #
+      # set - An Array of one character Strings.
+      #
+      # Returns a 1 character String.
+      # Raises ArgumentError when `set` is empty.
+      def self.random(set = ASCII)
+        set = set.sample || raise(ArgumentError, "character set is empty")
+      end
+    end
+  end
+end

data/lib/stig/generators/date.rb

@@ -0,0 +1,20 @@
+require "date"
+
+module Stig
+  module Generators
+    module Date
+      extend self
+
+      DEFAULT_INTERVAL = ::Date.new..::Date.today
+
+      # Public: Generates a random Date.
+      #
+      # range - An interval Range (default: Date.new..Date.today).
+      #
+      # Returns a Date.
+      def random(range = DEFAULT_INTERVAL)
+        rand(range)
+      end
+    end
+  end
+end

data/lib/stig/generators/float.rb

@@ -0,0 +1,16 @@
+module Stig
+  module Generators
+    module Float
+      extend self
+      
+      # Public: Generates a random Float.
+      #
+      # max - A maximum Float or Range (default 0.0..1.0).
+      #
+      # Returns a Float.
+      def random(max = 0.0..1.0)
+        rand(max)
+      end
+    end
+  end
+end

data/lib/stig/generators/hash.rb

@@ -0,0 +1,33 @@
+module Stig
+  module Generators
+    module Hash
+      extend self
+
+      # Public: Generates a random Hash. If no keys are passed, a Hash with a
+      # default proc is returned.
+      #
+      # generator - An object implementing #call or #random.
+      # keys      - Objects to use as Hash keys.
+      #
+      # Returns a Hash.
+      # Raises ArgumentError when an invalid generator was supplied.
+      def random(generator, *keys)
+        unless generator.respond_to?(:call) || generator.respond_to?(:random)
+          msg = "no #call or #random implemented for #{generator}"
+          raise ArgumentError, msg
+        end
+
+        method = generator.respond_to?(:call) ? :call : :random
+
+        if keys.empty?
+          hash = ::Hash.new { |hash, key| hash[key] = generator.send(method) }
+        else
+          hash = {}
+          keys.each { |key| hash[key] = generator.send(method) }
+        end
+
+        hash
+      end
+    end
+  end
+end

data/lib/stig/generators/integer.rb

@@ -0,0 +1,16 @@
+module Stig
+  module Generators
+    module Integer
+      extend self
+
+      # Public: Generates a random Integer.
+      #
+      # max - A maximum Integer or Range (default: 100).
+      #
+      # Returns an Integer.
+      def random(max = 100)
+        rand(max)
+      end
+    end
+  end
+end

data/lib/stig/generators/string.rb

@@ -0,0 +1,28 @@
+require "stig/generators/character"
+
+module Stig
+  module Generators
+    module String
+      extend self
+
+      # Public: Generates a random String. Characters are picked from a 
+      # character set (`set`). Size is variable, use a Range with equal start
+      # and end for a fixed size.
+      #
+      # set  - An Array of one character Strings (default: ASCII).
+      # size - A maximum length Integer or Range (default: 25).
+      #
+      # Returns a String.
+      def random(set = Character::ASCII, size = 25)
+        result = ""
+        
+        rand(size).times do
+          char = set.sample || raise(ArgumentError, "character set is empty")
+          result << char
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/stig/generators/symbol.rb

@@ -0,0 +1,15 @@
+module Stig
+  module Generators
+    module Symbol
+      extend self
+
+      # Public: Generates a random Symbol. See Stig::Generators::String for 
+      # usage
+      #
+      # Returns a Symbol.
+      def random(*args)
+        Generators::String.random(*args).to_sym
+      end
+    end
+  end
+end

data/lib/stig/generators/time.rb

@@ -0,0 +1,18 @@
+module Stig
+  module Generators
+    module Time
+      extend self
+
+      DEFAULT_INTERVAL = ::Time.at(0)..::Time.now
+
+      # Public: Generates a random Time.
+      #
+      # interval - An interval Range (default: Time.at(0)..Time.now).
+      #
+      # Returns a Time.
+      def random(interval = DEFAULT_INTERVAL)
+        rand(interval)
+      end
+    end
+  end
+end

data/lib/stig/refinements.rb

@@ -0,0 +1,115 @@
+require "stig/generators/date"
+require "stig/generators/float"
+require "stig/generators/integer"
+require "stig/generators/string"
+require "stig/generators/symbol"
+require "stig/generators/time"
+
+module Stig
+  # Public: Refinements for the core classes Array, Float, Integer and String.
+  module Refinements
+    # A note on refinements.
+    #
+    # There are a few issues with refinements:
+    #
+    # 1. Refined class methods are ignored. Calling them results in a 
+    #    NoMethodError.
+    # 2. #respond_to? ignores refined methods. It returns `false` for methods
+    #    that have been refined.
+    # 3. #send ignores refined methods. It raises a NoMethodError when trying
+    #    to invoke a refined method.
+    #
+    # Issues 2 and 3 aren't bugs, see: http://goo.gl/335ndw.
+    #
+    # Stig uses the following workarounds:
+    #
+    # 1. To refine class method, the singleton class is refined.
+    # 2. #respond_to? is refined. It checks for existing methods manually. The 
+    #    module Fix is included in the refinement.
+    # 3. #send is refined. Unfortunately, this cannot be done by including a 
+    #    module in the refinement. #send needs to be defined directly in the 
+    #    refinement or it will be ignored. It also requires any method it calls
+    #    to be defined directly in the refinement.
+    # 
+    # It's a pity.
+
+    # Internal: Fixes #respond_to? for refined classes.
+    module Fix
+      def respond_to?(method, *args)
+        method == :random ? true : super
+      end
+    end
+
+    refine Date.singleton_class do
+      include Fix
+
+      def random(*args, &block)
+        Generators::Date.random(*args, &block)
+      end
+
+      def send(method, *args, &block)
+        method == :random ? random(*args, &block) : super
+      end
+    end
+
+    refine Float.singleton_class do
+      include Fix
+
+      def random(*args, &block)
+        Generators::Float.random(*args, &block)
+      end
+
+      def send(method, *args, &block)
+        method == :random ? random(*args, &block) : super
+      end
+    end
+
+    refine Integer.singleton_class do
+      include Fix
+
+      def random(*args, &block)
+        Generators::Integer.random(*args, &block)
+      end
+
+      def send(method, *args, &block)
+        method == :random ? random(*args, &block) : super
+      end
+    end
+
+    refine String.singleton_class do
+      include Fix
+
+      def random(*args, &block)
+        Generators::String.random(*args, &block)
+      end
+
+      def send(method, *args, &block)
+        method == :random ? random(*args, &block) : super
+      end
+    end
+
+    refine Symbol.singleton_class do
+      include Fix
+
+      def random(*args, &block)
+        Generators::Symbol.random(*args, &block)
+      end
+
+      def send(method, *args, &block)
+        method == :random ? random(*args, &block) : super
+      end
+    end
+
+    refine Time.singleton_class do
+      include Fix
+
+      def random(*args, &block)
+        Generators::Time.random(*args, &block)
+      end
+
+      def send(method, *args, &block)
+        method == :random ? random(*args, &block) : super
+      end
+    end
+  end
+end

data/lib/stig/version.rb

@@ -0,0 +1,3 @@
+module Stig
+  VERSION = "0.1.0"
+end

data/stig.gemspec

@@ -0,0 +1,18 @@
+require_relative "lib/stig/version"
+
+Gem::Specification.new do |s|
+  s.name        = "stig"
+  s.version     = Stig::VERSION
+  s.summary     = "simple test input generation"
+  s.description = "Stig is a small library for property based testing in Ruby."
+  s.author      = "Jip van Reijsen"
+  s.email       = "jipvanreijsen@gmail.com"
+  s.homepage    = "https://github.com/britishtea/stig"
+  s.license     = "MIT"
+
+  s.files                 = `git ls-files`.split("\n")
+  s.extra_rdoc_files      = ["README.md"]
+  s.required_ruby_version = '>= 2.0'
+  
+  s.add_development_dependency "cutest", "~> 1.2"
+end

data/test/README.md

@@ -0,0 +1,7 @@
+# Testing 
+
+[Cutest](cutest) is used for testing.
+
+Running the tests is simple: `cutest test/*/*.rb`.
+
+[cutest]: https://github.com/djanowski/cutest

data/test/stig/array_generator.rb

@@ -0,0 +1,55 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/array"
+
+include Stig
+
+setup { Stig::Generators::Array }
+
+test "takes a generator" do |mod|
+  elements  = generator { 1 }
+  generator = generator_for(mod, elements)
+
+  property(generator) do |array|
+    assert_equal array.uniq, [1]
+
+    true
+  end
+end
+
+test "doesn't take an invalid generator" do |mod|
+  assert_raise(ArgumentError) { mod.random("invalid") }
+end
+
+test "defaults to Arrays with length between 1 and 10" do |mod|
+  elements  = generator { 1 }
+  generator = generator_for(mod, elements)
+
+  property(generator) do |array|
+    assert array.size.between?(1, 10)
+
+    true
+  end
+end
+
+test "takes a maximum size" do |mod|
+  elements  = generator { 1 }
+  generator = generator_for(mod, elements, 5)
+
+  property(generator) do |array|
+    assert array.size.between?(0, 5)
+
+    true
+  end
+end
+
+test "takes a range" do |mod|
+  elements  = generator { 1 }
+  generator = generator_for(mod, elements, 1..5)
+
+  property(generator) do |array|
+    assert array.size.between?(1, 5)
+
+    true
+  end
+end

data/test/stig/character_generator.rb

@@ -0,0 +1,41 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/string"
+
+include Stig
+
+setup { Stig::Generators::Character }
+
+test "defaults to all ASCII characters" do |mod|
+  property(mod) do |character|
+    assert_equal character.class, String
+
+    true
+  end
+
+  property(mod) do |character|
+    assert_equal character.size, 1
+
+    true
+  end
+
+  property(mod) do |character|
+    assert 0.upto(127).map(&:chr).include?(character)
+
+    true
+  end
+end
+
+test "takes a character set" do |mod|
+  generator = generator_for(mod, ["a"])
+
+  property(generator) do |character|
+    assert_equal character, "a"
+
+    true
+  end
+end
+
+test "doesn't take an empty character set" do |mod|
+  assert_raise(ArgumentError) { mod.random([]) }
+end

data/test/stig/date_generator.rb

@@ -0,0 +1,36 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/date"
+
+include Stig
+
+setup { Stig::Generators::Date }
+
+test "generates Dates" do |mod|
+  property(mod) do |date|
+    assert_equal date.class, Date
+
+    true
+  end
+end
+
+test "defaults between January 1, 4713 BCE and Date.today" do |mod|
+  range = Date.new..Date.today
+
+  property(mod) do |date|
+    assert range.cover?(date)
+
+    true
+  end
+end
+
+test "takes a Date Range" do |mod|
+  range     = Date.new(0)..Date.new(5)
+  generator = generator_for(mod, range)
+
+  property(generator) do |date|
+    assert range.cover?(date)
+
+    true
+  end
+end

data/test/stig/float_generator.rb

@@ -0,0 +1,35 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/float"
+
+include Stig
+
+setup { Stig::Generators::Float }
+
+test "takes a maximum value" do |mod|
+  generator = generator_for(mod, 10.0)
+
+  property(generator) do |integer|
+    assert integer.between?(0.0, 10.0)
+
+    true
+  end
+end
+
+test "takes a range" do |mod|
+  generator = generator_for(mod, 5.0..10.0)
+
+  property(generator) do |integer|
+    assert integer.between?(5.0, 10.0)
+
+    true
+  end
+end
+
+test "defaults to Floats between 0.0 and 1.0" do |mod|
+  property(mod) do |integer|
+    assert integer.between?(0.0, 1.0)
+
+    true
+  end
+end

data/test/stig/generator.rb

@@ -0,0 +1,48 @@
+require_relative "../test_helper"
+require "stig"
+
+setup { Stig }
+
+prepare { $test = nil }
+
+test "without a block" do |stig|
+  assert_raise(ArgumentError) { stig.generator }
+end
+
+test "with a block" do |stig|
+  generator = stig.generator { 1 }
+
+  assert_equal generator.class, Proc
+  assert_equal generator.call, 1
+end
+
+test "with a block taking arguments" do |stig|
+  arguments = [:a, :b, :c]
+  generator = stig.generator(*arguments) { |*args| args }
+
+  assert_equal generator.call, arguments
+end
+
+test "with an object without a #random" do |stig|
+  assert_raise(ArgumentError) { stig.generator_for "no #random" }
+end
+
+test "with an object responding to #random" do |stig|
+  object = Object.new
+  object.define_singleton_method(:random) { 1 }
+
+  generator = stig.generator_for(object)
+
+  assert_equal generator.class, Proc
+  assert_equal generator.call, 1
+end
+
+test "with an object taking arguments" do |stig|
+  object = Object.new
+  object.define_singleton_method(:random) { |*args| args }
+
+  arguments = [:a, :b, :c]
+  generator = stig.generator_for(object, *arguments)
+
+  assert_equal generator.call, arguments
+end

data/test/stig/hash_generator.rb

@@ -0,0 +1,35 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/hash"
+
+include Stig
+
+setup { Stig::Generators::Hash }
+
+test "takes a generator" do |mod|
+  keys      = generator { rand }
+  values    = generator { 1 }
+  generator = generator_for(mod, values)
+
+  property(generator, keys) do |hash, key|
+    assert_equal hash[key], 1
+
+    true
+  end
+end
+
+test "takes a generator and a list of keys" do |mod|
+  keys      = [:a, :b, :c]
+  values    = generator { 1 }
+  generator = generator_for(mod, values, *keys)
+
+  property(generator) do |hash|
+    assert_equal hash, :a => 1, :b => 1, :c => 1
+
+    true
+  end
+end
+
+test "doesn't take an invalid generator" do |mod|
+  assert_raise(ArgumentError) { mod.random(1) }
+end

data/test/stig/integer_generator.rb

@@ -0,0 +1,35 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/integer"
+
+include Stig
+
+setup { Stig::Generators::Integer }
+
+test "takes a maximum value" do |mod|
+  generator = generator_for(mod, 10)
+
+  property(generator) do |integer|
+    assert integer.between?(0, 10)
+
+    true
+  end
+end
+
+test "takes a range" do |mod|
+  generator = generator_for(mod, 5..10)
+
+  property(generator) do |integer|
+    assert integer.between?(5, 10)
+
+    true
+  end
+end
+
+test "defaults to Integers between 0 and 100" do |mod|
+  property(mod) do |integer|
+    assert integer.between?(0, 100)
+
+    true
+  end
+end

data/test/stig/property.rb

@@ -0,0 +1,101 @@
+require_relative "../test_helper"
+require "stig"
+
+GENERATOR = proc { 1 }
+VERBOSITY = $VERBOSE
+
+setup { Stig }
+
+prepare do
+  $VERBOSE = VERBOSITY
+  $test    = 0
+end
+
+test "no generators" do |stig|
+  assert_raise(ArgumentError) do
+    stig.property { true }
+  end
+end
+
+test "invalid generators" do |stig|
+  assert_raise(ArgumentError) do
+    stig.property("invalid", GENERATOR) { true }
+  end
+
+  assert_raise(ArgumentError) do
+    stig.property([].each) { true }
+  end
+end
+
+test "an object implementing #call as generator" do |stig|
+  generator = proc { 1 }
+
+  stig.property(generator) do |i|
+    assert_equal i, 1
+
+    true
+  end
+end
+
+test "an object implemeting #random as generator" do |stig|
+  generator = Object.new
+  generator.define_singleton_method(:random) { 1 }
+
+  stig.property(generator) do |i|
+    assert_equal i, 1
+
+    true
+  end
+end
+
+test "multiple generators" do |stig|
+  stig.property(GENERATOR, GENERATOR, GENERATOR) do |i,j,k|
+    assert_equal i, 1
+    assert_equal j, 1
+    assert_equal k, 1
+
+    true
+  end
+end
+
+test "no property" do |stig|
+  assert_raise(ArgumentError) { stig.property(GENERATOR) }
+end
+
+test "raises when a test fails" do |stig|
+  assert_raise(Stig::AssertionFailed) do
+    stig.property(GENERATOR) { false }
+  end
+end
+
+test "return true when all tests pass" do |stig|
+  assert stig.property(GENERATOR) { |i| true }
+end
+
+test "default number of runs" do |stig|
+  stig.property(GENERATOR) { $test += 1 }
+
+  assert_equal $test, 100
+end
+
+test "configure number of runs with constant" do |stig|
+  $VERBOSE = nil
+  stig::NUMBER_OF_RUNS = 2
+  $VERBOSE = VERBOSITY
+
+  stig.property(GENERATOR) { $test += 1 }
+
+  assert_equal $test, 2 
+end
+
+test "configure number of runs with environment variable" do |stig|
+  ENV["STIG_NUMBER_OF_RUNS"] = "2"
+  
+  $VERBOSE = nil
+  load "stig.rb"
+  $VERBOSE = VERBOSITY
+
+  stig.property(GENERATOR) { $test += 1 }
+
+  assert_equal $test, 2
+end

data/test/stig/refinements.rb

@@ -0,0 +1,11 @@
+require_relative "../test_helper"
+require "stig"
+
+test "doesn't pollute the global namespace" do
+  [Date, Float, Integer, String, Symbol, Time].each do |klass|
+    assert_equal klass.respond_to?(:random), false
+
+    # We just want this not to blow up.
+    Stig.property(klass) { true }
+  end
+end

data/test/stig/string_generator.rb

@@ -0,0 +1,63 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/string"
+
+include Stig
+
+setup { Stig::Generators::String }
+
+test "defaults to all ASCII characters with maximum length 25" do |mod|
+  set = Stig::Generators::Character::ASCII
+
+  property(mod) do |string|
+    assert string.chars.all? { |char| set.include? char }
+
+    true
+  end
+
+  property(mod) do |string|
+    assert string.size.between?(0, 25)
+
+    true
+  end
+end
+
+test "takes character sets" do |mod|
+  generator = generator_for(mod, ["a"])
+
+  property(generator) do |string|
+    assert_equal string.class, String
+
+    true
+  end
+
+  property(generator) do |string|
+      assert [["a"], []].include?(string.chars.uniq)
+
+    true
+  end
+end
+
+test "doesn't take an empty character set" do |mod|
+  assert_raise(ArgumentError) { mod.random([]) }
+end
+
+test "takes a maximum length" do |mod|
+  generator = generator_for(mod, ["a"], 10)
+  
+  property(generator) do |string|
+    assert string.size.between?(0, 10)
+
+    true
+  end
+end
+
+test "takes a range as length" do |mod|
+  generator = generator_for(mod, ["a"], 5..10)
+
+  property(generator) do |string|
+    assert string.size.between?(5, 10)
+
+    true
+  end
+end

data/test/stig/symbol_generator.rb

@@ -0,0 +1,63 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/symbol"
+
+include Stig
+
+setup { Stig::Generators::Symbol }
+
+test "defaults to all ASCII characters with maximum length 25" do |mod|
+  set = Stig::Generators::Character::ASCII
+
+  property(mod) do |symbol|
+    assert symbol.to_s.chars.all? { |char| set.include? char }
+
+    true
+  end
+
+  property(mod) do |symbol|
+    assert symbol.size.between?(0, 25)
+
+    true
+  end
+end
+
+test "takes character sets" do |mod|
+  generator = generator_for(mod, ["a"])
+
+  property(generator) do |symbol|
+    assert_equal symbol.class, Symbol
+
+    true
+  end
+
+  property(generator) do |symbol|
+      assert [["a"], []].include?(symbol.to_s.chars.uniq)
+
+    true
+  end
+end
+
+test "doesn't take an empty character set" do |mod|
+  assert_raise(ArgumentError) { mod.random([]) }
+end
+
+test "takes a maximum length" do |mod|
+  generator = generator_for(mod, ["a"], 10)
+  
+  property(generator) do |symbol|
+    assert symbol.size.between?(0, 10)
+
+    true
+  end
+end
+
+test "takes a range as length" do |mod|
+  generator = generator_for(mod, ["a"], 5..10)
+
+  property(generator) do |symbol|
+    assert symbol.size.between?(5, 10)
+
+    true
+  end
+end

data/test/stig/time_generator.rb

@@ -0,0 +1,34 @@
+require_relative "../test_helper"
+require "stig"
+require "stig/generators/time"
+
+include Stig
+
+setup { Stig::Generators::Time }
+
+test "defaults to dates between the UNIX epoch and \"now\"" do |mod|
+  range = Time.at(0)..Time.now
+
+  property(mod) do |time|
+    assert_equal time.class, Time
+
+    true
+  end
+
+  property(mod) do |time|
+    assert range.cover?(time)
+
+    true
+  end
+end
+
+test "takes a Range" do |mod|
+  range     = Time.at(200)..Time.at(300)
+  generator = generator_for(mod, range)
+
+  property(generator) do |time|
+    assert range.cover?(time)
+
+    true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1 @@
+$:.unshift File.expand_path('../../lib', __FILE__)

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: stig
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jip van Reijsen
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDhTCCAm2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMRYwFAYDVQQDDA1qaXB2
+  YW5yZWlqc2VuMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
+  FgNjb20wHhcNMTQwODIwMTcxOTMyWhcNMTUwODIwMTcxOTMyWjBEMRYwFAYDVQQD
+  DA1qaXB2YW5yZWlqc2VuMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJ
+  k/IsZAEZFgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsHlOk
+  1hmzWghMsGRqmVXfBIYeJ6qZFOU9pYL+Zv7PkjqkC8O720+oXwMcANuT2IzHTdy+
+  rTEH8ctLioYGN5FI+lJPKsTtl3+KNwJdIP9h4W8t5RtxMTaPU1mI/jk6wKz2o2qy
+  u12J0cLKb7IWH19DAj2ZjAxmxQqTZsGt6VbAky2foZjo/x112wMSixzOEukW+O6W
+  fqBVnSjfOClhT+plelqlR5i1rz5YT6IL82D538AOU6tzLddH6XyHD+SygKpYKcV9
+  QUOXJGhTcUyA9WtgkaffIVlB5l4Ny6sT+CdEbI8N8htMziBjNcZul6/6CI+n0IDs
+  cJ4EorwzD5YXUAQzAgMBAAGjgYEwfzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAd
+  BgNVHQ4EFgQUNWHVVURPyyrVLTYn664v3mAEXXQwIgYDVR0RBBswGYEXamlwdmFu
+  cmVpanNlbkBnbWFpbC5jb20wIgYDVR0SBBswGYEXamlwdmFucmVpanNlbkBnbWFp
+  bC5jb20wDQYJKoZIhvcNAQEFBQADggEBAEwhZPajKIKnMrZag4vojHM0KNiTFOFN
+  rKW875s0/ZQ0vZQ8XafR+9HPflRntkdGMoXG1Z48w1ocUGkeuqg8he4q3sjEPHXK
+  Jd3lAIrlZDIH5EBIUjzOWJz+vtH6LfPwl73sHJ8TZ/bxZnianWq4UMPIxQywfrba
+  vtLKKRzrUpWQP67o9e0yLrfIWUl8AkCpcqsHMfgAPwvgtv0e2Hqfo74uPZ/u5wll
+  WXFwPdOwdBBrxe80pFe980gybYXGDKG9qljoAy9n/Z09I0mLTqN+Qk3LyBfV9JpJ
+  GwazeZftMqpbXP5J5qZq3KDKKFABsUKmL68rdLwTA6BZBqPA2D063qs=
+  -----END CERTIFICATE-----
+date: 2014-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cutest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Stig is a small library for property based testing in Ruby.
+email: jipvanreijsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/stig.rb
+- lib/stig/generators.rb
+- lib/stig/generators/array.rb
+- lib/stig/generators/character.rb
+- lib/stig/generators/date.rb
+- lib/stig/generators/float.rb
+- lib/stig/generators/hash.rb
+- lib/stig/generators/integer.rb
+- lib/stig/generators/string.rb
+- lib/stig/generators/symbol.rb
+- lib/stig/generators/time.rb
+- lib/stig/refinements.rb
+- lib/stig/version.rb
+- stig.gemspec
+- test/README.md
+- test/stig/array_generator.rb
+- test/stig/character_generator.rb
+- test/stig/date_generator.rb
+- test/stig/float_generator.rb
+- test/stig/generator.rb
+- test/stig/hash_generator.rb
+- test/stig/integer_generator.rb
+- test/stig/property.rb
+- test/stig/refinements.rb
+- test/stig/string_generator.rb
+- test/stig/symbol_generator.rb
+- test/stig/time_generator.rb
+- test/test_helper.rb
+homepage: https://github.com/britishtea/stig
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: simple test input generation
+test_files: []

metadata.gz.sig

@@ -0,0 +1,2 @@
+}�$�y��ɱ����{��tc�]`DoW��u	) �3�%�ɐM*fw�|)�}�zQ���������_n����i
+Ҙ䣑5��(G=[A��I7�6�9�;��#���l:hXJ�����2�g�H��Ə�F�����;�䈬i#��G��+�7.���Ї�������u���]�R(��MՊK�%�DnX��r�����+
��f/zA��T��$�6���߽�t_d��6�0�i�Z�x��.�9�