pairwise_psych 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3235ee705e199c82b95973eecb55348db8f8092
+  data.tar.gz: 0f69362bfa95968b1c87bccc462cef0168d792df
+SHA512:
+  metadata.gz: 1dd0513ecc088ec79b1dcd49d14513f582d77a2549659c3e091ff2b674d04389e6b01943527e70fc318c80407f660ed21b52a86a6b67a790ae6419a8d46ece72
+  data.tar.gz: af9493453403096987d4f4b0837fe3f672f0a6d34b7743c9dcf5b3409a16eb881912211e10b14a095d2f4b375ad0871d48a1ae124b49071faeb8fb989382b12b

data/README.md

@@ -0,0 +1,34 @@
+Pairwise
+-------
+
+Pairwise is a Ruby based tool for selecting a smaller number of test input combinations (using pairwise generation) 
+rather than exhaustively testing all possible permutations.
+
+Created by Joseph Wilks, updated by Ali King for newer Rubies
+
+How to use Pairwise: http://josephwilk.github.com/pairwise/
+
+Newer Rubies and Syck vs Psych
+-----------
+Syck and Psych are YAML serialization libraries. Historically Ruby used syck, now Psych is the default. There are a 
+couple of differences between the two, which are better described here :- http://devblog.arnebrasseur.net/2014-02-yaml-syck-vs-psych
+
+This fork from the original pairwise just removes a directive to use syck and adds some tests for multibyte characters 
+which may have been interpreted differently by the different libraries. 
+
+Also adds unicode-display_width gem to help with formatting - multibyte characters are tricksy.
+
+Tested on ruby 1.8.7-p374 and 2.0.0-p353 as a sampling, but this should be future-proof. 
+
+
+Running tests
+------------
+<pre><code>rake</code></pre
+
+
+
+Copyright
+--------
+
+See LICENSE for details.
+

data/bin/pairwise

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
+require 'pairwise'
+require 'pairwise/cli'
+
+Pairwise::Cli.execute(ARGV)

data/lib/pairwise/cli.rb

@@ -0,0 +1,92 @@
+require 'optparse'
+
+module Pairwise
+  class Cli
+    BUILTIN_FORMATS = {
+      'cucumber' => [Pairwise::Formatter::Cucumber,
+                     'Tables for Cucumber'],
+      'csv'      => [Pairwise::Formatter::Csv,
+                     'Comma seperated values']}
+
+    max = BUILTIN_FORMATS.keys.map{|s| s.length}.max
+    FORMAT_HELP = (BUILTIN_FORMATS.keys.sort.map do |key|
+      "  #{key}#{' ' * (max - key.length)} : #{BUILTIN_FORMATS[key][1]}"
+    end)
+
+    class << self
+      def execute(args)
+        new(args).execute!
+      end
+    end
+
+    def initialize(args, out = STDOUT)
+      @args, @out = args, out
+      @options = defaults
+    end
+
+    def parse!
+      @args.extend(::OptionParser::Arguable)
+      @args.options do |opts|
+        opts.banner = ["Usage: pairwise [options] FILE.[yml|csv]", "",
+        "Example:",
+            "pairwise data/inputs.yml", "", "",
+          ].join("\n")
+        opts.on("-k", "--keep-wild-cards",
+        "Don't automatically replace any wild-cards which appear",
+        "in the pairwise data") do
+          @options[:keep_wild_cards] = true
+        end
+        opts.on('-f FORMAT', '--format FORMAT',
+        "How to format pairwise data (Default: cucumber). Available formats:",
+        *FORMAT_HELP) do |format|
+          @options[:format] = format
+        end
+        opts.on_tail("--version", "Show version.") do
+          @out.puts Pairwise::VERSION
+          Kernel.exit(0)
+        end
+        opts.on_tail("-h", "--help", "You're looking at it.") do
+          exit_with_help
+        end
+      end.parse!
+
+      @filename_with_path = @args[0] unless @args.empty?
+    end
+
+    def execute!
+      parse!
+      validate_options!
+
+      if inputs = InputFile.load(@filename_with_path)
+        builder = Pairwise::IPO.new(inputs.data, @options)
+
+        formatter.display(builder.build, inputs.labels)
+      else
+        puts "Error: '#{@filename_with_path}' does not contain the right structure for me to generate the pairwise set!"
+      end
+    end
+
+    private
+    def defaults
+      { :keep_wild_cards => false,
+        :format => 'cucumber' }
+    end
+
+    def validate_options!
+      exit_with_help if @filename_with_path.nil? || @filename_with_path.empty?
+      raise Errno::ENOENT, @filename_with_path  unless File.exist?(@filename_with_path)
+      exit_with_help unless File.file?(@filename_with_path)
+    end
+
+    def exit_with_help
+      @out.puts @args.options.help
+      Kernel.exit(0)
+    end
+
+    def formatter
+      format = BUILTIN_FORMATS[@options[:format]][0]
+      format.new(@out)
+    end
+
+  end
+end

data/lib/pairwise/formatter/csv.rb

@@ -0,0 +1,17 @@
+module Pairwise
+  module Formatter
+    class Csv
+
+      def initialize(out)
+        @out = out
+      end
+
+      def display(test_data, input_labels)
+        @out.puts input_labels.join(',')
+        test_data.each do |data|
+          @out.puts data.join(',')
+        end
+      end
+    end
+  end
+end

data/lib/pairwise/formatter/cucumber.rb

@@ -0,0 +1,52 @@
+require 'unicode/display_width'
+
+module Pairwise
+  module Formatter
+    class Cucumber
+
+      def initialize(out)
+        @out = out
+        @max = {}
+      end
+
+      def display(test_data, input_labels)
+        @test_data = label_wild_cards(test_data, input_labels)
+        @input_labels = input_labels
+
+        @out.print "|"
+        @input_labels.each_with_index do |label, column|
+          @out.print padded_string(label, column) + "|"
+        end
+        @out.puts
+
+        @test_data.each do |data|
+          @out.print "|"
+          data.each_with_index do |datum, column|
+            @out.print padded_string(datum, column) + "|"
+          end
+          @out.puts
+        end
+      end
+
+      private
+      def label_wild_cards(test_data, labels)
+        test_data.map do |data|
+          data.enum_for(:each_with_index).map do |datum, column|
+            datum == IPO::WILD_CARD ? "any_value_of_#{labels[column]}" : datum
+          end
+        end
+      end
+
+      def padded_string(string, column)
+        string = string.to_s unless string.is_a? String
+        padding_length = max_line_length(column) - string.display_width
+        " #{string} " + (" " * padding_length)
+      end
+
+      def max_line_length(column)
+        @max[column] ||= ([@input_labels[column].to_s.length] + @test_data.map{|data| data[column].to_s.length}).max
+      end
+
+    end
+  end
+end

data/lib/pairwise/formatter.rb

@@ -0,0 +1 @@
+%w[cucumber csv].each {|file| require "pairwise/formatter/#{file}"}

data/lib/pairwise/input_data.rb

@@ -0,0 +1,25 @@
+module Pairwise
+  class InputData
+
+    def initialize(inputs)
+      @inputs = inputs.is_a?(Hash) ? hash_inputs_to_list(inputs) : inputs
+    end
+
+    def data
+      @data ||= @inputs.map {|input| input.values[0]}
+    end
+
+    def labels
+      @labels ||= @inputs.map{|input| input.keys}.flatten
+    end
+
+    private
+
+    def hash_inputs_to_list(inputs_hash)
+      inputs_hash.sort.map do |key, value|
+        value = [value] unless value.is_a?(Array)
+        {key => value}
+      end
+    end
+  end
+end

data/lib/pairwise/input_file.rb

@@ -0,0 +1,62 @@
+module Pairwise
+  class InputFile
+
+    class << self
+      def load(filename)
+        inputs = self.new(filename).load_and_parse
+        InputData.new(inputs) if valid?(inputs)
+      end
+
+      def valid?(inputs)
+        inputs && (inputs.is_a?(Array) || inputs.is_a?(Hash))
+      end
+    end
+
+    def initialize(filename)
+      @filename = filename
+      self.extend(input_file_module)
+    end
+
+    private
+
+    def input_file_module
+      type = @filename[/\.(.+)$/, 1]
+      raise "Cannot determine file type for: #{@filename}" unless type
+      case type.downcase
+      when 'yaml', 'yml' then Yaml
+      else
+        Pairwise.const_get(type.capitalize) rescue raise "Unsupported file type: #{type}"
+      end
+    end
+
+  end
+
+  module Yaml
+    def load_and_parse
+      require 'yaml'
+      begin
+        inputs = YAML.load_file(@filename)
+      rescue
+        nil
+      end
+    end
+  end
+
+  module Csv
+    def load_and_parse
+      require 'csv'
+
+      csv_data = CSV.read @filename
+      headers = csv_data.shift.map {|head| head.to_s.strip }
+      string_data = csv_data.map {|row| row.map {|cell| cell.to_s.strip } }
+
+      inputs = Hash.new {|h,k| h[k] = []}
+
+      string_data.each do |row|
+        row.each_with_index { |value, index| inputs[headers[index]] << value }
+      end
+
+      inputs
+    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/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/pair_collection.rb

@@ -0,0 +1,72 @@
+module Pairwise
+  class PairCollection < Array
+
+    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
+
+    def remove_pairs_covered_by!(extended_input_list)
+      self.reject!{|pair| pair.covered_by?(extended_input_list)}
+    end
+
+    def input_combination_that_covers_most_pairs(input_combination, input_values_for_growth)
+      candidates = input_values_for_growth.map{|value| input_combination + [value]}
+      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
+
+    private
+    
+    def generate_pairs_between(input_parameter_values, input_value_lists, input_parameter_index)
+      pairs = []
+      input_parameter_values.each do |input_value_a|
+        input_value_lists.each_with_index do |input_list, input_value_b_index|
+          input_list.each do |input_value_b|
+            pairs << TestPair.new(input_parameter_index, input_value_b_index, input_value_a, input_value_b)
+          end
+        end
+      end
+      pairs
+    end
+
+    def pairs_covered_count(input_combination)
+      self.reduce(0) do |covered_count, pair|
+        covered_count += 1 if pair.covered_by?(input_combination)
+        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

@@ -0,0 +1,48 @@
+require 'forwardable'
+
+module Pairwise
+  class TestPair
+    extend Forwardable
+
+    def_delegators :@pair, :+, :inspect, :to_a, :==
+
+    def initialize(p1_position, p2_position, p1, p2)
+      @p1, @p2 = p1, p2
+      @p1_position, @p2_position = p1_position, p2_position
+      @pair = [@p1, @p2]
+    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){IPO::WILD_CARD}
+
+      new_input_list[@p1_position] = @p1
+      new_input_list[@p2_position] = @p2
+      new_input_list
+    end
+
+    def find_wild_card_index(input_combinations)
+      wild_card_list = input_combinations.map do |input_combination|
+        input_combination[@p2_position] == IPO::WILD_CARD && input_combination[@p1_position] == @p1
+      end
+      wild_card_list.rindex(true)
+    end
+
+  end
+end

data/lib/pairwise.rb

@@ -0,0 +1,40 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'pairwise/test_pair'
+require 'pairwise/pair_collection'
+require 'pairwise/ipo'
+require 'pairwise/ipo/horizontal'
+require 'pairwise/ipo/vertical'
+require 'pairwise/formatter'
+require 'pairwise/input_data'
+require 'pairwise/input_file'
+require 'pairwise/cli'
+
+require 'yaml'
+
+
+module Pairwise
+  class InvalidInputData < Exception; end
+
+  VERSION = '0.2.2'
+
+  class << self
+    def combinations(*inputs)
+      raise InvalidInputData, "Minimum of 2 inputs are required to generate pairwise test set" unless valid?(inputs)
+      Pairwise::IPO.new(inputs).build
+    end
+
+    private
+    def valid?(inputs)
+      array_of_arrays?(inputs) &&
+        inputs.length >= 2 &&
+        !inputs[0].empty? && !inputs[1].empty?
+    end
+
+    def array_of_arrays?(data)
+      data.reject{|datum| datum.kind_of?(Array)}.empty?
+    end
+
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Pairwise
+  VERSION = '0.2.3'
+end

data/spec/pairwise/cli_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module Pairwise
+  describe Cli do
+
+    before(:each) do
+      Kernel.stub!(:exit).and_return(nil)
+    end
+
+    def output_stream
+      @output_stream ||= StringIO.new
+    end
+
+    def options
+      #TODO: push options out to an object and avoid hacking at private instance vars
+      @cli.instance_variable_get("@options")
+    end
+
+    def prepare_args(args)
+      args.is_a?(Array) ? args : args.split(' ')
+    end
+
+    def after_parsing(args)
+      @cli = Pairwise::Cli.new(prepare_args(args), output_stream)
+      @cli.parse!
+      yield
+    end
+
+   context '--keep-wild-cards' do
+      it "displays wild cards in output result" do
+        after_parsing('--keep-wild-cards') do
+          options[:keep_wild_cards].should == true
+        end
+      end
+    end
+
+    context '-f FORMAT or --format FORMAT' do
+      it "defaults to the cucumber format for output" do
+        after_parsing('') do
+          options[:format].should == 'cucumber'
+        end
+      end
+
+      it "overides the cucumber format when passed a specific format" do
+        after_parsing('--format csv') do
+          options[:format].should == 'csv'
+        end
+      end
+    end
+
+    context "--help" do
+      it "displays usage" do
+        after_parsing('--help') do
+          output_stream.string.should =~ /Usage: pairwise \[options\] FILE\.\[yml|csv\]/
+        end
+      end
+    end
+
+    context '--version' do
+      it "displays Pairwise's version" do
+        after_parsing('--version') do
+          output_stream.string.should =~ /#{Pairwise::VERSION}/
+        end
+      end
+    end
+
+  end
+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/pair_collection_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Pairwise
+  describe PairCollection do
+    describe '#input_combination_that_covers_most_pairs' do
+      it "should do find the combination that covers most pairs" do
+        pair_collection = PairCollection.new([:A2, :B2], [[:A2, :B2], [:B2, :A1]], 1)
+
+        combination = pair_collection.input_combination_that_covers_most_pairs([:A2, :B2], [:C2, :A1])
+        
+        combination.should == [:A2, :B2, :C2]
+      end
+    end
+  end
+end

