IPOAlgorithm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab7632425eddb21f2030c19dfaca5f7f83957d62
+  data.tar.gz: 242b2c3342e31338d7a4797cf22767f6d6a684f2
+SHA512:
+  metadata.gz: b3d92e4fe19edda9ef2137f717c4cf3dd000aaadb27c75a0ee4d952569bd8ef98239c63954fd26efd33378ecb3150711ae37147b3706f06a5c23b14e272ad0a7
+  data.tar.gz: 2a672ea546523b5e2e622c47e3bcda38cc1171e4f3d601a5f39cfb52b175098bd464bc0f1ad83c1218b50f96dfc97c70fc0e31c557b3d346c2f983419ab85c59

data/bin/IPOAlgorithm.rb

@@ -0,0 +1,21 @@
+require_relative '../lib/IPOAlgorithm.rb'
+
+#
+#Exception handling for the arguments passed to the algorithm
+#
+
+#The algorithm raises an error if the number of arguments is not 2
+raise ArgumentError, "The IPO algorithm needs at least 2 arguments and a maximum of 4." unless 2 <= ARGV.size && ARGV.size <=4
+
+#The first argument must be an integer indicating the number of factors/parameters
+raise ArgumentError, "The first parameter must be an Integer i s.t. 2 <= i <= 26 indicating the number of factors." unless (no_parameters = Integer(ARGV.first)) && no_parameters >= 2 && no_parameters < 27
+
+#The second argument must be an array that is matched against a regular expression to see if it is of the correct form
+raise ArgumentError, "The second parameter must be an array of form [val1, val2, ... valn] where each vali indicates the number of levels for factor i and n is the number of factors already specified as the first parameter to the algorithm." unless /\[(\d+,)+\d+\]/.match ARGV[1]
+
+#The 'levels' array will contain the number of values (levels) for each parameter 
+levels = eval ARGV[1]
+raise ArgumentError, "The second parameter must be an array of form [val1, val2, ... valn] where each vali indicates the number of levels for factor i and n is the number of factors already specified as the first parameter to the algorithm." if levels.size != no_parameters
+
+puts IPOAlgorithm.new(no_parameters, levels,ARGV[2],ARGV[3]).output_table
+

data/lib/IPOAlgorithm.rb

@@ -0,0 +1,393 @@
+
+require 'terminal-table'
+require 'csv'
+
+class IPOAlgorithm
+
+	attr_reader :no_parameters
+	attr_reader :levels
+	attr_reader :parameters
+	attr_reader :runs
+	attr_reader :actual_parameters
+	attr_reader :infeasible_pairs
+	attr_reader :output_table
+	def initialize(no_parameters,levels,csv=nil,infeasible_csv=nil)
+		#
+		#preliminary checks of the arguments passed to the algorithm and initialization of the '@no_parameters' instance_variable 
+		#
+		raise ArgumentError, "The number of parameters passed as an argument must be an Integer." unless no_parameters.is_a? Integer
+		@no_parameters = no_parameters
+		raise ArgumentError, "The IPOAlgorithm can process at most 26 parameters (at least 2 parameters must be provided)" if @no_parameters >26 || @no_parameters < 2
+		raise ArgumentError, "The number of parameters doesn't match the size of the array argument representing the number of levels for each parameter." unless levels.size == @no_parameters
+		raise ArgumentError, "The number of levels for each argument must be an Integer." unless levels.all? {|l| l.is_a? Integer}
+
+		
+		#initialization of the remaining instance_variables 
+		@levels = levels
+		@runs = Array.new
+		@parameters = Array.new
+		@infeasible_pairs = Array.new
+
+		#to differentiate values of different factors, each factor is named with uppercase letters in the range [A-Z]; thus the number of factors is limited to a maximum of 26 factors 
+		0.upto(@no_parameters-1) do |i| 
+			@parameters << Parameter.new((65 + i).chr, @levels[i])
+		end
+
+		#
+		#reads the parameters and relative values from the csv file passed as an argument and checks if the number of factors and relative levels correspond to the specified values
+		#if a .csv file containing the infeasible pairs is passed parses this file in order to check if the specified levels are valid and represents these values by means of the format used by the internal logic of the algorithm 
+		unless csv.nil?
+			@actual_parameters = Array.new
+			#parses the .csv file containing the factors and relative levels and saves the values in a tabular format
+			read_parameters_from_csv(csv) 
+			#performs checks for inconsistencies
+			raise ArgumentError, "The number of factors in the CSV file doesn't correspond to the specified value" unless @actual_parameters.size == @parameters.size
+			@actual_parameters.each_with_index {|t,i| raise ArgumentError, "The number of levels doesn't correspond to the specified values" unless t.size - 1  == @levels[i]}
+			#in case an additional file for the infeasible pairs is passed parses this file
+			unless infeasible_csv.nil?
+				#reads the infeasible pairs and stores them in the '@infeasible_pairs' instance variable
+				read_infeasible_pairs(infeasible_csv)
+
+				@infeasible_pairs.each_with_index do |p,i|
+					#checks if the levels belonging to the pair exist and saves the 'a1', 'b3', ... internal representation using temporary variables
+					temp1 = find_value p.first
+					temp2 = find_value p.last
+
+					#raises ArgumentError if the levels weren't specified in the factors' .csv file
+					raise ArgumentError,"#{p.first} level specified in the #{infeasible_csv} file doesn't belong to any parameter in the #{csv} file" if temp1.nil?
+					raise ArgumentError,"#{p.last} level specified in the #{infeasible_csv} file doesn't belong to any parameter in the #{csv} file" if temp2.nil?
+					#overwrites the levels using the internal representation
+					@infeasible_pairs[i] = [temp1,temp2]
+					#orders the levels in alphabetically ascending order
+					@infeasible_pairs[i].sort_by {|p| p}
+
+				end
+			end
+		end
+
+		#generate all pairs of the first two parameters F1 and F2 and add them to the runs 
+
+		@parameters[0].values.each do |value1|
+			@parameters[1].values.each do |value2|
+				@runs << (Run.new.elements << value1 << value2)
+			end
+		end
+
+		#removes the infeasible pairs
+		@runs -= @infeasible_pairs
+		
+
+		#possible termination if there are 2 factors
+		return nil if no_parameters == 2
+
+		#given that there are more than 2 factors there's need to repeat the next steps for all the remaining factors
+		2.upto(no_parameters-1) do |current_F|
+			#replace all runs with an extended version containing an appropriate value of the current parameter; keep track of the uncovered pairs
+			temp = horizontal_growth(current_F)
+			@runs = temp[:runs]
+			uncovered_pairs = temp[:uncovered_pairs]
+
+			#if there aren't any uncovered pairs end the current step else apply the vertical growth procedure
+			@runs += vertical_growth(uncovered_pairs,current_F) unless uncovered_pairs.empty?
+		end
+		
+		#displays the runs obtained by the algorithm in a generic form and, if a .csv file was provided, with real values
+		format_output_without_CSV if csv.nil?
+		format_output_with_CSV unless csv.nil?
+		self	
+	end
+	
+	private
+
+	def horizontal_growth(f)
+
+		#calculate all the pairs formed by the values of already processed factors and those of the current factor
+		ap = Array.new
+		0.upto(f-1) {|i| ap += pairs(i,f)}
+
+		#removes the infeasible pairs
+
+		ap -= @infeasible_pairs
+
+		#calculate the minimum between the number of tests already obtained and the number of levels of the current factor
+		c = [@parameters[f].no_levels, @runs.size].min
+
+		#the runs already obtained are extended with values of the current factor; the pairs contained by the runs thus extended, are removed from the ap (all pairs) set; given the fact that values of the factor can give rise to infeasible pairs the original IPO algorithm is thus modified:
+		#for each run an attempt is made to extend the run with a different level of the factor under observation; the first level which hasn't been already used and that doesn't form infeasible pairs with the values contained by the run is added to the run; the 'loop_counter' variable serves as a flag to indicate if such a value is available; if it reaches 2 then it means that all the values have been examined and there isn't such a level
+		#an already used level is used to extend the run; if all levels give rise to unfeasible pairs an error is raised indicating that the input to the algorithm cannot produce valid runs
+
+		#saves the already used levels in order to minimize the number of tests
+		already_used_level = []
+		tPrime = Array.new
+		0.upto(c-1) do |i|
+			#the evaluation of levels of the current factor under observation starts at a specific index in accordance with the original IPO Algorithm, so that a minimal set of runs is obtained
+			j=i
+			loop_counter=0
+			loop do
+				#attempt to extend the run with the next level of the factor
+				temp = ext(@runs[i].dup,@parameters[f].values[j])
+				#if it doesn't form infeasible pairs and it hasn't been already used the run is extended with this level
+				if (!pairs_for_run(temp).any? {|t| @infeasible_pairs.include? t} && !already_used_level.include?(j))
+					tPrime << temp
+					already_used_level << j
+					break
+				end
+				#the parsing of the levels of the factor restarts with the first level in a circular fashion; the loop_counter flag is increased
+				if j==@parameters[f].no_levels-1
+					j=0
+					loop_counter+=1
+				else
+					#increases the index that points at the next level of the factor
+					j+=1
+				end
+				#if the domain of the factor has been parsed and no valid level was encountered stop the search
+				break if loop_counter == 2
+			end
+			#search an already used level to extend the run in a similar fashion to the steps commented above; this time raise an error if no such level is found meaning that there is no valid run that respects the contraints of infeasible pairs
+			j=i
+			loop_counter_2 = 0
+			if loop_counter==2
+				loop do 
+					temp = ext(@runs[i].dup,@parameters[f].values[j])
+					if (!pairs_for_run(temp).any? {|t| @infeasible_pairs.include? t})
+						tPrime << temp
+						break
+					end
+					if j==@parameters[f].no_levels-1
+						j=0
+						loop_counter_2+=1
+					else
+						j+=1
+					end
+					loop_counter_2
+					raise ArgumentError,"The input provided doesn't allow the creation of valid runs(raised in horizontal_growth)" if loop_counter_2 == 2
+				end
+			end
+
+			#remove the covered pairs by the run produced
+			ap -= pairs_for_run(tPrime[i])
+		end
+
+		#if the minimum is the preexistent number of runs than the method return the extended runs
+		return {runs: tPrime, uncovered_pairs: ap} if c == @runs.size 
+
+		#
+		#otherwise extend the remaining runs by values of the current factor under observation that cover the maximum number of pairs in ap
+		#
+
+		valuePrime = nil
+		apPrime = []
+		
+		#scan every run already produced
+		c.upto(@runs.size-1) do |j|
+			apSecond = []
+			#for every value of the current factor under observation
+			@parameters[f].values.each_with_index do |value,index|
+				#extend the run with the value
+				tempa = ext(@runs[j].dup,value)
+				#check if any infeasible pairs have been obtained
+				unless pairs_for_run(tempa).any? {|p| @infeasible_pairs.include? p}
+					#calculate the pairs contained by the run thus obtained
+					apSecond = pairs_for_run(tempa)
+					#find the value that adds the maximum pairwise coverage 
+					if apSecond.find_all {|e| ap.include? e}.size > apPrime.find_all {|e| ap.include? e}.size
+						apPrime = apSecond
+						valuePrime = value
+					end
+				end
+				raise ArgumentError,"The input provided doesn't allow the creation of valid runs(raised in horizontal_growth)" if apSecond.nil? && index == @parameters[f].no_levels-1 
+			end
+			#extend the run with the value found in the previous step
+			tPrime << ext(@runs[j].dup,valuePrime)
+			#remove the pairs covered by the newly extended run
+			ap -= apPrime
+		end
+		{runs: tPrime, uncovered_pairs: ap}
+	end
+
+	#
+	#permits to extend a run with a value 
+	#
+	def ext(run, val)
+		run << val
+	end
+
+	#
+	#given the indexes for two parameters produces the cartesian product of their respective values
+	#
+	def pairs(f1, f2)
+		temp = Array.new
+		@parameters[f1].values.each do |value1|
+			@parameters[f2].values.each do |value2|
+				temp << (Run.new.elements << value1 << value2)
+			end
+		end
+		temp			
+	end
+	
+	#
+	#produces all the pairs of values given a run 
+	#
+	def pairs_for_run(run)
+		temp = Array.new
+		0.upto(run.size-2) do |index1|
+			(index1+1).upto(run.size-1) do |index2|
+				temp << ([] << run[index1] << run[index2])
+			end
+		end
+		temp
+	end
+
+	#
+	#Vertical Growth procedure to produce additional runs that cover the remaining uncovered pairs
+	#
+	def vertical_growth(uncovered_pairs,current_F)
+		current_F = current_F
+		tPrime = []
+		#scan every run
+		uncovered_pairs.each do |u_pair|
+			#calculate the index of the factor whose value doesn't form any pair with the factor under observation within the preexistent runs 
+			uncovered_F = u_pair[0][0].ord - 97
+			#use the flag to indicate if the pair has been covered
+			flag = false
+			#scan every preexistent run
+			@runs.each do |run|
+				#if the run contains a placeholder to indicate the absence of a value where a value of the factor with index uncovered_F should be, overwrite the placeholder with the uncovered value
+				temp = run.dup
+				temp[uncovered_F] = u_pair[0]
+				if run[uncovered_F].nil? && !pairs_for_run(temp).any? {|p| @infeasible_pairs.include? p}
+					run[uncovered_F] = u_pair[0]
+					#indicate that the pair is covered and break the loop
+					flag = true
+					break
+				end
+			end
+
+			#if no placeholder was found create a new run
+			if !flag
+				temp = []
+				0.upto(current_F-1) do |j|
+					#use placeholders for values belonging to factors different from the one whose value isn't covered (uncovered_F)
+					if j != uncovered_F
+						temp << nil
+					#save the value needing coverage  
+					else
+						temp << u_pair[0]
+					end 
+				end
+				#append the second value of the uncovered pair, that belongs to the factor under observation (current_F)
+				temp << u_pair[1]
+				#add the run obtained to the set of runs
+				tPrime << temp 
+			end
+		end	
+		#
+		#replace each placeholder with a value of the corresponding factor selected in random fashion but respecting the constraints on infeasible pairs
+		#
+		#for each run obtained in the previous step
+		tPrime.each do |run|
+			#for each level of the run
+			run.each_with_index do |val,index|
+				#if the value is nil
+				if run[index].nil?
+					#create a copy of the run
+					temp = run.dup
+					#generate a random index in the range that goes from zero to the number of levels of the factor - 1
+					i = rand(0...@parameters[index].no_levels)
+					#store this index
+					j = i
+					loop do
+						#check if the level at index j is a valid one in the sense that doesn't form infeasible pairs
+						temp[index] = @parameters[index].values[j]
+						#if it's valid stop the search
+						break unless pairs_for_run(temp).any? {|p| @infeasible_pairs.include? p}
+						#tries next level
+						j+=1
+						#if it reaches the last level of the factor restart from the first level in a circular fashion
+						j = 0 if j == @parameters[index].no_levels
+						#if no level is valid raise an exception	
+						raise ArgumentError,"The input provided doesn't allow the creation of valid runs(raised in vertical_growth)" if j == i
+					end
+					#save the level thus obtained
+					run[index] = temp[index]
+				end
+			end
+		end
+		#return the runs obtained by the Vertical_Growth method
+		tPrime
+	end
+
+	#
+	#formats the runs obtained by the algorithm in a table with an appropriate structure
+	#
+	def format_output_without_CSV
+		headings = [] << "Run" 
+		rows = []
+		@parameters.each_with_index {|p,i| headings << "F#{i+1}"}
+		@runs.each_with_index {|r,i| temp = ["#{i+1}"]; temp += r; rows << temp}
+		@output_table = Terminal::Table.new :title => "IPO Algorithm tests output", :headings => headings, :rows => rows
+	end
+
+	#
+	#formats the runs obtained by the algorithm substituting real values passed by means of the .csv file
+	#
+
+	def format_output_with_CSV()
+		headings = [] << "Run" 
+		rows = []
+		@actual_parameters.each {|t| headings << t[0]}
+		@runs.each_with_index do |run,i| 
+			temp = ["#{i+1}"];
+			run.each_with_index do |r,i|
+				temp << @actual_parameters[i][Integer(run[i][1])]
+			end
+			rows << temp
+		end
+		@output_table = Terminal::Table.new :title => "IPO Algorithm tests output", :headings => headings, :rows => rows
+	end
+
+	#
+	#the procedure reads the .csv file and produces a tabular representation 
+	# 
+	def read_parameters_from_csv(csv)
+		begin
+			temp = CSV.read(csv)
+		rescue Exception
+			raise ArgumentError, "It wasn't possible to read from #{csv} file."
+		end
+		temp.each_with_index do |row,index|
+			@actual_parameters[index] = row[0].split(';')
+		end
+	end
+
+	#
+	#reads the infeasible pairs from the .csv file
+	#
+	def read_infeasible_pairs(infeasible_csv)
+		begin
+			temp = CSV.read(infeasible_csv)
+		rescue Exception
+			raise ArgumentError, "It wasn't possible to read from #{infeasible_csv} file."
+		end
+		temp.each_with_index do |row,index|
+			@infeasible_pairs[index] = row[0].split(';')
+		end
+		raise ArgumentError,"Every line of the .csv file containing infeasible pairs must contain exactly 2 elements" unless @infeasible_pairs.all? {|pair| pair.size == 2}
+	end
+
+	#permits to retrieve a level from the tabular representation of the .csv file of factors; if it exists the internal representation of the level is returned, consisting of a lowercase letter from a to z and an index 
+	def find_value(val)
+		temp = nil
+		@actual_parameters.each_with_index do |row,index|
+			row.each_with_index do |element, index1|
+				if (element.downcase.delete(' ') == val.downcase.delete(' ') && index1 != 0)
+					return (index + 97).chr + index1.to_s
+				end
+			end
+		end
+		return nil
+	end
+end
+
+require_relative 'IPOAlgorithm/Parameter'
+require_relative 'IPOAlgorithm/Run'

