dither 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8544177ee83d6cbef836448d4e0d550cff9affc5
-  data.tar.gz: 91019ef4fc9f4cdaada74fddf41e4a9b4007f41a
+  metadata.gz: 1615f95c32d97e471ea43d8714dee5a9c9e4f1ad
+  data.tar.gz: 2284c90542966f2487969b68d35c30d372493a6c
 SHA512:
-  metadata.gz: 0aa18ecaf1bf5e84690ef817f5b3b2607389359b9d6233af3beb7a74d3e79c3768d43b982766390b346be8430b3dd9334295a644f4004b750422fc7271a07eed
-  data.tar.gz: 192d58cfe5c72c8a1c177791a406779583084732d9f276cca1b3c4607d5c189901de369c80dc8fc4ebbf89cc65227df16d3ab184d6082318fea4aaa4829745ca
+  metadata.gz: 9f548f30dc8de6d28276fe42284451f01408bd1b86c4e627bd7f40651e62a2cddc872940007b840cf2653dfafeb3d92597726a587f2210e31f9be1cf7eb975d8
+  data.tar.gz: 5c8fb0bb33f372328275e2090821ffdfa8bba20dd7c20e054ae696acecffa114fb2b3416faceeb3985c971418c3269e394ee2f56b271fcc3f660b02fb2001ee0

data/Gemfile.lock

@@ -1,13 +1,26 @@
 PATH
   remote: .
   specs:
-    dither (0.0.4)
+    dither (0.0.5)
 
 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)
@@ -21,11 +34,21 @@ GEM
       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
   ruby
 
 DEPENDENCIES
+  coveralls
   dither!
   rake (~> 0.9.2)
   rspec (~> 3.2)

data/dither.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rspec", "~> 3.2"
   s.add_development_dependency "rake", "~> 0.9.2"