data/spec/pairwise_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Pairwise do
+  before(:each) do
+    Kernel.stub!(:rand).and_return(0)
+  end
+
+  context "with invalid inputs" do
+    it "should be invalid when running with no input" do
+      lambda{ Pairwise.combinations([]) }.should raise_error(Pairwise::InvalidInputData)
+    end
+
+    it "should be invalid when running with only 1 input" do
+      lambda{ Pairwise.combinations([:A1, :A2])}.should raise_error(Pairwise::InvalidInputData)
+    end
+
+    it "should be invalid when running with a single list input" do
+      lambda{ Pairwise.combinations([:A1, :A2])}.should raise_error(Pairwise::InvalidInputData)
+    end
+  end
+
+  context "with valid inputs" do
+    context "which are equal lengths" do
+      it "should generate pairs for 2 parameters of 1 value" do
+        data = [[:A1], [:B1]]
+
+        Pairwise.combinations(*data).should == [[:A1, :B1]]
+      end
+
+      it "should generate all pairs for 2 parameters of 2 values" do
+        data = [[:A1, :A2], [:B1, :B2]]
+
+        Pairwise.combinations(*data).should == [[:A1, :B1], [:A1, :B2], [:A2, :B1], [:A2, :B2]]
+      end
+
+      it "should generate all pairs for 3 parameters of 1 value" do
+        data = [[:A1], [:B1], [:C1]]
+
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1]]
+      end
+
+      it "should generate pairs for three paramters" do
+        data = [[:A1, :A2],
+                [:B1, :B2],
+                [:C1 , :C2]]
+
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1],
+                                           [:A1, :B2, :C2],
+                                           [:A2, :B1, :C2],
+                                           [:A2, :B2, :C1]]
+      end
+    end
+
+    context "which are unequal lengths" do
+      it "should generate all pairs for 3 parameters of 1,1,2 values" do
+        data = [[:A1], [:B1], [:C1, :C2]]
+
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1],
+                                           [:A1, :B1, :C2]]
+      end
+
+      it "should generate all pairs for 3 parameters of 1,1,3 values" do
+        data = [[:A1], [:B1], [:C1, :C2, :C3]]
+
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1],
+                                           [:A1, :B1, :C2],
+                                           [:A1, :B1, :C3]]
+      end
+
+      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, :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
+        data = [[:A1, :A2], [:B1], [:C1, :C2]]
+
+        Pairwise.combinations(*data).should == [[:A1, :B1, :C1],
+                                           [:A2, :B1, :C2],
+                                           [:A2, :B1, :C1],
+                                           [:A1, :B1, :C2]]
+
+
+        #:A1, :B1, :C1
+        #:A1, :B1, :C2
+        #:A2, :B1, :C1
+        #:A2,any_value_of_B, :C2
+      end
+
+      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, :D2], [:A1, :B1, :C2, :D2], [:A2, :B1, :C2, :D1]]
+      end
+
+      it "should generate pairs for three parameters" do
+        data = [[:A1, :A2],
+                [:B1, :B2],
+                [:C1 , :C2 , :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, :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
+
+  end
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: pairwise_psych
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+platform: ruby
+authors:
+- Joseph Wilk
+- Ali King
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: unicode-display_width
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: cucumber
+  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'
+description: |-
+  A tool for selecting a smaller number of test combinations (using pairwise generation) rather than exhaustively testing all possible permutations.
+              To read about why, go here: http://www.pairwise.org/
+              This variation uses the newer psych yaml engine
+email: ali@animoto.com
+executables:
+- pairwise
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/pairwise
+- lib/pairwise.rb
+- lib/pairwise/cli.rb
+- lib/pairwise/formatter.rb
+- lib/pairwise/formatter/csv.rb
+- lib/pairwise/formatter/cucumber.rb
+- lib/pairwise/input_data.rb
+- lib/pairwise/input_file.rb
+- lib/pairwise/ipo.rb
+- lib/pairwise/ipo/horizontal.rb
+- lib/pairwise/ipo/vertical.rb
+- lib/pairwise/pair_collection.rb
+- lib/pairwise/test_pair.rb
+- lib/version.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
+homepage: https://aliking.github.io/pairwise/
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Turn large test data combinations into smaller ones
+test_files: []
+has_rdoc: