dither 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9574ed6c2c949edec919c9278fb913429c877e77
-  data.tar.gz: 801a8c1dfc56648d97d62b456037a1132e1b418b
+  metadata.gz: e6aeec317ee301c987fa9f850ae1d131ae2e5fc6
+  data.tar.gz: 5258de5745ae92ca80c7040911e7cf0d9a8156ff
 SHA512:
-  metadata.gz: 63d2f2ab3792d6a711a96543328df659d84a43f83909d6a3f392f4ad77e00898a9d652fb8b36cf8c85c35e68d0de257f0f59bd22089c4ad1b0ea8c57da2e607b
-  data.tar.gz: 5e997a1f04704678feb68b925a85bc82d66dcb91818c2ec22aba056bf3bbd2bfdbb1f3fd05219fe8f90cf125d9ce59157e56fd566ddfb781a884167d9ea72aee
+  metadata.gz: 771652b00d5078fcc02585ac67caa0c891081f6dd4ad75747cd08491242f8fd019030a07b4a2cfbc5154723c6dba8b54f8ab614bd043f6268b35d358a5b0068f
+  data.tar.gz: 08ab024560ddd9a7cde11f8ca7ae6ae77e69267e4478b7c6dad079ede63b626ed9b7a52d3ef0a0ab5053dc05ba6aaaa9b871c27542f804572a4482abca5ff9eb

data/README.md

@@ -3,42 +3,32 @@ Collection of combinatorial test generation strategies.
 
 # Usage
 
-Use 2-Way IPOG
 ```ruby
 require 'dither'
 
-results = Dither.ipog([[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.ipog([[true, false],
-                       [true, false],
-                       [:cat, :dog, :mouse],
-                       (0...5).to_a], :t => 3)
-
-results.each { |a| puts "#{a}" }
+# 2-way
+Dither.ipog([[true, false],
+             [:cat, :dog, :mouse],
+             (0...3).to_a])
+# 3-way
+Dither.ipog([[true, false],
+             [true, false],
+             [:cat, :dog, :mouse],
+             (0...5).to_a],
+            :t => 3)
+
+# 3-way with constraints and previously tested cases
+Dither.ipog([[true, false],
+             [true, false],
+             [:cat, :dog, :mouse],
+             (0...5).to_a],
+            :t => 3,
+            :constraints => [
+              { 1 => 0, 2 => 0 }, # exclude true and cat
+              { 1 => 0, 2 => 1, 3 => 4 }, # exclude true :dog 4 combinations
+            ],
+			:previously_tested => [[true, true, :cat, 0]])
 
-# output
-[true, true, :cat, 0]
-...
 ```
 
 # Note on Patches/Pull Requests

data/lib/dither/ipog_helper.rb

@@ -2,11 +2,11 @@
 
 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
+    attr_reader :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool, :tested
+    private :params, :t, :constraints, :test_set, :orig_params, :unbound_param_pool, :tested
 
     def initialize(params, opts = {})
-      init_params(params)
+      init_params(params, (opts[:previously_tested] || []))
       @t = opts[:t]
       unless opts[:constraints].nil?
         @constraints = opts[:constraints].map(&:to_a)
@@ -21,24 +21,40 @@ module Dither
       end
     end
 
-    def init_params(user_params)
+    def init_params(user_params, previously_tested)
       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!
 
+      orig_param_map = {}
       @map_to_orig_index = {}
       @orig_params.each_with_index do |e, i|
         @map_to_orig_index[i] = e[0]
+        orig_param_map[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) }
+        @params << (0...e[1].length).map do |j|
+          local_param = Param.new(i, j)
+          orig_param_map[e[0]][e[1][j]] = local_param
+          local_param
+        end
         @unbound_param_pool << UnboundParam.new(i)
       end
+
+      @tested = []
+      previously_tested.each do |a|
+        local_params = []
+        a.each_with_index do |e, i|
+          local_params << orig_param_map[i][e]
+        end
+        @tested << TestCase.create(params, unbound_param_pool, local_params)
+      end
+
       params
     end
 
@@ -88,7 +104,7 @@ module Dither
 
       result = products.map(&:flatten)
         .map { |a| TestCase.create(params, unbound_param_pool, a) }
-      result
+      result.reject { |a| tested?(a) }
     end
 
     def comb_i(param_i)
@@ -101,11 +117,14 @@ module Dither
         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) }
+                 .map { |b| TestCase.create(params, unbound_param_pool, b) }
       end
-      result.to_set
+      result.reject { |a| tested?(a) }.to_set
     end
 
+    def tested?(test_case)
+      @tested.any? { |a| test_case.subset?(a) }
+    end
 
     def fill_unbound(data)
       arr = Array.new(params.length)
@@ -134,6 +153,7 @@ module Dither
       end
 
       return nil if violates_constraints?(data)
+      return nil if tested?(data)
 
       arr
     end

data/lib/dither/java_ext/dither.rb

@@ -7,7 +7,8 @@ module Dither
     com.github.jesg.dither.Dither.ipog(
       opts[:t].to_java(:int),
       params.map(&:to_java).to_java,
-      constraints).to_a
+      constraints,
+      (opts[:previously_tested] || []).map(&:to_java).to_java).to_a
   rescue com.github.jesg.dither.DitherError => e
     raise Dither::Error.new(e.message)
   end

data/lib/dither/version.rb

@@ -1,4 +1,4 @@
 
 module Dither
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

data/spec/dither/dither_spec.rb

@@ -117,13 +117,13 @@ describe Dither do
   it 'can compute 3-way ipog with constraints' do
     params = [(0...2).to_a, (0...2).to_a, (0..3).to_a]
     expect(Dither.ipog(params, :t => 3,
-                            :constraints => [
-                              {0 => 0,
-                               2 => 2},
-                              {0 => 0,
-                               1 => 1,
-                               2 => 0}
-                            ]).to_set).to eq([[0, 0, 0],
+                       :constraints => [
+                         {0 => 0,
+                          2 => 2},
+                         {0 => 0,
+                          1 => 1,
+                          2 => 0}],
+                        :previously_tested => [[0, 0, 0]]).to_set).to eq([
                                        [1, 0, 0],
                                        [1, 1, 0],
                                        [0, 0, 1],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Jason Gowan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-03 00:00:00.000000000 Z
+date: 2015-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec