pairwise 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+tmp/
+pkg
+rdoc
+.#*
+coverage/

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2009 Joseph Wilk
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "pairwise"
+    gem.summary = %Q{Turn large test data combinations into smaller ones}
+    gem.description = %Q{A tool for selecting a smaller number of test combinations (using pairwise generation) rather than exhaustively testing all possible permutations.}
+    gem.email = "joe@josephwilk.net"
+    gem.homepage = "http://wiki.github.com/josephwilk/pairwise"
+    gem.authors = ["Joseph Wilk"]
+
+    gem.add_development_dependency 'rspec'
+    gem.add_development_dependency 'cucumber'
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Dir['gem_tasks/**/*.rake'].each { |rake| load rake }
+
+task :default => ["spec", "features"]

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:patch: 0
+:major: 0
+:minor: 1

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/features/generating_pairwise_data.feature

@@ -0,0 +1,80 @@
+Feature: Generating pairwise data
+  In order to test small, managable datasets while having confidence in test coverage
+  As a tester
+  I want a set of tests which is smaller than all the possible combinations of my specified inputs
+
+Scenario: No input file specified
+  When I run pairwise
+  Then I should see in the output
+  """
+  Usage: pairwise [options] FILE.yml
+  """
+
+Scenario: Ordered yaml inputs
+  Given I have the yaml file "inputs.yml" containing:
+    """
+    - event with image: [Football, Basketball, Soccer]
+    - event without image: [Football, Basketball, Soccer]
+    - media: [Image, Video, Music]
+    """
+  When I run pairwise inputs.yml
+  Then I should see the output
+    """
+    | event with image | event without image | media |
+    | Football         | Football            | Image |
+    | Football         | Basketball          | Video |
+    | Football         | Soccer              | Music |
+    | Basketball       | Football            | Music |
+    | Basketball       | Basketball          | Image |
+    | Basketball       | Soccer              | Video |
+    | Soccer           | Football            | Video |
+    | Soccer           | Basketball          | Music |
+    | Soccer           | Soccer              | Image |
+
+    """
+
+Scenario: Unorderd yaml inputs
+  Given I have the yaml file "inputs.yml" containing:
+    """
+    event with image: [Football, Basketball, Soccer]
+    event without image: [Football, Basketball, Soccer]
+    media: [Image, Video, Music]
+    """
+  When I run pairwise inputs.yml
+  Then I should see the output
+    """
+    | media | event without image | event with image |
+    | Image | Football            | Football         |
+    | Image | Basketball          | Basketball       |
+    | Image | Soccer              | Soccer           |
+    | Video | Football            | Soccer           |
+    | Video | Basketball          | Football         |
+    | Video | Soccer              | Basketball       |
+    | Music | Football            | Basketball       |
+    | Music | Basketball          | Soccer           |
+    | Music | Soccer              | Football         |
+
+    """
+
+Scenario: Not replacing wild cards
+  Given I have the yaml file "inputs.yml" containing:
+  """
+  - A: [A1, A2, A3]
+  - B: [B1, B2]
+  - C: [C1, C2, C3]
+  """
+  When I run pairwise inputs.yml --keep-wild-cards
+  Then I should see the output
+  """
+  | A  | B         | C  |
+  | A1 | B1        | C1 |
+  | A1 | B2        | C2 |
+  | A2 | B1        | C3 |
+  | A2 | B2        | C1 |
+  | A3 | B1        | C2 |
+  | A3 | B2        | C3 |
+  | A3 | wild_card | C1 |
+  | A2 | wild_card | C2 |
+  | A1 | wild_card | C3 |
+
+  """

data/features/step_definitions/pairwise_data_steps.rb

@@ -0,0 +1,15 @@
+Given /^I have the yaml file "([^\"]*)" containing:$/ do |file_name, file_contents|
+  create_file(file_name, file_contents)
+end
+
+When /^I run (.+)$/ do |command|
+  run(command)
+end
+
+Then /^I should see the output$/ do |text|
+  last_stdout.should == text
+end
+
+Then /^I should see in the output$/ do |string|
+  last_stdout.should include(string)
+end