+  s.add_development_dependency "coveralls"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec}/*`.split("\n")

data/lib/dither/ipog.rb

@@ -2,72 +2,7 @@
 
 module Dither
   class IPOG
-    attr_reader :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool
-    private :params, :t, :constraints, :test_set, :orig_params
-
-    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 't must be >= 2' if t < 2
-      raise 't must be <= params.length' if t > params.length
-      params.each do |param|
-        raise 'param length must be > 1' if param.length < 2
-      end
-    end
-
-    def init_params(user_params)
-      tmp = []
-      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
-
-      test_case << params[i][current_max_j]
-      return nil if violates_constraints?(test_case)
-
-      current_matches
-    end
+    include IPOGHelper
 
     def run
       # add into test set a test for each combination of values
@@ -94,7 +29,7 @@ module Dither
 
         # vertical extension for parameter i
         pi.each do |a|
-          if test_set.any? { |test_case| a.subset?(test_case) }
+          if test_set.any? { |b| a.subset?(b) }
             pi.delete(a)
           else
 
@@ -114,85 +49,10 @@ module Dither
         end
       end
 
-      test_set.map { |a| fill_unbound(a) }
+      @test_set = test_set.map { |a| fill_unbound(a) }
         .delete_if(&:nil?)
         .to_a
+      @test_set
     end
-
-    def violates_constraints?(params)
-      return false if constraints.nil?
-      constraints.any? { |b| b.subset?(params) }
-    end
-
-    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
-
-      products.map(&:flatten)
-        .map { |a| TestCase.create(params, unbound_param_pool, a) }
-    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[0][b] }) { |p, i| p.product((0...params[i].length).to_a.map { |b| params[i][b] }) }
-                 .map(&:flatten)
-                 .map { |a| TestCase.create(params, unbound_param_pool, a) }
-      end
-      result
-    end
-
-    private
-
-    def fill_unbound(data)
-      arr = Array.new(params.length)
-      data.each do |param|
-        unless param.unbound?
-          orig_param = orig_params[param.i]
-          arr[orig_param[0]] = orig_param[1][param.j]
-        end
-      end
-
-      arr.each_with_index do |e, i|
-        if e.nil?
-          j = 0
-          orig_param = orig_params.find { |a| a[0] = i }
-          arr[i] = orig_param[1][j]
-        end
-      end
-
-      return nil if violates_constraints?(data)
-      arr
-    end
-
-    def find_unbound(param_array, stuff)
-      data = {}
-      stuff.each do |param|
-        data[param.i] = param.j
-      end
-
-      unbound = []
-      param_array.each do |param|
-        case data[param.i]
-        when param.j
-        when nil
-          unbound << param
-        else
-          unbound = nil
-          break
-        end
-      end
-      unbound
-    end
-  end
-end
+  end # IPOG
+end # Dither

data/lib/dither/ipog_helper.rb

@@ -0,0 +1,140 @@
+# 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 't must be >= 2' if t < 2
+      raise 't must be <= params.length' if t > params.length
+      params.each do |param|
+        raise '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
+
+      test_case << params[i][current_max_j]
+      return nil if violates_constraints?(test_case)
+
+      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
+    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]
+          end
+        end
+        return nil if arr[i].nil?
+      end
+
+      return nil if violates_constraints?(data)
+
+      arr
+    end
+  end # IPOGHelper
+end # Dither

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/test_case.rb

@@ -80,7 +80,9 @@ module Dither
       new_elements.each { |a| new_self << a }
 
       return nil if block_given? && block.call(new_self)
-      new_self
+
+      new_elements.each { |a| self << a }
+      self
     end
   end # TestCase
 end # Dither

data/lib/dither/version.rb

@@ -1,4 +1,4 @@
 
 module Dither
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/lib/dither.rb

@@ -6,9 +6,15 @@ module Dither
   def self.all_pairs(params, t = 2, opts = {})
     IPOG.new(params, t, opts).run
   end
+
+  def self.mipog(params, t = 2, opts = {})
+    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'

data/spec/dither/dither_spec.rb

@@ -19,14 +19,62 @@ describe Dither do
     expect(Dither.all_pairs(params)).to eq([[:a, :d, :h],
                                             [:a, :e, :i],
                                             [:a, :f, :h],
-                                            [:b, :d, :h],
-                                            [:b, :e, :i],
-                                            [:b, :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 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 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([
@@ -91,8 +139,6 @@ describe Dither 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,
-                               2 => 2},
                               {0 => 0,
                                1 => 1,
                                2 => 0}
@@ -100,10 +146,10 @@ describe Dither do
                                        [1, 1, 0, 0],
                                        [1, 0, 1, 0],
                                        [0, 1, 1, 0],
-                                       [0, 0, 0, 1],
+                                       [1, 0, 0, 1],
                                        [1, 1, 0, 1],
-                                       [1, 0, 1, 1],
-                                       [0, 1, 1, 1],
+                                       [0, 0, 1, 1],
+                                       [1, 1, 1, 1],
                                        [0, 0, 0, 2],
                                        [1, 1, 0, 2],
                                        [1, 0, 1, 2],
@@ -112,32 +158,6 @@ describe Dither do
                                        [1, 1, 0, 3],
                                        [1, 0, 1, 3],
                                        [0, 1, 1, 3],
-                                      ])
-       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,
-                               ], 3)
-
-#    results = Dither.all_pairs([
-#                             (0...2).to_a,
-#                             (0...2).to_a,
-#                             (0...2).to_a,
-#                             (0...3).to_a,
-#                           ], 3)
-        require 'csv'
-        results.each { |a| puts a.to_csv }
-        puts results.count
-
-
+                                       [0, 0, 0, 1]])
   end
 end

data/spec/spec_helper.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Jason Gowan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-19 00:00:00.000000000 Z
+date: 2015-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Efficient test generation strategies
 email:
 - gowanjason@gmail.com
@@ -56,6 +70,8 @@ files:
 - dither.gemspec
 - lib/dither.rb
 - lib/dither/ipog.rb
+- lib/dither/ipog_helper.rb
+- lib/dither/mipog.rb
 - lib/dither/param.rb
 - lib/dither/test_case.rb
 - lib/dither/unbound_param.rb