data/lib/IPOAlgorithm/Parameter.rb

@@ -0,0 +1,12 @@
+#the class 'Parameter' models a Factor/Parameter 
+class IPOAlgorithm::Parameter
+	attr_reader :name, :no_levels, :values
+
+	def initialize(name, levels)
+		@values = Array.new
+		@name = name
+		@no_levels = levels
+		#each value is represented using the lowercase version of the factor's name and an index subscript starting from 1 up to the number of levels of the factor 
+		1.upto(levels) {|i| values << name.downcase + i.to_s}
+	end 
+end

data/lib/IPOAlgorithm/Run.rb

@@ -0,0 +1,8 @@
+	class IPOAlgorithm::Run
+		attr_accessor :elements
+
+		def initialize
+			@elements = Array.new
+		end
+
+	end

data/test/incorrect_file.csv

@@ -0,0 +1,4 @@
+Hardware;Dell Dimension Series;Apple iMac;Apple MacBook Pro;;
+OS;Windows Server 2008: Web Edition;Windows Server 2008: R2 standard edition;Windows 7 Enterprise;OS 10.6;OS 10.7
+Browser;Internet Explorer 9;Internet Explorer;Chrome;Safari 5.1.6;Firefox
+AnotherFactor;f1;f2;;;

data/test/infeasible_pairs.csv

@@ -0,0 +1,20 @@
+Dell Dimension Series;OS 10.6
+Dell Dimension Series;OS 10.7
+Apple iMac;Windows Server 2008: Web Edition
+Apple iMac;Windows Server 2008: R2 standard edition
+Apple iMac;Windows 7 Enterprise
+Apple MacBook Pro;Windows Server 2008: Web Edition
+Apple MacBook Pro;Windows Server 2008: R2 standard edition
+Apple MacBook Pro;Windows 7 Enterprise
+Dell Dimension Series;Safari 5.1.6
+Apple iMac;Internet Explorer 9
+Apple iMac;Internet Explorer
+Apple MacBook Pro;Internet Explorer 9
+Apple MacBook Pro;Internet Explorer
+OS 10.6;Internet Explorer 9
+OS 10.6;Internet Explorer
+OS 10.7;Internet Explorer 9
+OS 10.7;Internet Explorer
+Windows Server 2008: Web Edition;Safari 5.1.6
+Windows Server 2008: R2 standard edition;Safari 5.1.6
+Windows 7 Enterprise;Safari 5.1.6

data/test/infeasible_pairs_impossible_combination_HG.csv

@@ -0,0 +1,6 @@
+Dell Dimension Series;OS 10.6
+Apple iMac;Windows 7 Enterprise
+OS 10.6;Internet Explorer 9
+Windows 7 Enterprise;Safari 5.1.6
+Ubuntu 16.04 LTS;Internet Explorer 9
+Ubuntu 16.04 LTS;Safari 5.1.6

