dither 0.0.9-java → 0.0.10-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7b9a6a3077ab3312022ea6a5e4d1bc0bb66c597
-  data.tar.gz: 7de614370ed33a979147bc9249afa8cb4733f4fc
+  metadata.gz: f604e88d5d8eac1f835c1dda247b4fd0772002ea
+  data.tar.gz: 4dbd069d8a778df29828151bbb176093885f0f3b
 SHA512:
-  metadata.gz: 6a127e281dee369094061ff7511282ee5de76c212e762afac1d91784696b92cc2c0b24b8bfde4c0dd0a7a583c6b7858488670acc870bb3b8c12a5542e0820dee
-  data.tar.gz: 5bc538d91a0fc3d8ea851336bfd7abf3e98a3e84a3b0af1f159f3cd987d553a69f91a0982c2026fee4e3ea009a08d120ed66a916f012e46505ce1ffd592ce969
+  metadata.gz: b648cc3b440e1f2cd88dd47d85cd84e31a6755fe5c6912b11aa23c1fa405155c55a25a74f80e37b37a91ec5fe40e62abb74adba574eb87d86abe4968521adfd2
+  data.tar.gz: 20ef90a73de9b0f31bc43f3435c33f5202b1eef2aa8ecc7971eb42900dde8b4a1f243ff1dba5ede919cf5555a0f2e4d114bf5011d3793f15b845fa6df0273b08

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: java
 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