dither 0.0.11-java → 0.0.12-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e5528867e133a68bb9a429ae778153f59d7fa07
-  data.tar.gz: 06470e7386b123b3a6642fb48761318ad9bfc0be
+  metadata.gz: ebd1c192f8d6b59c19a05e69fca456794c19dd7f
+  data.tar.gz: 2d31494b532b2050bd1fa8662f7882080a8f5202
 SHA512:
-  metadata.gz: 70072c1bcfe0006bb632bf33542e700c8dd1036c2946b3d8bed6f4f752d1feffdbbf850a45eae283ab0651019c10b4ca03551f72741a6e9fe8dd8ae90b210741
-  data.tar.gz: 630cc4a6cef209358550c04242a82093ddf7729de981ccd3eeb942b8b144286da4c20a4bebe31c07dc2fada801b21e2327fd8b8f59d8b881ac59e097cba0ab9c
+  metadata.gz: beca214f99e4581f1aa285dff9bbf037078d6ef83035a15f254af6f69ef9a3971c9ad00cc6aab65dd973d075b1e78f100ddf98012860358224ccc6a204752cdd
+  data.tar.gz: b37a58fe3bb90490f3d15e5823640f6454156eff35e543f2f3863ef75a6cc979521df14c53b46157205e2c9b8f0ed7c3d82362d025ce0d5078cd9ea8df4e5bd8

data/README.md

@@ -4,6 +4,7 @@ Collection of combinatorial test generation strategies.
 # Usage
 
 ## Pairwise Testing
+IPOG (In-Parameter-Order-General) is an efficient deterministic alogrithm.
 ```ruby
 require 'dither'
 
@@ -32,6 +33,25 @@ Dither.ipog([[true, false],
 
 ```
 
+ATEG non-deterministic alogrithm for pairwise testing.
+```ruby
+require 'dither'
+
+# 2-way
+Dither.ateg([[true, false],
+             [:cat, :dog, :mouse],
+             (0...3).to_a])
+
+# 3-way
+Dither.ateg([[true, false],
+             [true, false],
+             [:cat, :dog, :mouse],
+             (0...5).to_a],
+            :t => 3,
+            :seed => 0 # set the seed on the random number generator
+)
+```
+
 ## Graph Models (Experimental)
 ```ruby
 raw_graph = {

data/lib/dither/ateg.rb

@@ -0,0 +1,15 @@
+
+module Dither
+  module Ateg
+
+    def run
+      result = []
+      until stop?
+        generate
+        filter
+        result << best_fit
+      end
+      result
+    end
+  end # Ateg
+end # Dither

data/lib/dither/ateg_pairwise.rb

@@ -0,0 +1,77 @@
+
+module Dither
+  module Ateg
+    class Pairwise
+      include Ateg
+
+      attr_reader :scratch, :n, :random, :t, :params, :constraints, :pair_cache, :comb
+
+      Pair = Struct.new(:i, :j)
+
+      module Pairs
+
+        def in_test_case?(test_case)
+          self.all? { |pair| pair.j == test_case[pair.i] }
+        end
+
+        alias_method :orig_method_missing, :method_missing
+
+        def method_missing(method, *args, &block)
+          if method == :cached_hash
+            orig_hash = hash
+            self.class.define_method(:cached_hash) do
+              orig_hash
+            end
+          end
+          orig_method_missing(method, *args, &block)
+        end
+      end
+
+      def initialize(params, opts = {})
+
+        raise Dither::Error, 't must be >= 2' if opts[:t] < 2
+        raise Dither::Error, 't must be <= params.length' if opts[:t] > params.length
+        params.each do |param|
+          raise Dither::Error, 'param length must be > 1' if param.length < 2
+        end
+        @params = params
+        @n = 50
+        @scratch = Array.new(@n)
+        seed = opts[:seed] || Random.new.seed
+        @random = Random.new(seed)
+        @constraints = nil
+        @pair_cache = Array.new(params.length)
+        params.each_with_index do |param, i|
+          pair_cache[i] = (0...param.length).map { |j| Pair.new(i, j).freeze }
+        end
+        @comb = []
+        @t = opts[:t]
+        (0...params.length).to_a.combination(t).each do |a|
+          car, *cdr = a.map { |b| pair_cache[b] }
+          @comb.push(*car.product(*cdr).each { |b| b.extend(Pairs) })
+        end
+      end
+
+      def generate
+        (0...n).each do |i|
+          scratch[i] = params.map { |a| random.rand(a.length) }
+        end
+      end
+
+      def filter
+        return unless constraints
+      end
+
+      def best_fit
+        max, _ = scratch.map { |a| [a, comb.count { |b| b.in_test_case?(a) }] }
+          .max { |a, b| a[1] <=> b[1] }
+        comb.delete_if { |a| a.in_test_case?(max) }
+        max
+      end
+
+      def stop?
+        comb.empty?
+      end
+    end
+  end
+end

data/lib/dither/version.rb

@@ -1,4 +1,4 @@
 
 module Dither
-  VERSION = '0.0.11'
+  VERSION = '0.0.12'
 end

data/lib/dither.rb

@@ -25,6 +25,11 @@ module Dither
     opts[:t] = t
     MIPOG.new(params, opts).run
   end
+
+  def self.ateg(params, opts = {})
+    opts = DEFUALT_OPTS.dup.merge(opts)
+    Ateg::Pairwise.new(params, opts).run
+  end
 end # Dither
 
 require 'dither/param'
@@ -34,6 +39,8 @@ require 'dither/ipog_helper'
 require 'dither/ipog'
 require 'dither/mipog'
 require 'dither/chinese_postman_problem'
+require 'dither/ateg'
+require 'dither/ateg_pairwise'
 
 if RUBY_PLATFORM =~ /java/
   require 'java'

data/spec/dither/dither_spec.rb

@@ -165,4 +165,14 @@ describe Dither do
                                        [0, 0, 0, 1],
                                        [0, 1, 1, 1]].to_set)
   end
+
+  it 'can run 2-way ateg' do
+    params = [(0...2).to_a, (0...2).to_a, (0...2).to_a, (0..3).to_a]
+    Dither.ateg(params)
+  end
+
+  it 'can run 4-way ateg with seed' do
+    params = [(0...2).to_a, (0...2).to_a, (0...2).to_a, (0..3).to_a]
+    expect(Dither.ateg(params, :t => 4, :seed => 0).length).to eq 32
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: java
 authors:
 - Jason Gowan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-09-14 00:00:00.000000000 Z
+date: 2015-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -70,6 +70,8 @@ files:
 - dither.gemspec
 - lib/dither.jar
 - lib/dither.rb
+- lib/dither/ateg.rb
+- lib/dither/ateg_pairwise.rb
 - lib/dither/chinese_postman_problem.rb
 - lib/dither/ipog.rb
 - lib/dither/ipog_helper.rb