dither 0.0.8-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eaa7339d133be5eb764dc4b8aa8d1504cfefd4fb
+  data.tar.gz: dce4f5a332a553d1463da52cbf5feafae2579373
+SHA512:
+  metadata.gz: 086c0fe7b98425443312ea641541684a700d3475a4928e2fb23e58322b0576952051abec719dc876a8205252ff51491d026600e12ce6f558d16192b622acaf6c
+  data.tar.gz: 64763c24e5bebf57c82ad2e7d3e744392771986f765e262a6ef1dca950b9b757cce962f199203469337b7163a0691cd63a2aa3f342a7e0f4ecf47f2c0bf5b151

data/.gitignore

@@ -0,0 +1,35 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.ruby-version

@@ -0,0 +1 @@
+2.1.0

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    dither (0.0.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coveralls (0.7.1)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    mime-types (2.3)
+    multi_json (1.10.1)
+    netrc (0.7.7)
+    rake (0.9.6)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.1)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    simplecov (0.9.0)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.3.3)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  coveralls
+  dither!
+  rake (~> 0.9.2)
+  rspec (~> 3.2)

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jason Gowan
+
+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,57 @@
+# Dither
+Collection of combinatorial test generation strategies.
+
+# Usage
+
+Use 2-Way IPOG
+```ruby
+require 'dither'
+
+results = Dither.all_pairs([[true, false],
+                            [:cat, :dog, :mouse],
+                            (0...3).to_a])
+
+results.each { |a| puts "#{a}" }
+
+# output
+[true,  :cat, 0]
+[true,  :dog, 1]
+[true,  :mouse, 2]
+[false, :cat, 0]
+[false, :dog, 1]
+[false, :mouse, 2]
+[true,  :cat, 0]
+[true,  :dog, 1]
+[true,  :mouse, 2]
+```
+
+Use 3-Way IPOG
+```ruby
+require 'dither'
+
+results = Dither.all_pairs([[true, false],
+                            [true, false],
+                            [:cat, :dog, :mouse],
+                            (0...5).to_a], 3)
+
+results.each { |a| puts "#{a}" }
+
+# output
+[true, true, :cat, 0]
+...
+```
+
+# Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches
+
+# Copyright
+includes [dither-java](https://github.com/jesg/dither-java) Apache License, Version 2.0
+
+Copyright (c) 2015 Jason Gowan See LICENSE for details.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/dither.gemspec

@@ -0,0 +1,33 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "dither/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dither"
+  s.version     = Dither::VERSION
+  s.licenses    = ['MIT']
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jason Gowan"]
+  s.email       = ["gowanjason@gmail.com"]
+  s.homepage    = "https://github.com/jesg/dither"
+  s.summary     = %q{Collection of test generation strategies}
+  s.description = %q{Efficient test generation strategies}
+
+  s.rubyforge_project = "dither"
+
+  s.add_development_dependency "rspec", "~> 3.2"
+  s.add_development_dependency "rake", "~> 0.9.2"
+  s.add_development_dependency "coveralls"
+
+  files         = `git ls-files`.split("\n")
+
+  if RUBY_PLATFORM =~ /java/
+    s.platform = "java"
+    # compile dither-java on jdk 7
+    files << "lib/dither.jar"
+  end
+  s.files = files
+
+  s.test_files    = `git ls-files -- {test,spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/dither/ipog.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+module Dither
+  class IPOG
+    include IPOGHelper
+
+    def run
+      # add into test set a test for each combination of values
+      # of the first t parameter
+      test_set = comb
+
+      (t...params.length).each do |i|
+        # let pi
+        # be the set of t-way combinations of values involving
+        # parameter Pi and t -1 parameters among the first i – 1
+        # parameters
+        pi = comb_i(i)
+
+        # horizontal extension for parameter i
+        test_set.each do |test_case|
+          cover = maximize_coverage(i, test_case, pi)
+
+          if cover.nil?
+            test_set.delete(test_case)
+          else
+            pi -= cover
+          end
+        end
+
+        # vertical extension for parameter i
+        pi.each do |a|
+          if test_set.any? { |b| a.subset?(b) }
+            pi.delete(a)
+          else
+
+            test_case = nil
+            test_set.each do |b|
+              test_case = b.merge_without_conflict(i, a) do |a|
+                violates_constraints?(a)
+              end
+              break unless test_case.nil?
+            end
+
+            if test_case.nil?
+              test_set << a.create_unbound(i)
+            end
+            pi.delete(a)
+          end
+        end
+      end
+
+      @test_set = test_set.map { |a| fill_unbound(a) }
+        .delete_if(&:nil?)
+        .to_a
+      @test_set
+    end
+  end # IPOG
+end # Dither

data/lib/dither/ipog_helper.rb

@@ -0,0 +1,141 @@
+# coding: utf-8
+
+module Dither
+  module IPOGHelper
+    attr_reader :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool
+    private :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool
+
+    def initialize(params, t, opts = {})
+      init_params(params)
+      @t = t
+      unless opts[:constraints].nil?
+        @constraints = opts[:constraints].map(&:to_a)
+                       .map { |a| a.map { |b| @params[@map_to_orig_index.key(b[0])][b[1]] } }
+                       .map(&:to_set)
+      end
+
+      raise Dither::Error, 't must be >= 2' if t < 2
+      raise Dither::Error, 't must be <= params.length' if t > params.length
+      params.each do |param|
+        raise Dither::Error, 'param length must be > 1' if param.length < 2
+      end
+    end
+
+    def init_params(user_params)
+      tmp = []
+      @input_params = user_params
+      user_params.each_with_index { |e, i| tmp << [i, e] }
+      @orig_params = tmp.sort_by { |a| a[1].length }
+                     .reverse!
+
+      @map_to_orig_index = {}
+      @orig_params.each_with_index do |e, i|
+        @map_to_orig_index[i] = e[0]
+      end
+
+      @params = []
+      @unbound_param_pool = []
+      orig_params.each_with_index do |e, i|
+        @params << (0...e[1].length).map { |j| Param.new(i, j) }
+        @unbound_param_pool << UnboundParam.new(i)
+      end
+      params
+    end
+
+    # return nil if unable to satisfy constraints
+    def maximize_coverage(i, test_case, pi)
+      current_max = 0
+      current_max_j = 0
+      current_matches = []
+
+      (0...params[i].length).each do |j|
+        current_param = params[i][j]
+        test_case << current_param
+        unless violates_constraints?(test_case)
+          matches = pi.select { |a| a.subset?(test_case) }
+          count = matches.count
+
+          if count > current_max
+            current_max = count
+            current_max_j = j
+            current_matches = matches
+          end
+        end
+        test_case.delete(current_param)
+      end
+
+      return nil if violates_constraints?(test_case)
+      test_case << params[i][current_max_j]
+
+      current_matches
+    end
+
+    def violates_constraints?(params)
+      return false if constraints.nil?
+      constraints.any? { |b| b.subset?(params) }
+    end
+
+    private
+
+    def comb
+      ranges = (0...t).to_a.inject([]) do |a, i|
+        a << (0...params[i].length).map { |j| params[i][j] }
+      end
+
+      products = ranges[1..-1].inject(ranges[0]) do |a, b|
+        a = a.product(b)
+      end
+
+      result = products.map(&:flatten)
+        .map { |a| TestCase.create(params, unbound_param_pool, a) }
+      result
+    end
+
+    def comb_i(param_i)
+      values = (0...param_i).to_a.combination((t-1)).to_a
+      values.each do |a|
+        a << param_i
+      end
+      result = []
+      values.each do |a|
+        result += a[1..-1]
+                 .inject((0...params[a[0]].length).map { |b| params[a[0]][b] }) { |p, i| p.product((0...params[i].length).to_a.map { |c| params[i][c] }) }
+                 .map(&:flatten)
+                 .map { |a| TestCase.create(params, unbound_param_pool, a) }
+      end
+      result.to_set
+    end
+
+
+    def fill_unbound(data)
+      arr = Array.new(params.length)
+      data.each do |param|
+        unless param.unbound?
+          i = @map_to_orig_index[param.i]
+          arr[i] = @input_params[i][param.j]
+        end
+      end
+
+      arr.each_with_index do |e, i|
+        next unless e.nil?
+
+        orig_param = @input_params[i]
+        (0...orig_param.length).each do |j|
+          data << params[@map_to_orig_index.key(i)][j]
+          if violates_constraints?(data)
+            data.delete(params[@map_to_orig_index.key(i)][j])
+            next
+          else
+            arr[i] = orig_param[j]
+            break
+          end
+        end
+        return nil if arr[i].nil?
+      end
+
+      return nil if violates_constraints?(data)
+
+      arr
+    end
+  end # IPOGHelper
+end # Dither

data/lib/dither/java_ext/dither.rb

@@ -0,0 +1,29 @@
+
+module Dither
+
+  def self.all_pairs(params, t = 2, opts = {})
+    constraints = constraints_to_java(params.length, opts[:constraints])
+    com.github.jesg.dither.Dither.ipog(
+      t.to_java(:int),
+      params.map(&:to_java).to_java,
+      constraints).to_a
+  rescue com.github.jesg.dither.DitherError => e
+    raise Dither::Error.new(e.message)
+  end
+
+  private
+
+  def self.constraints_to_java(param_length, constraints)
+    return [].to_java if constraints.nil?
+    result = []
+    constraints.each do |constraint|
+      new_constraint = Array.new(param_length)
+      constraint.each do |k, v|
+        new_constraint[k] = v
+        puts "#{k} => #{v}"
+      end
+      result << new_constraint
+    end
+    result.map { |a| a.to_java(java.lang.Integer) }.to_java
+  end
+end

data/lib/dither/mipog.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+module Dither
+  class MIPOG
+    include Dither::IPOGHelper
+
+    def maximize_unbound_coverage(i, test_case, pi)
+      all_unbound = test_case.unbound
+                    .map { |a| a.create_params(params[a.i].length) }
+                    .flatten
+
+      current_max = 0
+      current_max_j = 0
+      current_outer_param = all_unbound[0]
+      current_matches = []
+
+      all_unbound.each do |outer_param|
+        test_case << outer_param
+
+        (0...params[i].length).each do |j|
+          current_param = params[i][j]
+          test_case << current_param
+          count = pi.count { |a| a.subset?(test_case) }
+
+          if count > current_max
+            current_max = count
+            current_max_j = j
+            current_outer_param = outer_param
+          end
+          test_case.delete(current_param)
+        end
+        test_case.delete(outer_param)
+      end
+
+      test_case << params[i][current_max_j]
+      test_case << current_outer_param
+      test_case.delete(unbound_param_pool[current_outer_param.i])
+
+      current_matches
+    end
+
+    def run
+      # add into test set a test for each combination of values
+      # of the first t parameter
+      test_set = comb
+
+      (t...params.length).each do |i|
+        # let pi
+        # be the set of t-way combinations of values involving
+        # parameter Pi and t -1 parameters among the first i – 1
+        # parameters
+        pi = comb_i(i)
+
+        # horizontal extension for parameter i
+        test_set.each do |test_case|
+          if !test_case.contains_unbound?
+            cover = maximize_coverage(i, test_case, pi)
+          else
+            cover = maximize_unbound_coverage(i, test_case, pi)
+          end
+
+          # remove covered combinations
+          pi -= cover
+        end
+
+        # vertical extension for parameter i
+        until pi.empty?
+          pi.sort!
+          test_case, coverage = maximize_vertical_coverage(i, pi[0].dup, pi)
+          test_set << test_case.create_unbound(i)
+          pi -= coverage
+        end
+      end
+      test_set.map { |a| fill_unbound(a) }
+    end
+
+    def maximize_vertical_coverage(i, test_case, pi)
+      coverage = [pi[0]]
+      pi[1..-1].each do |a|
+        coverage << a unless test_case.merge_without_conflict(i, a).nil?
+      end
+      [test_case, coverage]
+    end
+  end # MIPOG
+end # Dither

data/lib/dither/param.rb

@@ -0,0 +1,19 @@
+
+module Dither
+  Param = Struct.new(:i, :j) do
+    def <=>(param)
+      return 1 if param.unbound?
+
+      a = i <=> param.i
+      if a == 0
+        return j <=> param.j
+      else
+        return a
+      end
+    end
+
+    def unbound?
+      false
+    end
+  end # Param
+end # Dither

data/lib/dither/test_case.rb

@@ -0,0 +1,80 @@
+
+module Dither
+  class TestCase < Set
+
+    attr_accessor :bound_param_pool, :unbound_param_pool
+
+    def self.create(bound_param_pool, unbound_param_pool, params)
+      test_case = TestCase.new(params)
+      test_case.bound_param_pool = bound_param_pool
+      test_case.unbound_param_pool = unbound_param_pool
+      test_case
+    end
+
+    def contains_unbound?
+      self.any?(&:unbound?)
+    end
+
+    def unbound
+      self.select(&:unbound?)
+    end
+
+    def <=>(test_case)
+      result = 0
+      l = length <= test_case.length ? length : test_case.length
+      self.zip(test_case)[0...l].each do |arr|
+        first, second = arr
+        result = first <=> second
+        break if result != 0
+      end
+      result
+    end
+
+    def create_unbound(i)
+      bound_params = self.reject(&:unbound?).map(&:i)
+      ((0..i).to_a - bound_params).each do |a|
+        self << unbound_param_pool[a]
+      end
+      self
+    end
+
+    def to_ipog_array(i)
+      arr = Array.new(i)
+      self.each do |param|
+        arr[param.i] = param.j unless param.unbound?
+      end
+      arr
+    end
+
+    # return nil if there is a conflict
+    # return self if no conflict
+    def merge_without_conflict(i, test_case, &block)
+      new_elements = []
+      self.to_ipog_array(i).zip(test_case.to_ipog_array(i))
+        .each_with_index do |arr, a|
+        first, second = arr
+
+        if first.nil? && second.nil?
+          new_elements << unbound_param_pool[a]
+        elsif (first == second) || second.nil?
+          next
+        elsif first.nil?
+          new_elements << bound_param_pool[a][second]
+        else
+          return nil
+        end
+      end
+
+      new_self = self.clone
+      new_elements.each { |a| new_self << a }
+
+      return nil if block_given? && block.call(new_self)
+
+      new_elements.each do |a|
+        self.delete(unbound_param_pool[a.i]) unless a.unbound?
+        self << a
+      end
+      self
+    end
+  end # TestCase
+end # Dither

data/lib/dither/unbound_param.rb

@@ -0,0 +1,17 @@
+
+module Dither
+  UnboundParam = Struct.new(:i) do
+    def <=>(param)
+      return -1 unless param.unbound?
+      i <=> param.i
+    end
+
+    def unbound?
+      true
+    end
+
+    def create_params(j)
+      (0...j).map { |a| Param.new(i, a) }
+    end
+  end # UnboundParam
+end # Dither

data/lib/dither/version.rb

@@ -0,0 +1,4 @@
+
+module Dither
+  VERSION = '0.0.8'
+end

data/lib/dither.rb

@@ -0,0 +1,30 @@
+
+require 'set'
+
+module Dither
+
+  class Error < StandardError; end
+
+  def self.all_pairs(params, t = 2, opts = {})
+    IPOG.new(params, t, opts).run
+  end
+
+  def self.mipog(params, t = 2, opts = {})
+    raise Error, 'mipog does not support constraints' if opts.key?(:constraints)
+    MIPOG.new(params, t, opts).run
+  end
+end # Dither
+
+require 'dither/param'
+require 'dither/unbound_param'
+require 'dither/test_case'
+require 'dither/ipog_helper'
+require 'dither/ipog'
+require 'dither/mipog'
+
+if RUBY_PLATFORM =~ /java/
+  require 'java'
+  require 'dither.jar'
+
+  require 'dither/java_ext/dither'
+end

data/spec/dither/dither_spec.rb

@@ -0,0 +1,222 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Dither do
+
+  it 'mipog does not support constraints' do
+    expect { Dither.mipog([[1,1],[1,2]], 2, :constraints => []) }.to raise_error(Dither::Error, 'mipog does not support constraints')
+  end
+
+  it 't must be >= 2' do
+    expect { Dither.all_pairs([], 0) }.to raise_error(Dither::Error, 't must be >= 2')
+  end
+
+  it 't must be <= params.length' do
+    expect { Dither.all_pairs([(0...3).to_a], 4) }.to raise_error(Dither::Error,'t must be <= params.length')
+  end
+
+  it 'param length must be > 1' do
+    expect { Dither.all_pairs([[], []], 2) }.to raise_error(Dither::Error,'param length must be > 1')
+  end
+
+  it 'can compute 2-way ipog using symbols' do
+    params = [[:a, :b, :c], [:d, :e, :f], [:h, :i]]
+    expect(Dither.all_pairs(params)).to eq([[:a, :d, :h],
+                                            [:a, :e, :i],
+                                            [:a, :f, :h],
+                                            [:b, :d, :i],
+                                            [:b, :e, :h],
+                                            [:b, :f, :i],
+                                            [:c, :d, :h],
+                                            [:c, :e, :i],
+                                            [:c, :f, :h]])
+  end
+
+  it 'can compute 3-way mipog' do
+    params = [(0...2).to_a, (0...2).to_a, (0..3).to_a]
+    expect(Dither.mipog(params, 3)).to eq([[0, 0, 0],
+                                           [1, 0, 0],
+                                           [0, 1, 0],
+                                           [1, 1, 0],
+                                           [0, 0, 1],
+                                           [1, 0, 1],
+                                           [0, 1, 1],
+                                           [1, 1, 1],
+                                           [0, 0, 2],
+                                           [1, 0, 2],
+                                           [0, 1, 2],
+                                           [1, 1, 2],
+                                           [0, 0, 3],
+                                           [1, 0, 3],
+                                           [0, 1, 3],
+                                           [1, 1, 3],
+                                          ])
+  end
+
+  it 'can compute 2-way mipog using symbols' do
+    params = [[:a, :b, :c], [:d, :e, :f], [:h, :i]]
+    expect(Dither.mipog(params).to_set).to eq([[:a, :d, :h],
+                                        [:a, :e, :i],
+                                        [:a, :f, :h],
+                                        [:b, :d, :i],
+                                        [:b, :e, :h],
+                                        [:b, :f, :i],
+                                        [:c, :d, :h],
+                                        [:c, :e, :i],
+                                        [:c, :f, :h]].to_set)
+  end
+
+  it 'can compute 2-way mipog' do
+    params = [(0...2).to_a, (0..3).to_a]
+    expect(Dither.mipog(params)).to eq([
+                                         [0, 0],
+                                         [1, 0],
+                                         [0, 1],
+                                         [1, 1],
+                                         [0, 2],
+                                         [1, 2],
+                                         [0, 3],
+                                         [1, 3],
+                                       ])
+  end
+
+  it 'can compute 2-way ipog' do
+    params = [(0...2).to_a, (0..3).to_a]
+    expect(Dither.all_pairs(params)).to eq([
+                                             [0, 0],
+                                             [1, 0],
+                                             [0, 1],
+                                             [1, 1],
+                                             [0, 2],
+                                             [1, 2],
+                                             [0, 3],
+                                             [1, 3],
+                                           ])
+  end
+
+  it 'can compute 3-way ipog' do
+    params = [(0...2).to_a, (0...2).to_a, (0..3).to_a]
+    expect(Dither.all_pairs(params, 3).to_set).to eq([[0, 0, 0],
+                                               [1, 0, 0],
+                                               [0, 1, 0],
+                                               [1, 1, 0],
+                                               [0, 0, 1],
+                                               [1, 0, 1],
+                                               [0, 1, 1],
+                                               [1, 1, 1],
+                                               [0, 0, 2],
+                                               [1, 0, 2],
+                                               [0, 1, 2],
+                                               [1, 1, 2],
+                                               [0, 0, 3],
+                                               [1, 0, 3],
+                                               [0, 1, 3],
+                                               [1, 1, 3],
+                                              ].to_set)
+  end
+
+  it 'can compute 3-way ipog with constraints' do
+    params = [(0...2).to_a, (0...2).to_a, (0..3).to_a]
+    expect(Dither.all_pairs(params, 3,
+                            :constraints => [
+                              {0 => 0,
+                               2 => 2},
+                              {0 => 0,
+                               1 => 1,
+                               2 => 0}
+                            ]).to_set).to eq([[0, 0, 0],
+                                       [1, 0, 0],
+                                       [1, 1, 0],
+                                       [0, 0, 1],
+                                       [1, 0, 1],
+                                       [0, 1, 1],
+                                       [1, 1, 1],
+                                       [1, 0, 2],
+                                       [1, 1, 2],
+                                       [0, 0, 3],
+                                       [1, 0, 3],
+                                       [0, 1, 3],
+                                       [1, 1, 3],
+                                      ].to_set)
+  end
+
+  it 'another 3-way ipog with constraints' do
+    params = [(0...2).to_a, (0...2).to_a, (0...2).to_a, (0..3).to_a]
+    expect(Dither.all_pairs(params, 3,
+                            :constraints => [
+                              {0 => 0,
+                               1 => 1,
+                               2 => 0}
+                            ]).to_set).to eq([[0, 0, 0, 0],
+                                       [1, 1, 0, 0],
+                                       [1, 0, 1, 0],
+                                       [0, 1, 1, 0],
+                                       [1, 0, 0, 1],
+                                       [1, 1, 0, 1],
+                                       [0, 0, 1, 1],
+                                       [1, 1, 1, 1],
+                                       [0, 0, 0, 2],
+                                       [1, 1, 0, 2],
+                                       [1, 0, 1, 2],
+                                       [0, 1, 1, 2],
+                                       [0, 0, 0, 3],
+                                       [1, 1, 0, 3],
+                                       [1, 0, 1, 3],
+                                       [0, 1, 1, 3],
+                                       [0, 0, 0, 1],
+                                       [0, 1, 1, 1]].to_set)
+
+#           results = Dither.all_pairs([
+#                                     (0...10).to_a,
+#                                     (0...10).to_a,
+#                                     (0...4).to_a,
+#                                     (0...3).to_a,
+#                                     (0...3).to_a,
+#                                     (0...2).to_a,
+#                                     (0...2).to_a,
+#                                     (0...2).to_a,
+#                                     (0...2).to_a,
+#                                     (0...2).to_a,
+#                                     (0...2).to_a,
+#                                     (0...2).to_a,
+#                                   ], 4)
+
+#        results = Dither.all_pairs([
+#                                 (0...4).to_a,
+#                                 (0...4).to_a,
+#                                 (0...4).to_a,
+#                                 (0...4).to_a,
+#                                 (0...4).to_a,
+#                                 (0...3).to_a,
+#                                 (0...3).to_a,
+#                                 (0...3).to_a,
+#                                 (0...3).to_a,
+#                               ], 2)
+
+
+        results = Dither.all_pairs([
+                                 (0...2).to_a, # user type
+                                 (0...2).to_a, # exists?
+                                 (0...2).to_a, # seats
+                                 (0...2).to_a, # seats
+                                 (0...3).to_a, # user region
+                                 (0...3).to_a, # currency
+                                 (0...3).to_a,
+                                 (0...4).to_a, # payment
+                                 (0...6).to_a, # delivery
+                                 (0...6).to_a,
+                               ], 3)
+
+        # mipog 2-way 36... ipog 36
+        # mipog 3-way 156... ipog 151
+        # mipog 4-way 592... ipog 511
+
+#    results = Dither.all_pairs( [[1,2],
+#                                  ['1','2'],
+#                                  [1.0,2.0],
+#                                  [true, false, 3]],3)
+            require 'csv'
+            results.each { |a| puts a.to_csv }
+            puts results.count
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'coveralls'
+Coveralls.wear!
+
+$LOAD_PATH.unshift File.expand_path("../lib")
+require 'dither'

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: dither
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+platform: java
+authors:
+- Jason Gowan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: Efficient test generation strategies
+email:
+- gowanjason@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- dither.gemspec
+- lib/dither.jar
+- lib/dither.rb
+- lib/dither/ipog.rb
+- lib/dither/ipog_helper.rb
+- lib/dither/java_ext/dither.rb
+- lib/dither/mipog.rb
+- lib/dither/param.rb
+- lib/dither/test_case.rb
+- lib/dither/unbound_param.rb
+- lib/dither/version.rb
+- spec/dither/dither_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jesg/dither
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: dither
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Collection of test generation strategies
+test_files:
+- spec/dither/dither_spec.rb
+- spec/spec_helper.rb