data/features/support/env.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'tempfile'
+require 'spec/expectations'
+require "spec/mocks"
+require 'fileutils'
+require 'forwardable'
+
+SCRATCH_SPACE = 'tmp'
+
+class PairwiseWorld
+  extend Forwardable
+  def_delegators PairwiseWorld, :self_test_dir
+
+  def self.examples_dir(subdir=nil)
+    @examples_dir ||= File.expand_path(File.join(File.dirname(__FILE__), "../../#{SCRATCH_SPACE}"))
+    subdir ? File.join(@examples_dir, subdir) : @examples_dir
+  end
+
+  def self.self_test_dir
+    @self_test_dir ||= examples_dir
+  end
+
+  def pairwise_lib_dir
+    @pairwise_lib_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+  end
+
+  def initialize
+    @current_dir = self_test_dir
+  end
+
+  private
+  attr_reader :last_exit_status, :last_stderr
+
+  def last_stdout
+    @last_stdout
+  end
+  
+  def create_file(file_name, file_content)
+    in_current_dir do
+      FileUtils.mkdir_p(File.dirname(file_name)) unless File.directory?(File.dirname(file_name))
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+
+  def set_env_var(variable, value)
+    @original_env_vars ||= {}
+    @original_env_vars[variable] = ENV[variable] 
+    ENV[variable]  = value
+  end
+
+  def in_current_dir(&block)
+    Dir.chdir(@current_dir, &block)
+  end
+
+  def run(command)
+    stderr_file = Tempfile.new('pairwise')
+    stderr_file.close
+    in_current_dir do
+      IO.popen("../bin/#{command} 2> #{stderr_file.path}", 'r') do |io|
+        @last_stdout = io.read
+      end
+
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+  end
+end
+
+World do
+  PairwiseWorld.new
+end
+
+Before do
+  FileUtils.rm_rf SCRATCH_SPACE
+  FileUtils.mkdir SCRATCH_SPACE
+end

data/features/support/hooks.rb

@@ -0,0 +1,4 @@
+Before do
+  Kernel.stub!(:rand).and_return(0)
+end
+

data/gem_tasks/features.rake

@@ -0,0 +1,10 @@
+require 'cucumber'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new('features') do |t|
+  t.rcov = ENV['RCOV']
+end
+
+Cucumber::Rake::Task.new('pretty') do |t|
+  t.cucumber_opts = %w{--format pretty}
+end

data/gem_tasks/rspec.rake

@@ -0,0 +1,15 @@
+begin
+  require 'spec/expectations'
+  require 'spec/rake/spectask'
+
+  desc "Run RSpec"
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_opts = ['--options', "spec/spec.opts"]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = ENV['RCOV']
+    t.rcov_opts = %w{--exclude gems\/,spec\/}
+    t.verbose = true
+  end
+rescue LoadError
+  task :spec
+end

data/lib/pairwise.rb

@@ -0,0 +1,35 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'pairwise/test_pair'
+require 'pairwise/builder'
+require 'pairwise/formatter'
+require 'pairwise/cli'
+
+require 'yaml'
+
+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('.')
+
+  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
+    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/pairwise/builder.rb

