/// <summary>
/// Creates and returns an assignment for a parameter in the coverage group
/// based on a specific combination that has not yet been covered in a test case.
/// </summary>
private bool AssignCoveredParameter(
IDictionary <string, ParameterAssignment> parameterAssignments,
TestSpecification testSpecification,
CoverageGroup coverageGroup,
IList <string> uncoveredCombination,
int groupIndex)
{
string selectedParameter = coverageGroup.Parameters[groupIndex];
string selectedEquivalenceClass = uncoveredCombination[groupIndex];
if ((selectedParameter == null) || (selectedEquivalenceClass == null))
{
return(false);
}
InputParameter inputParameter = testSpecification.InputParameters[selectedParameter];
if (inputParameter == null)
{
return(false);
}
ParameterAssignment parameterAssignment = new ParameterAssignment();
parameterAssignment.Set(
inputParameter.Given,
inputParameter.Name,
inputParameter.Text,
inputParameter.EquivalenceClasses[selectedEquivalenceClass]);
parameterAssignments.Add(parameterAssignment.Name, parameterAssignment);
return(true);
}
/// <summary>
/// Creates and returns an assignment for a parameter that is NOT in the coverage group
/// by randomly selecting one of its equivalence classes.
/// </summary>
private bool AssignUncoveredParameter(
IDictionary <string, ParameterAssignment> parameterAssignments,
InputParameter inputParameter)
{
IList <string> equivalenceClassNames = inputParameter.EquivalenceClasses.Keys.ToList();
if ((equivalenceClassNames == null) || !equivalenceClassNames.Any())
{
return(false);
}
int randomIndex = _random.Next(equivalenceClassNames.Count);
string selectedEquivalenceClass = equivalenceClassNames[randomIndex];
if (string.IsNullOrEmpty(selectedEquivalenceClass))
{
return(false);
}
ParameterAssignment parameterAssignment = new ParameterAssignment();
parameterAssignment.Set(
inputParameter.Given,
inputParameter.Name,
inputParameter.Text,
inputParameter.EquivalenceClasses[selectedEquivalenceClass]);
parameterAssignments.Add(parameterAssignment.Name, parameterAssignment);
return(true);
}
/// <summary>
/// Returns true if the parameter assignments match the constraints in the relational expression.
/// </summary>
public override bool Match(IDictionary <string, ParameterAssignment> parameterAssignments)
{
ParameterAssignment assignment = parameterAssignments[ParameterName];
switch (RelationalOperator)
{
case ExpressionParser.OperatorEqualAsName:
case ExpressionParser.OperatorEqualAsSymbol:
return(EquivalenceClassNames.Contains(assignment.SelectedEquivalenceClassName()));
case ExpressionParser.OperatorNotEqualAsName:
case ExpressionParser.OperatorNotEqualAsSymbol:
return(!EquivalenceClassNames.Contains(assignment.SelectedEquivalenceClassName()));
default:
if (EquivalenceClassNames.Count != 1)
{
return(false);
}
double expectedAsNumeric = ConvertToNumeric(EquivalenceClassNames[0]);
double assignedAsNumeric = ConvertToNumeric(assignment.SelectedEquivalenceClassName());
switch (RelationalOperator)
{
case ExpressionParser.OperatorLessAsName:
case ExpressionParser.OperatorLessAsSymbol:
return(assignedAsNumeric < expectedAsNumeric);
case ExpressionParser.OperatorLessEqualAsName:
case ExpressionParser.OperatorLessEqualAsSymbol:
return(assignedAsNumeric <= expectedAsNumeric);
case ExpressionParser.OperatorGreaterAsName:
case ExpressionParser.OperatorGreaterAsSymbol:
return(assignedAsNumeric > expectedAsNumeric);
case ExpressionParser.OperatorGreaterEqualAsName:
case ExpressionParser.OperatorGreaterEqualAsSymbol:
return(assignedAsNumeric >= expectedAsNumeric);
default:
return(false);
}
}
}
