dither 0.1.5 → 0.2.0.rc3

data/ext/dither/simple_constraint_handler.h

@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright (C) 2015 Jason Gowan
+ * All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the BSD license.  See the LICENSE file for details.
+ */
+
+#ifndef SIMPLE_CONSTRAINT_HANDLER_H_
+#define SIMPLE_CONSTRAINT_HANDLER_H_
+
+#include <vector>
+#include <utility>
+#include <algorithm>
+#include "dither_types.h"
+#include "base_constraint_handler.h"
+
+namespace dither {
+
+  class SimpleConstraintHandler : public BaseConstraintHandler {
+    protected:
+      std::vector<std::vector<std::pair<std::size_t, dval>>> constraints;
+      std::vector<dval> params;
+
+      inline bool violate_constraint(const dtest_case& test_case, const std::vector<std::pair<std::size_t, dval>>& constraint);
+      inline bool violate_constraint(const std::vector<param>& test_case, const std::vector<std::pair<std::size_t, dval>>& constraint);
+
+    public:
+      SimpleConstraintHandler(std::vector<dval>& ranges, std::vector<std::vector<dval>>& pconstraints);
+      bool violate_constraints(const dtest_case &test_case);
+      bool violate_constraints(const std::vector<param> &test_case);
+      bool ground(dtest_case &test_case);
+  };
+}
+
+#endif  // SIMPLE_CONSTRAINT_HANDLER_H_
+

data/lib/dither/api.rb

@@ -0,0 +1,20 @@
+
+require 'ffi'
+
+# Interface to the c++ api.
+module Dither
+  module API
+    extend FFI::Library
+    ffi_lib %w[lib/dither.so lib/dither.dll]
+
+    attach_function :dither_ipog_new, [:int], :pointer
+    attach_function :dither_ipog_add_parameter_int, [:pointer, :int, :pointer, :int], :void
+    attach_function :dither_ipog_run, [:pointer], :void
+    attach_function :dither_ipog_size, [:pointer], :int
+    attach_function :dither_ipog_display_raw_solution, [:pointer], :void
+    attach_function :dither_ipog_fill, [:pointer, :pointer], :void
+    attach_function :dither_ipog_add_constraint, [:pointer, :pointer, :int], :void
+    attach_function :dither_ipog_add_previously_tested, [:pointer, :pointer, :int], :void
+    # attach_function :dither_ipog_delete, [:pointer], :void
+  end
+end

data/lib/dither/version.rb

@@ -1,4 +1,4 @@
 
 module Dither
-  VERSION = '0.1.5'
+  VERSION = '0.2.0.rc3'
 end

data/lib/dither.rb

@@ -12,18 +12,73 @@ module Dither
   # deprecated
   def self.all_pairs(params, t = 2, opts = {})
     opts[:t] = t
-    IPOG.new(params, opts).run
+    ipog(params, opts)
   end
 
   def self.ipog(params, opts = {})
     opts = DEFUALT_OPTS.dup.merge(opts)
-    IPOG.new(params, opts).run
-  end
+    t = opts[:t] || 2
+    if t < 2
+      raise Dither::Error,'t must be >= 2'
+    end
+    raise Dither::Error, 'param length must be > 1' if params.any? { |a| a.size <= 1 }
+    if t > params.size
+      raise Dither::Error, 't must be <= params.length'
+    end
 
-  def self.mipog(params, t = 2, opts = {})
-    raise Error, 'mipog does not support constraints' if opts.key?(:constraints)
-    opts[:t] = t
-    MIPOG.new(params, opts).run
+    pointer = Dither::API.dither_ipog_new(t)
+    c_params = (0..params.max { |a| a.size }.size).to_a
+    c_int_params = FFI::MemoryPointer.new(:int, c_params.size)
+    c_int_params.write_array_of_int(c_params)
+
+    params.each_with_index do |param, i|
+      Dither::API.dither_ipog_add_parameter_int(pointer, i, c_int_params, param.size)
+    end
+
+    if opts[:constraints]
+      constraint_scratch = FFI::MemoryPointer.new(:int, params.size)
+      opts[:constraints].each do |constraint|
+        arr = Array.new(params.size, -1)
+        constraint.each do |k, v|
+          if k >= params.size
+            raise Dither::Error, "Invalid constraint #{k} > #{params.size}"
+          end
+          if v >= params[k].size
+            raise Dither::Error, "Invalid constraint #{k} > #{params[k].size}"
+
+          end
+          arr[k] = v
+        end
+        constraint_scratch.write_array_of_int(arr)
+        Dither::API.dither_ipog_add_constraint(pointer, constraint_scratch, params.size)
+      end
+    end
+
+    if opts[:previously_tested]
+      tested_scratch = FFI::MemoryPointer.new(:int, params.size)
+      opts[:previously_tested].each do |test_case|
+        if test_case.size != params.size
+          raise Dither::Error
+        end
+        arr = Array.new(params.size)
+        (0...params.size).each do |i|
+          arr[i] = params[i].find(test_case[i]).first
+        end
+        tested_scratch.write_array_of_int(arr)
+        Dither::API.dither_ipog_add_previously_tested(pointer, tested_scratch, params.size)
+      end
+    end
+
+    Dither::API.dither_ipog_run(pointer)
+    result_size = Dither::API.dither_ipog_size(pointer)
+    solution = FFI::MemoryPointer.new(:int, params.size * result_size)
+    Dither::API.dither_ipog_fill(pointer, solution)
+
+    results = solution.read_array_of_int(params.size * result_size)
+      .enum_for(:each_slice, params.size)
+      .map do |test_case|
+      test_case.zip(params).map { |a, b| b[a] }
+    end
   end
 
   def self.aetg(params, opts = {})
