pairwise 0.1.8 → 0.2.0

data/README.md

@@ -4,7 +4,7 @@ Pairwise
 [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/josephwilk/pairwise)
 [![Build Status](https://secure.travis-ci.org/josephwilk/pairwise.png)](http://travis-ci.org/josephwilk/pairwise)
 
-Documentation is at http://github.com/josephwilk/pairwise/wikis/home/
+How to use Pairwise: http://josephwilk.github.com/pairwise/
 
 Running tests
 ------------

data/lib/pairwise.rb

@@ -3,7 +3,9 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 require 'pairwise/test_pair'
 require 'pairwise/pair_collection'
-require 'pairwise/builder'
+require 'pairwise/ipo'
+require 'pairwise/ipo/horizontal'
+require 'pairwise/ipo/vertical'
 require 'pairwise/formatter'
 require 'pairwise/input_data'
 require 'pairwise/input_file'
@@ -17,13 +19,12 @@ end
 module Pairwise
   class InvalidInputData < Exception; end
 
-  version = YAML.load_file(File.dirname(__FILE__) + '/../VERSION.yml')
-  VERSION = [version[:major], version[:minor], version[:patch], version[:build]].compact.join('.')
+  VERSION = '0.2.0'
 
   class << self
     def combinations(*inputs)
       raise InvalidInputData, "Minimum of 2 inputs are required to generate pairwise test set" unless valid?(inputs)
-      Pairwise::Builder.new(inputs).build
+      Pairwise::IPO.new(inputs).build
     end
 
     private

data/lib/pairwise/cli.rb

@@ -58,7 +58,7 @@ module Pairwise
       validate_options!
 
       if inputs = InputFile.load(@filename_with_path)
-        builder = Pairwise::Builder.new(inputs.data, @options)
+        builder = Pairwise::IPO.new(inputs.data, @options)
 
         formatter.display(builder.build, inputs.labels)
       else

data/lib/pairwise/formatter/cucumber.rb

@@ -30,7 +30,7 @@ module Pairwise
       def label_wild_cards(test_data, labels)
         test_data.map do |data|
           data.enum_for(:each_with_index).map do |datum, column|
-            datum == Builder::WILD_CARD ? "any_value_of_#{labels[column]}" : datum
+            datum == IPO::WILD_CARD ? "any_value_of_#{labels[column]}" : datum
           end
         end
       end

data/lib/pairwise/ipo.rb

@@ -0,0 +1,63 @@
+# A pairwise implementation using the in-parameter-order (IPO) strategy.
+# Based on: http://ranger.uta.edu/~ylei/paper/ipo-tse.pdf
+module Pairwise
+  class IPO
+
+    WILD_CARD = 'wild_card'
+
+    def initialize(inputs, options = {})
+      @list_of_input_values = inputs
+      @options = options
+    end
+
+    def build
+      input_combinations = PairCollection.new(@list_of_input_values[0], [@list_of_input_values[1]], 0)
+      @list_of_input_values.size > 2 ? in_parameter_order_generation(input_combinations) : input_combinations.to_a
+    end
+
+    private
+
+    def in_parameter_order_generation(input_combinations)
+      @list_of_input_values[2..-1].each_with_index do |input_values, index|
+        index += 2
+        previously_grown_input_values = @list_of_input_values[0..(index-1)]
+        
+        input_combinations, uncovered_pairs = IPO::Horizontal.growth(input_combinations, input_values, previously_grown_input_values)
+        input_combinations = IPO::Vertical.growth(input_combinations, uncovered_pairs)
+      end
+      input_combinations = replace_wild_cards(input_combinations) unless @options[:keep_wild_cards]
+      input_combinations
+    end
+    
+    def replace_wild_cards(input_combinations)
+      map_wild_cards(input_combinations) do |_, index|
+        if @list_of_input_values[index].length == 1
+          @list_of_input_values[index][0]
+        else
+          pick_random_value(@list_of_input_values[index])
+        end
+      end
+    end
+    
+    def map_wild_cards(input_combinations)
+      input_combinations.map do |input_combination|
+        input_combination.enum_for(:each_with_index).map do |input_value, index|
+          input_value == WILD_CARD ? yield(index, index) : input_value
+        end
+      end
+    end
+
+    def map_each_input_value(input_combinations, &block)
+      input_combinations.map do |input_combination|
+        input_combination.enum_for(:each_with_index).map do |input_value, index|
+          yield input_value, index
+        end
+      end
+    end
+
+    def pick_random_value(input_combination)
+      input_combination[Kernel.rand(input_combination.size)]
+    end
+
+  end
+end

data/lib/pairwise/ipo/horizontal.rb

@@ -0,0 +1,27 @@
+module Pairwise
+  class IPO
+
+    class Horizontal
+      class << self
+
+        def growth(input_combinations, input_values_for_growth, previously_grown_input_values)
+          uncovered_pairs = PairCollection.new(input_values_for_growth, previously_grown_input_values, previously_grown_input_values.size)
+          input_combinations, uncovered_pairs = grow_input_combinations_and_remove_covered_pairs(input_combinations, input_values_for_growth, uncovered_pairs)
+          [input_combinations, uncovered_pairs]
+        end
+
+        private
+      
+        def grow_input_combinations_and_remove_covered_pairs(input_combinations, input_values_for_growth, uncovered_pairs)
+          input_combinations = input_combinations.enum_for(:each_with_index).map do |input_combination, input_index|
+            extended_input_combination = uncovered_pairs.input_combination_that_covers_most_pairs(input_combination, input_values_for_growth)
+            uncovered_pairs.remove_pairs_covered_by!(extended_input_combination)
+            extended_input_combination
+          end
+          [input_combinations, uncovered_pairs]
+        end
+      end
+      
+    end
+  end
+end

data/lib/pairwise/ipo/vertical.rb

@@ -0,0 +1,15 @@
+module Pairwise
+  class IPO
+    class Vertical
+
+      def self.growth(input_combinations, uncovered_pairs)
+        new_input_combinations = uncovered_pairs.reduce([]) do |new_input_combinations, uncovered_pair|
+          new_input_combinations = uncovered_pair.replace_wild_card(new_input_combinations)
+        end
+
+        input_combinations + new_input_combinations
+      end
+
+    end
+  end
+end

data/lib/pairwise/pair_collection.rb

@@ -3,6 +3,7 @@ module Pairwise
 
     def initialize(input_parameter_values, input_value_lists, input_parameter_index)
       pairs = generate_pairs_between(input_parameter_values, input_value_lists, input_parameter_index)
+      @combination_history = []
       super(pairs)
     end
 
@@ -12,9 +13,18 @@ module Pairwise
 
     def input_combination_that_covers_most_pairs(input_combination, input_values_for_growth)
       candidates = input_values_for_growth.map{|value| input_combination + [value]}
-      candidates.max {|combination_1, combination_2| pairs_covered_count(combination_1) <=> pairs_covered_count(combination_2)}
-    end
+      max_combination = candidates.max {|combination_1, combination_2| pairs_covered_count(combination_1) <=> pairs_covered_count(combination_2)}
+      possible_max_combinations = candidates.select{|combination| pairs_covered_count(max_combination) == pairs_covered_count(combination)}
 
+      winner = if possible_max_combinations.size > 1 && !@combination_history.empty?
+        find_most_different_combination(possible_max_combinations)
+      else
+        possible_max_combinations[0]
+      end
+      @combination_history << winner
+      winner
+    end
+  
     def to_a
       self.map{|list| list.to_a}
     end
@@ -39,5 +49,24 @@ module Pairwise
         covered_count
       end
     end
+    
+    def find_most_different_combination(options)
+      scores = options.map do |option|
+        score(option)
+      end.flatten
+
+      _, winner_index = *scores.each_with_index.max
+      options[winner_index]
+    end
+    
+    def score(option)
+      #O(n^2)
+      @combination_history.map do |previous_combination|
+        option.each_with_index.inject(0) do |difference_score, (value, index)|
+          value != previous_combination[index] ? difference_score : difference_score += 1
+        end
+      end.max
+    end
+    
   end
 end

data/lib/pairwise/test_pair.rb

@@ -13,26 +13,33 @@ module Pairwise
     end
 
     def covered_by?(test_pair)
+      debugger unless test_pair 
       test_pair[@p1_position] == @p1 &&
       test_pair[@p2_position] == @p2
     end
 
+    def replace_wild_card(new_input_combinations)
+      #TODO: Decided if we should replace all matches or single matches?
+      if wild_card_index = find_wild_card_index(new_input_combinations)
+        new_input_combinations[wild_card_index][@p2_position] = @p2
+      else
+        new_input_combinations << create_input_list
+      end
+      new_input_combinations
+    end
+
+    private
     def create_input_list
-      new_input_list = Array.new(@p1_position){Builder::WILD_CARD}
+      new_input_list = Array.new(@p1_position){IPO::WILD_CARD}
 
       new_input_list[@p1_position] = @p1
       new_input_list[@p2_position] = @p2
       new_input_list
     end
 
-    def replace_wild_card(input_list)
-      input_list[@p2_position] = @p2
-      input_list
-    end
-
-    def replaceable_wild_card?(input_combinations)
+    def find_wild_card_index(input_combinations)
       wild_card_list = input_combinations.map do |input_combination|
-        input_combination[@p2_position] == Builder::WILD_CARD && input_combination[@p1_position] == @p1
+        input_combination[@p2_position] == IPO::WILD_CARD && input_combination[@p1_position] == @p1
       end
       wild_card_list.rindex(true)
     end

data/spec/pairwise/ipo/horizontal_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Pairwise
+class IPO
+  
+  describe Horizontal do
+    describe ".growth" do
+      context "when the input_combinations size is smaller than the input values for growth size" do
+        it "should extenhd with C's inputs" do
+          input_combinations = [[:A1, :B1], [:A1, :B2]]
+          data               = [[:A1, :A2], [:C1, :C2, :C3 ]]
+        
+          test_set, _ = Horizontal.growth(input_combinations, data[1], data[0..1])
+          
+          test_set.should == [[:A1, :B1, :C1], [:A1, :B2, :C3]]
+        end
+      end
+      
+      context "when the input_combinations size is larger than the input values for growth size" do
+        before(:each) do
+          @test_pairs = [[:A1, :B1], [:A1, :B2], [:A2, :B1], [:A2, :B2]]
+          @data       = [[:A1, :A2], [:B1, :B2], [:C1, :C2, :C3 ]]
+        end
+
+        it "should return pairs extended with C's inputs" do
+          test_set, _ = Horizontal.growth(@test_pairs, @data[2], @data[0..1])
+
+          test_set.should == [[:A1, :B1, :C1], [:A1, :B2, :C3], [:A2, :B1, :C3], [:A2, :B2, :C2]]
+        end
+
+        it "should return all the uncovered pairs" do
+          _, pi = Horizontal.growth(@test_pairs, @data[2], @data[0..1])
+
+          pi.to_a.should == [[:C1, :A2], [:C1, :B2], [:C2, :A1], [:C2, :B1]]
+        end
+      
+      end
+    end
+  end
+
+end
+end

data/spec/pairwise/ipo_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module Pairwise
+  describe IPO do
+
+  end
+end

data/spec/pairwise_spec.rb

@@ -70,12 +70,7 @@ describe Pairwise do
       it "should generate all pairs for 3 parameters of 1,2,3 values" do
         data = [[:A1], [:B1, :B2], [:C1, :C2, :C3]]
 
-        Pairwise.combinations(*data).should == [[:A1, :B1, :C1],
-                                           [:A1, :B2, :C2],
-                                           [:A1, :B2, :C1],
-                                           [:A1, :B1, :C2],
-                                           [:A1, :B1, :C3],
-                                           [:A1, :B2, :C3]]
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1], [:A1, :B2, :C3], [:A1, :B2, :C1], [:A1, :B1, :C2], [:A1, :B2, :C2], [:A1, :B1, :C3]]
       end
 
       it "should generate all pairs for 3 parameters of 2,1,2 values" do