@@ -0,0 +1,142 @@
+# 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 = {})
+      @inputs = inputs
+      @options = options
+    end
+
+    def build
+      input_lists = generate_pairs_between(@inputs[0], [@inputs[1]], 0)
+      @inputs.size > 2 ? in_parameter_order_generation(input_lists) : input_lists.map{|list| list.to_a}
+    end
+
+    private
+
+    def in_parameter_order_generation(input_lists)
+      @inputs[2..-1].each_with_index do |input_list, i|
+        i += 2
+        input_lists, pi = horizontal_growth(input_lists, input_list, @inputs[0..(i-1)])
+        input_lists = vertical_growth(input_lists, pi)
+      end
+      input_lists = replace_redundant_wild_cards(input_lists)
+      input_lists = replace_wild_cards(input_lists) unless @options[:keep_wild_cards]
+      input_lists
+    end
+
+    def horizontal_growth(input_lists, parameter_i, inputs)
+      pi = generate_pairs_between(parameter_i, inputs, inputs.size)
+
+      if input_lists.size <= parameter_i.size
+        input_lists = input_lists.enum_for(:each_with_index).map do |input_list, index_of_input_under_inspection|
+          extended_input_list = input_list + [parameter_i[index_of_input_under_inspection]]
+          pi = remove_pairs_covered_by(extended_input_list, pi)
+          extended_input_list
+        end
+      else
+        input_lists[0...parameter_i.size] = input_lists[0...parameter_i.size].enum_for(:each_with_index).map do |input_list, index_of_input_under_inspection|
+          extended_input_list = input_list + [parameter_i[index_of_input_under_inspection]]
+          pi = remove_pairs_covered_by(extended_input_list, pi)
+          extended_input_list
+        end
+
+        input_lists[parameter_i.size..-1] = input_lists[parameter_i.size..-1].map do |input_list|
+          extended_input_list = input_list_that_covers_most_pairs(input_list, parameter_i, pi)
+          pi = remove_pairs_covered_by(extended_input_list, pi)
+          extended_input_list
+        end
+      end
+
+      [input_lists, pi]
+    end
+
+    def vertical_growth(input_lists, pi)
+      new_input_lists = []
+
+      pi.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_lists)
+          new_input_lists[test_position] = uncovered_pair.replace_wild_card(new_input_lists[test_position])
+        else
+          new_input_lists << uncovered_pair.create_input_list
+        end
+      end
+
+      input_lists + new_input_lists
+    end
+
+    def replace_redundant_wild_cards(input_lists)
+      map_each_input_value(input_lists) do |input_value, index|
+        if input_value == WILD_CARD && @inputs[index].length == 1
+          @inputs[index][0]
+        else
+          input_value
+        end
+      end
+    end
+
+    def replace_wild_cards(input_lists)
+      map_each_input_value(input_lists) do |input_value, index|
+        if input_value == WILD_CARD
+          pick_random_value(@inputs[index])
+        else
+          input_value
+        end
+      end
+    end
+
+    def map_each_input_value(input_lists)
+      input_lists.map do |input_list|
+        input_list.enum_for(:each_with_index).map do |input_value, index|
+          yield input_value, index
+        end
+      end
+    end
+
+    def pick_random_value(input_list)
+      input_list[rand(input_list.size)]
+    end
+
+    def generate_pairs_between(parameter_i, input_lists, p_index)
+      pairs = []
+      parameter_i.each do |p|
+        input_lists.each_with_index do |input_list, q_index|
+          input_list.each do |q|
+            pairs << TestPair.new(p_index, q_index, p, q)
+          end
+        end
+      end
+      pairs
+    end
+
+    def remove_pairs_covered_by(extended_input_list, pi)
+      pi.reject{|pair| pair.covered_by?(extended_input_list)}
+    end
+
+    def input_list_that_covers_most_pairs(input_list, parameter_i, pi)
+      selected_input_list = nil
+      parameter_i.reduce(0) do |max_covered_count, value|
+        input_list_candidate = input_list + [value]
+        covered_count = pairs_covered_count(input_list_candidate, pi)
+        if covered_count >= max_covered_count
+          selected_input_list = input_list_candidate
+          covered_count
+        else
+          max_covered_count
+        end
+      end
+      selected_input_list
+    end
+
+    def pairs_covered_count(input_list, pairs)
+      pairs.reduce(0) do |covered_count, pair|
+        covered_count += 1 if pair.covered_by?(input_list)
+        covered_count
+      end
+    end
+  end
+end

data/lib/pairwise/cli.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+require 'optparse'
+module Pairwise
+  class Cli
+    class << self
+      def execute(args)
+        new(args).execute!
+      end
+    end
+
+    def initialize(args, out = STDOUT)
+      @args, @out = args, out
+      @formatter = Formatter::Cucumber.new(@out)
+      @options = defaults
+    end
+
+    def parse!
+      @args.extend(::OptionParser::Arguable)
+      @args.options do |opts|
+        opts.banner = ["Usage: pairwise [options] FILE.yml", "",
+        "Example:",
+            "pairwise data/inputs.yml", "", "",
+          ].join("\n")
+        opts.on("-k", "--keep-wild-cards") do
+          @options[:keep_wild_cards] = true
+        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!
+
+      @input_file = @args[0] unless @args.empty?
+    end
+
+    def execute!
+      parse!
+      exit_with_help if @input_file.nil? || @input_file.empty?
+      input_data, input_labels = *load_and_parse_input_file!
+
+      builder = Pairwise::Builder.new(input_data, @options)
+
+      @formatter.display(builder.build, input_labels)
+    end
+
+    private
+    def defaults
+      {:keep_wild_cards => false}
+    end
+
+    def exit_with_help
+      @out.puts @args.options.help
+      Kernel.exit(0)
+    end
+
+    def load_and_parse_input_file!
+      inputs = YAML.load_file(@input_file)
+      inputs = hash_inputs_to_list(inputs) if inputs.is_a?(Hash)
+
+      raw_inputs = inputs.map {|input| input.values[0]}
+      input_labels = input_names(inputs)
+
+      [raw_inputs, input_labels]
+    end
+
+    def hash_inputs_to_list(inputs_hash)
+      inputs_hash.map {|key, value| {key => value}}
+    end
+
+    def input_names(inputs)
+      inputs.map{|input| input.keys}.flatten
+    end
+
+  end
+end