@@ -34,12 +89,6 @@ module Dither
   class << self; alias_method :ateg, :aetg end
 end # Dither
 
-require 'dither/param'
-require 'dither/unbound_param'
-require 'dither/test_case'
-require 'dither/ipog_helper'
-require 'dither/ipog'
-require 'dither/mipog'
 require 'dither/chinese_postman_problem'
 require 'dither/aetg'
 require 'dither/aetg_pairwise'
@@ -51,4 +100,6 @@ if RUBY_PLATFORM =~ /java/
   require 'dither-0.1.3.jar'
 
   require 'dither/java_ext/dither'
+else
+  require 'dither/api'
 end

data/spec/dither/dither_spec.rb

@@ -2,10 +2,6 @@ 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.ipog([], :t => 0) }.to raise_error(Dither::Error, 't must be >= 2')
   end
@@ -20,63 +16,15 @@ describe Dither do
 
   it 'can compute 2-way ipog using symbols' do
     params = [[:a, :b, :c], [:d, :e, :f], [:h, :i]]
-    expect(Dither.ipog(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],
-                                       ])
+    expect(Dither.all_pairs(params)).to eq([[:c, :f, :h],
+                                       [:b, :f, :i],
+                                       [:a, :f, :h],
+                                       [:c, :e, :i],
+                                       [:b, :e, :h],
+                                       [:a, :e, :i],
+                                       [:c, :d, :h],
+                                       [:b, :d, :i],
+                                       [:a, :d, :h]])
   end
 
   it 'can compute 2-way ipog' do
@@ -90,7 +38,7 @@ describe Dither do
                                              [1, 2],
                                              [0, 3],
                                              [1, 3],
-                                           ])
+    ].reverse)
   end
 
   it 'can compute 3-way ipog' do
@@ -116,54 +64,37 @@ 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,
+    results = Dither.ipog(params, :t => 3,
                        :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],
-                                       [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)
+                        :previously_tested => [[0, 0, 0]]
+                      )
+    results.each do |result|
+      expect(result[0] == 0 && result[1] == 1 && result[2] == 0).to be false
+    end
+    results.each do |result|
+      expect(result[0] == 0 && result[1] == 2).to be false
+    end
+    results.each do |result|
+      expect(result[0] == 0 && result[1] == 0 && result[2] == 0).to be false
+    end
   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.ipog(params, :t => 3,
+    results = Dither.ipog(params, :t => 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.each do |result|
+      expect(result[0] == 0 && result[1] == 1 && result[2] == 0).to be false
+    end
   end
 
   it 'can run 2-way aetg' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0.rc3
 platform: ruby
 authors:
 - Jason Gowan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-12-08 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: rake-compiler
+  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'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -52,11 +66,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Efficient test generation strategies
 email:
 - gowanjason@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/dither/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -68,18 +97,24 @@ files:
 - README.md
 - Rakefile
 - dither.gemspec
+- ext/dither/README.md
+- ext/dither/base_constraint_handler.h
+- ext/dither/combinations.h
+- ext/dither/dither.cc
+- ext/dither/dither.h
+- ext/dither/dither_types.h
+- ext/dither/extconf.rb
+- ext/dither/ipog.cc
+- ext/dither/ipog.h
+- ext/dither/simple_constraint_handler.cc
+- ext/dither/simple_constraint_handler.h
 - lib/dither.rb
 - lib/dither/aetg.rb
 - lib/dither/aetg_pairwise.rb
+- lib/dither/api.rb
 - lib/dither/chinese_postman_problem.rb
 - lib/dither/graph.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/chinese_postman_problem_spec.rb
 - spec/dither/dither_spec.rb
@@ -100,12 +135,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: dither
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Collection of test generation strategies

data/lib/dither/ipog.rb

@@ -1,58 +0,0 @@
-# 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

@@ -1,161 +0,0 @@
-# coding: utf-8
-
-module Dither
-  module IPOGHelper
-    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, (opts[:previously_tested] || []))
-      @t = opts[: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 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
-    end
-
-    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 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
-
-    # 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.reject { |a| tested?(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[a[0]][b] }) { |p, i| p.product((0...params[i].length).to_a.map { |c| params[i][c] }) }
-                 .map(&:flatten)
-                 .map { |b| TestCase.create(params, unbound_param_pool, b) }
-      end
-      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)
-      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)
-      return nil if tested?(data)
-
-      arr
-    end
-  end # IPOGHelper
-end # Dither