@@ -96,11 +91,7 @@ describe Pairwise do
       it "should generate all pairs for 4 parameters of 2,1,2,2 values" do
         data = [[:A1, :A2], [:B1], [:C1, :C2], [:D1, :D2]]
 
-        Pairwise.combinations(*data).should == [[:A1, :B1, :C1, :D1], 
-                                                [:A2, :B1, :C2, :D2], 
-                                                [:A2, :B1, :C1, :D1], 
-                                                [:A1, :B1, :C2, :D1], 
-                                                [:A1, :B1, :C1, :D2]]
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1, :D1], [:A2, :B1, :C2, :D2], [:A2, :B1, :C1, :D2], [:A1, :B1, :C2, :D2], [:A2, :B1, :C2, :D1]]
       end
 
       it "should generate pairs for three parameters" do
@@ -108,27 +99,22 @@ describe Pairwise do
                 [:B1, :B2],
                 [:C1 , :C2 , :C3 ]]
 
-        Pairwise.combinations(*data).should == [[:A1, :B1, :C1],
-                                           [:A1, :B2, :C2],
-                                           [:A2, :B1, :C3],
-                                           [:A2, :B2, :C1],
-                                           [:A2, :B1, :C2],
-                                           [:A1, :B2, :C3]]
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1], [:A1, :B2, :C3], [:A2, :B1, :C3], [:A2, :B2, :C2], [:A2, :B2, :C1], [:A1, :B1, :C2]]
       end
 
       describe "replacing wildcards which could have more than one option" do
         it "should generate pairs for 2 parameters of 3,2,3 values" do
           Pairwise.combinations([:A1, :A2, :A3],
                                 [:B1, :B2],
-                                [:C1, :C2, :C3]).should == [[:A1, :B1, :C1],
-                                                            [:A1, :B2, :C2],
-                                                            [:A2, :B1, :C3],
-                                                            [:A2, :B2, :C1],
-                                                            [:A3, :B1, :C2],
-                                                            [:A3, :B2, :C3],
-                                                            [:A3, :B1, :C1], #B1 is a wildcard replacement
-                                                            [:A2, :B1, :C2], #B1 is a wildcard replacement
-                                                            [:A1, :B1, :C3]] #B1 is a wildcard replacement
+                                [:C1, :C2, :C3]).should == [[:A1, :B1, :C1], 
+                                                            [:A1, :B2, :C3], 
+                                                            [:A2, :B1, :C3], 
+                                                            [:A2, :B2, :C2], 
+                                                            [:A3, :B1, :C2], 
+                                                            [:A3, :B2, :C1], 
+                                                            [:A2, :B1, :C1], 
+                                                            [:A1, :B1, :C2], 
+                                                            [:A3, :B1, :C3]]
         end
       end
     end

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
 require 'rubygems'