data/test/infeasible_pairs_impossible_combination_VG.csv

@@ -0,0 +1,4 @@
+Dell Dimension Series;OS 10.6
+Apple iMac;Windows 7 Enterprise
+OS 10.6;Internet Explorer 9
+Windows 7 Enterprise;Safari 5.1.6

data/test/infeasible_pairs_not_all_pairs.csv

@@ -0,0 +1,20 @@
+Dell Dimension Series;OS 10.6
+Dell Dimension Series;OS 10.7
+Apple iMac;Windows Server 2008: Web Edition
+Apple iMac;Windows Server 2008: R2 standard edition
+Apple iMac;Windows 7 Enterprise
+Apple MacBook Pro;Windows Server 2008: Web Edition
+Apple MacBook Pro;Windows Server 2008: R2 standard edition
+Apple MacBook Pro;Windows 7 Enterprise
+Dell Dimension Series;Safari 5.1.6
+Apple iMac;Internet Explorer 9
+Apple iMac;
+Apple MacBook Pro;Internet Explorer 9
+Apple MacBook Pro;Internet Explorer
+OS 10.6;Internet Explorer 9
+OS 10.6;Internet Explorer
+OS 10.7;Internet Explorer 9
+OS 10.7;Internet Explorer
+Windows Server 2008: Web Edition;Safari 5.1.6
+Windows Server 2008: R2 standard edition;Safari 5.1.6
+Windows 7 Enterprise;Safari 5.1.6