data/lib/pairwise/formatter.rb

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

data/lib/pairwise/formatter/cucumber.rb

@@ -0,0 +1,40 @@
+module Pairwise
+  module Formatter
+    class Cucumber
+
+      def initialize(out)
+        @out = out
+        @max = {}
+      end
+
+      def display(test_data, inputs)
+        @test_data, @inputs = test_data, inputs
+
+        @out.print "|"
+        inputs.each_with_index do |key, column|
+          @out.print padded_string(key, 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 padded_string(string, column)
+        padding_length = max_line_length(column) - string.length
+        " #{string} " + (" " * padding_length)
+      end
+
+      def max_line_length(column)
+        @max[column] ||= ([@inputs[column].length] + @test_data.map{|data| data[column].length}).max
+      end
+
+    end
+  end
+end

data/lib/pairwise/test_pair.rb

@@ -0,0 +1,41 @@
+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)
+      test_pair[@p1_position] == @p1 &&
+      test_pair[@p2_position] == @p2
+    end
+
+    def create_input_list
+      new_input_list = Array.new(@p1_position){Builder::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_lists)
+      wild_card_list = input_lists.map do |input_list|
+        input_list[@p2_position] == Builder::WILD_CARD && input_list[@p1_position] == @p1
+      end
+      wild_card_list.rindex(true)
+    end
+
+  end
+end

data/spec/pairwise/builder_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../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.should == [[:C2, :A2], [:C2, :B1], [:C3, :A1], [:C3, :B2]]
+      end
+    end
+  end
+end

data/spec/pairwise/cli_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../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 "--help" do
+      it "displays usage" do
+        after_parsing('--help') do
+          output_stream.string.should =~ /Usage: pairwise \[options\] FILE\.yml/
+        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_spec.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/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 lenghts" 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, :C2],
+                                           [:A1, :B2, :C1],
+                                           [:A1, :B1, :C2],
+                                           [:A1, :B1, :C3],
+                                           [:A1, :B2, :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]]
+        #:A1, :B1, :C1, :D1
+        #:A1, :B1, :C2, :D2
+        #:A2, any_value_of_B, :C2, :D1
+        #:A2, :B1, :C1, :D2
+      end
+
+      it "should generate pairs for three paramters" do
+        data = [[:A1, :A2],
+                [: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]]
+      end
+    end
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format
+profile
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'spec'
+
+require File.dirname(__FILE__) + '/../lib/pairwise'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: pairwise
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Joseph Wilk
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-05 00:00:00 +00:00
+default_executable: pairwise
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A tool for selecting a smaller number of test combinations (using pairwise generation) rather than exhaustively testing all possible permutations.
+email: joe@josephwilk.net
+executables: 
+- pairwise
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- .gitignore
+- LICENSE
+- Rakefile
+- VERSION.yml
+- bin/pairwise
+- features/generating_pairwise_data.feature
+- features/step_definitions/pairwise_data_steps.rb
+- features/support/env.rb
+- features/support/hooks.rb
+- gem_tasks/features.rake
+- gem_tasks/rspec.rake
+- lib/pairwise.rb
+- lib/pairwise/builder.rb
+- lib/pairwise/cli.rb
+- lib/pairwise/formatter.rb
+- lib/pairwise/formatter/cucumber.rb
+- lib/pairwise/test_pair.rb
+- spec/pairwise/builder_spec.rb
+- spec/pairwise/cli_spec.rb
+- spec/pairwise_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://wiki.github.com/josephwilk/pairwise
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Turn large test data combinations into smaller ones
+test_files: 
+- spec/pairwise/builder_spec.rb
+- spec/pairwise/cli_spec.rb
+- spec/pairwise_spec.rb
+- spec/spec_helper.rb