-require 'rspec'
+require 'bundler'
+Bundler.require(:test)
 
-require 'simplecov'
 SimpleCov.start
+SimpleCov.command_name 'unit_tests'
 
-require File.dirname(__FILE__) + '/../lib/pairwise'
+require File.dirname(__FILE__) + '/../lib/pairwise'

metadata

@@ -1,8 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: pairwise
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.1.8
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Joseph Wilk
@@ -10,16 +14,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-17 00:00:00 Z
+date: 2012-09-04 00:00:00 +01:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id001
@@ -27,10 +33,11 @@ dependencies:
   name: cucumber
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id002
@@ -44,21 +51,25 @@ extra_rdoc_files: []
 
 files: 
 - README.md
-- lib/pairwise/builder.rb
 - lib/pairwise/cli.rb
 - lib/pairwise/formatter/csv.rb
 - lib/pairwise/formatter/cucumber.rb
 - lib/pairwise/formatter.rb
 - lib/pairwise/input_data.rb
 - lib/pairwise/input_file.rb
+- lib/pairwise/ipo/horizontal.rb
+- lib/pairwise/ipo/vertical.rb
+- lib/pairwise/ipo.rb
 - lib/pairwise/pair_collection.rb
 - lib/pairwise/test_pair.rb
 - lib/pairwise.rb
-- spec/pairwise/builder_spec.rb
 - spec/pairwise/cli_spec.rb
+- spec/pairwise/ipo/horizontal_spec.rb
+- spec/pairwise/ipo_spec.rb
 - spec/pairwise/pair_collection_spec.rb
 - spec/pairwise_spec.rb
 - spec/spec_helper.rb
+has_rdoc: true
 homepage: http://wiki.github.com/josephwilk/pairwise
 licenses: []
 
@@ -68,21 +79,23 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Turn large test data combinations into smaller ones

data/lib/pairwise/builder.rb

@@ -1,108 +0,0 @@
-# A pairwise implementation using the in-parameter-order (IPO) strategy.
-# Based on: http://ranger.uta.edu/~ylei/paper/ipo-tse.pdf
-module Pairwise
-  class Builder
-
-    WILD_CARD = 'wild_card'
-
-    def initialize(inputs, options = {})
-      @list_of_input_values = inputs
-      @options = options
-    end
-
-    def build
-      input_combinations = PairCollection.new(@list_of_input_values[0], [@list_of_input_values[1]], 0)
-      @list_of_input_values.size > 2 ? in_parameter_order_generation(input_combinations) : input_combinations.to_a
-    end
-
-    private
-
-    def in_parameter_order_generation(input_combinations)
-      @list_of_input_values[2..-1].each_with_index do |input_values, i|
-        i += 2
-        input_combinations, uncovered_pairs = horizontal_growth(input_combinations, input_values, @list_of_input_values[0..(i-1)])
-        input_combinations = vertical_growth(input_combinations, uncovered_pairs)
-      end
-      input_combinations = replace_redundant_wild_cards(input_combinations)
-      input_combinations = replace_wild_cards(input_combinations) unless @options[:keep_wild_cards]
-      input_combinations
-    end
-
-    def horizontal_growth(input_combinations, input_values_for_growth, previously_grown_input_values)
-      uncovered_pairs = PairCollection.new(input_values_for_growth, previously_grown_input_values, previously_grown_input_values.size)
-
-      if input_combinations.size <= input_values_for_growth.size
-        input_combinations, uncovered_pairs = grow_input_combinations_and_remove_covered_pairs(input_combinations, input_values_for_growth, uncovered_pairs)
-      else
-        range_to_grow = 0...input_values_for_growth.size
-        input_combinations[range_to_grow], uncovered_pairs = grow_input_combinations_and_remove_covered_pairs(input_combinations[range_to_grow], input_values_for_growth, uncovered_pairs)
-
-        range_to_grow = input_values_for_growth.size..-1
-        input_combinations[range_to_grow] = input_combinations[range_to_grow].map do |input_combination|
-          extended_input_combination = uncovered_pairs.input_combination_that_covers_most_pairs(input_combination, input_values_for_growth)
-          uncovered_pairs.remove_pairs_covered_by!(extended_input_combination)
-          extended_input_combination
-        end
-      end
-
-      [input_combinations, uncovered_pairs]
-    end
-
-    def grow_input_combinations_and_remove_covered_pairs(input_combinations, input_values_for_growth, uncovered_pairs)
-      input_combinations = input_combinations.enum_for(:each_with_index).map do |input_combination, input_index|
-        extended_input_combination = input_combination + [input_values_for_growth[input_index]]
-        uncovered_pairs.remove_pairs_covered_by!(extended_input_combination)
-        extended_input_combination
-      end
-      [input_combinations, uncovered_pairs]
-    end
-        
-    def vertical_growth(input_combinations, uncovered_pairs)
-      new_input_combinations = []
-
-      uncovered_pairs.each do |uncovered_pair|
-        #TODO: Decided if we should replace all matches or single matches?
-        if test_position = uncovered_pair.replaceable_wild_card?(new_input_combinations)
-          new_input_combinations[test_position] = uncovered_pair.replace_wild_card(new_input_combinations[test_position])
-        else
-          new_input_combinations << uncovered_pair.create_input_list
-        end
-      end
-
-      input_combinations + new_input_combinations
-    end
-
-    def replace_redundant_wild_cards(input_combinations)
-      map_each_input_value(input_combinations) do |input_value, index|
-        if input_value == WILD_CARD && @list_of_input_values[index].length == 1
-          @list_of_input_values[index][0]
-        else
-          input_value
-        end
-      end
-    end
-
-    def replace_wild_cards(input_combinations)
-      map_each_input_value(input_combinations) do |input_value, index|
-        if input_value == WILD_CARD
-          pick_random_value(@list_of_input_values[index])
-        else
-          input_value
-        end
-      end
-    end
-
-    def map_each_input_value(input_combinations)
-      input_combinations.map do |input_combination|
-        input_combination.enum_for(:each_with_index).map do |input_value, index|
-          yield input_value, index
-        end
-      end
-    end
-
-    def pick_random_value(input_combination)
-      input_combination[Kernel.rand(input_combination.size)]
-    end
-
-  end
-end

data/spec/pairwise/builder_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-module Pairwise
-  describe Builder do
-
-    describe 'ipo horizontal growth' do
-      before(:each) do
-        @test_pairs = [[:A1, :B1], [:A1, :B2], [:A2, :B1], [:A2, :B2]]
-        @data = [[:A1, :A2],[:B1, :B2],[:C1 , :C2 , :C3 ]]
-
-        @builder = Builder.new(@test_pairs)
-      end
-
-      it "should return pairs extended with C's inputs" do
-        test_set, _ = @builder.send(:horizontal_growth, @test_pairs, @data[2], @data[0..1])
-
-        test_set.should == [[:A1, :B1, :C1],
-                            [:A1, :B2, :C2],
-                            [:A2, :B1, :C3],
-                            [:A2, :B2, :C1]]
-      end
-
-      it "should return all the uncovered pairs" do
-        _, pi = @builder.send(:horizontal_growth, @test_pairs, @data[2], @data[0..1])
-
-        # We are getting the uncovered pairs in reverse
-        #pi.should == [[:A2, :C2],[:A1, :C3],[:B1, :C2],[:B2, :C3]]
-        # Cheat and check we get the list in reverse
-        pi.to_a.should == [[:C2, :A2], [:C2, :B1], [:C3, :A1], [:C3, :B2]]
-      end
-    end
-  end
-end