/// <summary>
/// Removes the expression objects from parameters, equivalence classes, and expected results.
/// </summary>
private bool ClearExpressions()
{
bool compositeResult = true;
if ((InputParameters != null) && InputParameters.Any())
{
foreach (InputParameter parameter in InputParameters.Values)
{
parameter.ConditionExpression = null;
if ((parameter.EquivalenceClasses != null) && parameter.EquivalenceClasses.Any())
{
foreach (EquivalenceClass equivalenceClass in parameter.EquivalenceClasses.Values)
{
equivalenceClass.ConditionExpression = null;
}
}
}
}
if ((ExpectedResults != null) && ExpectedResults.Any())
{
foreach (ExpectedResult result in ExpectedResults.Values)
{
result.ConditionExpression = null;
}
}
return(compositeResult);
}
/// <summary>
/// Returns a list of the consumers enumerated in this object.
/// </summary>
/// <returns></returns>
public string ListOfConsumers()
{
IList <string> consumerLists = new List <string>();
if (InputParameters.Any())
{
consumerLists.Add($"input parameters = {string.Join(",", InputParameters)}");
}
if (EquivalenceClasses.Any())
{
consumerLists.Add($"equivalence classes = {string.Join(",", EquivalenceClasses)}");
}
if (ExpectedResults.Any())
{
consumerLists.Add($"expected results = {string.Join(",", ExpectedResults)}");
}
if (CoverageGroups.Any())
{
consumerLists.Add($"coverage groups = {string.Join(",", CoverageGroups)}");
}
if (!consumerLists.Any())
{
return(null);
}
return(string.Join(";", consumerLists));
}
/// <summary>
/// Validates the test specification and returns true if successful; otherwise false
/// and returns an informative error message.
/// </summary>
public bool Validate(IList <string> errors)
{
bool validated = true;
if ((InputParameters == null) || !InputParameters.Any())
{
errors.Add($"specification {Name} has no input parameters");
validated = false;
}
else
{
foreach (InputParameter parameter in InputParameters.Values)
{
validated = parameter.Validate(errors) && validated;
}
}
if ((ExpectedResults == null) || !ExpectedResults.Any())
{
errors.Add($"specification {Name} has no expected results");
validated = false;
}
else
{
foreach (ExpectedResult expectedResult in ExpectedResults.Values)
{
validated = expectedResult.Validate(errors) && validated;
}
}
if ((CoverageGroups == null) || !CoverageGroups.Any())
{
errors.Add($"specification {Name} has no coverage groups");
validated = false;
}
else
{
foreach (CoverageGroup coverageGroup in CoverageGroups)
{
validated = coverageGroup.Validate(errors) && validated;
}
}
return(validated && (errors.Count == 0));
}
/// <summary>
/// For the request, build the literals and/or instantiators to assign to each
/// property in the request shape for which sample data was supplied in the example.
/// </summary>
/// <returns>A list of strings of the form 'PropertyName = value' with comments at the
/// end, if present.</returns>
public IList <string> GetRequestAssignments(int currentIndent)
{
var result = new List <string>();
if (!InputParameters.Any())
{
return(result);
}
var last = InputParameters.Last().Key;
foreach (var param in InputParameters)
{
var member = Operation.RequestStructure.Members.GetMemberByName(param.Key);
if (null == member)
{
continue;
}
var sb = new StringBuilder();
var cb = new CodeBuilder(sb, currentIndent);
cb.Append(member.PropertyName).Append(" = ");
GetSampleLiteral(member, param.Value, cb);
if (param.Key != last)
{
cb.Append(",");
}
if (InputComments.ContainsKey(param.Key))
{
cb.Append(" // ").Append(InputComments[param.Key]);
}
result.Add(sb.ToString());
}
return(result);
}
/// <summary>
/// Parses strings containing expressions into recursive expression objects; returns true if successful.
/// </summary>
private bool NormalizeExpressions()
{
bool compositeResult = true;
if ((InputParameters != null) && InputParameters.Any())
{
foreach (InputParameter parameter in InputParameters.Values)
{
if (!parameter.ParseConditions())
{
compositeResult = false;
}
if ((parameter.EquivalenceClasses != null) && parameter.EquivalenceClasses.Any())
{
foreach (EquivalenceClass equivalenceClass in parameter.EquivalenceClasses.Values)
{
if (!equivalenceClass.ParseConditions())
{
compositeResult = false;
}
}
}
}
}
if ((ExpectedResults != null) && ExpectedResults.Any())
{
foreach (ExpectedResult result in ExpectedResults.Values)
{
if (!result.ParseConditions())
{
compositeResult = false;
}
}
}
return(compositeResult);
}