data/test/infeasible_pairs_unspecified_level.csv

@@ -0,0 +1,20 @@
+Dell Dimension Series;OS 10.6
+Dell Dimension Series;OS 10.7
+Apple iMac;Windows Server 2008: Web Edition
+Apple iMac;Windows Server 2008: R2 standard edition
+Apple iMac;Windows 7 Enterprise
+Apple MacBook Pro;Windows Server 2008: Web Edition
+Apple MacBook Pro;Windows Server 2008: R2 standard edition
+Apple MacBook Pro;Windows 10 Enterprise
+Dell Dimension Series;Safari 5.1.6
+Apple iMac;Internet Explorer 9
+Apple iMac;Internet Explorer
+Apple MacBook Pro;Internet Explorer 9
+Apple MacBook Pro;Internet Explorer
+OS 10.6;Internet Explorer 9
+OS 10.6;Internet Explorer
+OS 10.7;Internet Explorer 9
+OS 10.7;Internet Explorer
+Windows Server 2008: Web Edition;Safari 5.1.6
+Windows Server 2008: R2 standard edition;Safari 5.1.6
+Windows 7 Enterprise;Safari 5.1.6

data/test/input_file.csv

@@ -0,0 +1,3 @@
+Hardware;Dell Dimension Series;Apple iMac;Apple MacBook Pro;;
+OS;Windows Server 2008: Web Edition;Windows Server 2008: R2 standard edition;Windows 7 Enterprise;OS 10.6;OS 10.7
+Browser;Internet Explorer 9;Internet Explorer;Chrome;Safari 5.1.6;Firefox

data/test/input_file_impossible_combination_HG.csv

@@ -0,0 +1,3 @@
+Hardware;Dell Dimension Series;Apple iMac
+OS;Windows 7 Enterprise;OS 10.6;Ubuntu 16.04 LTS
+Browser;Internet Explorer 9;Safari 5.1.6

data/test/input_file_impossible_combination_VG.csv

@@ -0,0 +1,3 @@
+Hardware;Dell Dimension Series;Apple iMac
+OS;Windows 7 Enterprise;OS 10.6
+Browser;Internet Explorer 9;Safari 5.1.6

data/test/test_IPOAlgorithm.rb

