dither 0.1.5-java → 0.2.0-java

data/ext/dither/simple_constraint_handler.h

@@ -0,0 +1,39 @@
+/*
+ *
+ * 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;
+      std::vector<dval> scratch;
+
+      inline bool violate_constraint(const dtest_case& test_case, const std::vector<std::pair<std::size_t, dval>>& constraint);
+      inline bool violate_constraints_(const dtest_case &test_case);
+
+    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,21 @@
+
+require 'ffi'
+
+# Interface to the c++ api.
+module Dither
+  module API
+    extend FFI::Library
+    LIB_DIR = File.expand_path('../..', __FILE__)
+    ffi_lib %W[#{LIB_DIR}/dither.so #{LIB_DIR}/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'
 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_index(test_case[i])
+        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'
@@ -48,7 +97,9 @@ require 'dither/graph'
 if RUBY_PLATFORM =~ /java/
   require 'java'
   require 'choco-solver-3.3.1-with-dependencies.jar'
-  require 'dither-0.1.3.jar'
+  require 'dither-0.1.4.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
@@ -115,55 +63,38 @@ describe Dither do
   end
 
   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,
+    params = [[:a, :b], (0...2).to_a, (0..3).to_a]
+    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 => [[:a, 0, 0]]
+                      )
+    results.each do |result|
+      expect(result[0] == :a && result[1] == 1 && result[2] == 0).to be false
+    end
+    results.each do |result|
+      expect(result[0] == :a && result[1] == 2).to be false
+    end
+    results.each do |result|
+      expect(result[0] == :a && 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,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: dither
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: java
 authors:
 - Jason Gowan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
   name: rspec
@@ -21,13 +21,13 @@ dependencies:
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.2
   name: rake
@@ -35,13 +35,27 @@ dependencies:
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.2
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake-compiler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   name: coveralls
@@ -49,7 +63,7 @@ dependencies:
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Efficient test generation strategies
@@ -59,34 +73,40 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .ruby-version
-- .travis.yml
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - 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/choco-solver-3.3.1-with-dependencies.jar
+- lib/dither-0.1.4.jar
 - 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
 - spec/dither/graph_spec.rb
 - spec/spec_helper.rb
-- lib/dither-0.1.3.jar
-- lib/choco-solver-3.3.1-with-dependencies.jar
 homepage: https://github.com/jesg/dither
 licenses:
 - MIT
@@ -97,17 +117,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: dither
-rubygems_version: 2.1.9
+rubygems_version: 2.4.8
 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