@@ -0,0 +1,120 @@
+require 'test/unit'
+require_relative '../lib/IPOAlgorithm.rb'
+
+#tests the response of the algorithm with only the first 2 arguments provided
+class TestIpoWithoutCSV < Test::Unit::TestCase
+
+	#it specifies the maximum number of parameters to be tested
+	def setup
+		@no_tests = 10
+	end
+
+	#tests if the algorithm spots invalid inputs
+	def test_invalid_number_of_parameters
+		assert_raise(ArgumentError.new("The number of parameters passed as an argument must be an Integer.")) {IPOAlgorithm.new(3.5,[3,5,5])}
+		assert_raise(ArgumentError.new("The IPOAlgorithm can process at most 26 parameters (at least 2 parameters must be provided)")) {IPOAlgorithm.new(27,[3,5,5])}
+		assert_raise(ArgumentError.new("The IPOAlgorithm can process at most 26 parameters (at least 2 parameters must be provided)")) {IPOAlgorithm.new(1,[3,5,5])}
+	end
+
+	#tests if the algorithm recognizes when the specified number of parameters doesn't correspond to the size of the array representing the levels for each parameter
+	def test_different_no_parameters
+		assert_raise(ArgumentError.new("The number of parameters doesn't match the size of the array argument representing the number of levels for each parameter.")) {IPOAlgorithm.new(3,[3,5,5,4])}
+	end
+
+	#tests if the algorithm recognizes when the specified number of levels for a parameter isn't a valid value
+	def test_invalid_levels
+		assert_raise(ArgumentError.new("The number of levels for each argument must be an Integer.")) {IPOAlgorithm.new(3,[3,5,"a"])}
+	end
+
+	#test if all the pairs have been covered; to do so the Kernel#eval method is used to create objects of IPO class dynamically and to test the pairwise coverage
+	def test_all_pairs_covered
+		puts "\n"
+		2.upto(@no_tests) do |no_factors|
+			levels="["
+			1.upto(no_factors) {|factor| levels += rand(2...10 ).to_s + ","}
+			levels[levels.size-1] = "]"
+			declaration = "@ipo_#{no_factors}_factors = IPOAlgorithm.new(#{no_factors}, #{levels})" 
+			puts declaration + " ----->I'm testing #{no_factors} factors"
+			eval declaration
+			eval "assert_not_nil @ipo_#{no_factors}_factors"
+			eval "assert_equal @ipo_#{no_factors}_factors.class, IPOAlgorithm"
+			eval "assert all_pairs_covered @ipo_#{no_factors}_factors"
+
+		end
+	end
+
+	#method that given an IPO object outputs a boolean value indicating the pairwise coverage
+	def all_pairs_covered(ipo)
+		all_pairs = []
+		0.upto(ipo.no_parameters-2) do |index1|
+			(index1+1).upto(ipo.no_parameters-1) do |index2|
+				all_pairs += ipo.instance_eval {pairs(index1,index2)}
+			end
+		end
+		ipo.runs.each {|r| all_pairs -= ipo.instance_eval{pairs_for_run(r)}}
+		(all_pairs-ipo.infeasible_pairs).empty?
+	end	
+end
+
+#tests the algorithm response with the first two mandatory arguments and the third optional one containing the path to the .csv file with the actual values of the parameters; the pairwise coverage isn't tested because it is the same as for the TestIpoWithoutCSV tests.
+class TestIpoWithCSV < Test::Unit::TestCase
+
+	#tests if the .csv file has been correctly read and the tabular representation created
+	def setup
+		@path = File.expand_path File.dirname(__FILE__)
+	end	
+	def test_table_created
+		@ipo = IPOAlgorithm.new(3,[3,5,5],"#{@path}/input_file.csv")
+		assert_not_nil @ipo.actual_parameters
+	end
+
+	#tests if the algorithm spots invalid .csv files
+	def test_invalid_file
+		assert_raise(ArgumentError.new("It wasn't possible to read from #{@path}/invalid_file.csv file.")) {IPOAlgorithm.new(3,[3,5,5],"#{@path}/invalid_file.csv")}
+	end
+
+	#test if the algorithm recognizes a discrepancy between the values of the first two arguments and the values contained within the .csv file
+	def test_incorrect_csv
+		assert_raise(ArgumentError.new("The number of factors in the CSV file doesn't correspond to the specified value")) {IPOAlgorithm.new(3,[3,5,5],"#{@path}/incorrect_file.csv")}
+		assert_raise(ArgumentError.new("The number of levels doesn't correspond to the specified values")) {IPOAlgorithm.new(3,[3,4,5],"#{@path}/input_file.csv")}
+	end
+
+end
+
+#tests the algorithm response when all four arguments are provided
+class TestIpoWithCSVandInfeasiblePairs < Test::Unit::TestCase
+	def setup
+		@path = File.expand_path File.dirname(__FILE__)
+	end	
+
+	#tests if the algorithm recognizes invalid files for the infeasible pairs 
+	def test_invalid_file
+		assert_raise(ArgumentError.new("It wasn't possible to read from #{@path}/invalid_infeasible_file.csv file.")) {IPOAlgorithm.new(3,[3,5,5],"#{@path}/input_file.csv","#{@path}/invalid_infeasible_file.csv")}
+	end
+
+	#tests if the algorithm spots rows of the .csv file containing infeasible pairs with less or more than 2 values
+	def test_not_all_lines_are_pairs
+		assert_raise(ArgumentError.new("Every line of the .csv file containing infeasible pairs must contain exactly 2 elements")) {IPOAlgorithm.new(3,[3,5,5],"#{@path}/input_file.csv","#{@path}/infeasible_pairs_not_all_pairs.csv")}
+	end
+
+	#tests if the algorithm recognizes values specified by the .csv file containing infeasible pairs that have not been declared by the .csv file containing the actual values of the paramenters 
+	def test_unspecified_level
+		assert_raise(ArgumentError.new("Windows 10 Enterprise level specified in the #{@path}/infeasible_pairs_unspecified_level.csv file doesn't belong to any parameter in the #{@path}/input_file.csv file")) {IPOAlgorithm.new(3,[3,5,5],"#{@path}/input_file.csv","#{@path}/infeasible_pairs_unspecified_level.csv")}
+	end
+
+	#tests if the algorithm spots infeasible pairs for which it is impossible to obtain valid runs; more precisely this impossibility is spotted within the Vertical Growth step of the algorithm.
+	def test_impossible_combination_VG
+		assert_raise(ArgumentError.new("The input provided doesn't allow the creation of valid runs(raised in vertical_growth)")) {IPOAlgorithm.new(3,[2,2,2],"#{@path}/input_file_impossible_combination_VG.csv","#{@path}/infeasible_pairs_impossible_combination_VG.csv")}
+	end
+
+	#tests if the algorithm spots infeasible pairs for which it is impossible to obtain valid runs; more precisely this impossibility is spotted within the Horizontal Growth step of the algorithm.
+	def test_impossible_combination_HG
+		assert_raise(ArgumentError.new("The input provided doesn't allow the creation of valid runs(raised in horizontal_growth)")) {IPOAlgorithm.new(3,[2,3,2],"#{@path}/input_file_impossible_combination_HG.csv","#{@path}/infeasible_pairs_impossible_combination_HG.csv")}
+	end
+
+	#test if indeed no infeasible pair has been covered
+	def test_no_infeasible_pair_covered
+		assert TestIpoWithoutCSV.new(5).all_pairs_covered(IPOAlgorithm.new(3,[3,5,5],"#{@path}/input_file.csv","#{@path}/infeasible_pairs.csv"))
+	end
+end
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: IPOAlgorithm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mihai Soldan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+description: IPO (In-Parameter-Order) procedure for the generation of mixed level
+  covering arrays with constraints of infeasible pairs.
+email: catalinmihai.soldan@studenti.unicam.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/IPOAlgorithm.rb
+- lib/IPOAlgorithm.rb
+- lib/IPOAlgorithm/Parameter.rb
+- lib/IPOAlgorithm/Run.rb
+- test/incorrect_file.csv
+- test/infeasible_pairs.csv
+- test/infeasible_pairs_impossible_combination_HG.csv
+- test/infeasible_pairs_impossible_combination_VG.csv
+- test/infeasible_pairs_not_all_pairs.csv
+- test/infeasible_pairs_unspecified_level.csv
+- test/input_file.csv
+- test/input_file_impossible_combination_HG.csv
+- test/input_file_impossible_combination_VG.csv
+- test/test_IPOAlgorithm.rb
+homepage: http://rubygems.org/gems/IPOAlgorithm
+licenses:
+- GNU GPLv3
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: IPO procedure
+test_files:
+- test/test_IPOAlgorithm.rb