protected override object[] Args(
IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] objParams = base.Args(datasetContext, testParameters, out tableParameters);
if (objParams.Length != 2)
{
throw new ArgumentException(string.Format("expected 2 parameter, got {0}",
objParams.Length));
}
if (objParams[0] is ITable == false)
{
throw new ArgumentException(string.Format("expected ITable, got {0}",
objParams[0].GetType()));
}
if (objParams[1] as IList <string> == null)
{
throw new ArgumentException(string.Format("expected IList<string>, got {0}",
objParams[1].GetType()));
}
var objects = new object[2];
IList <ConstraintNode> nodes =
HierarchicalConstraintUtils.GetConstraintHierarchy((IList <string>)objParams[1]);
objects[0] = objParams[0];
objects[1] = nodes;
return(objects);
}
protected virtual object[] Args(
[NotNull] IOpenDataset datasetContext,
[NotNull] IList <TestParameter> testParameters,
[NotNull] out List <TableConstraint> tableParameters)
{
return(GetConstructorArgs(datasetContext, testParameters, out tableParameters));
}
protected ITable CreateQueryTable([NotNull] IOpenDataset datasetContext,
[NotNull] string associationName,
[NotNull] IList <ITable> tables,
JoinType joinType)
{
return(CreateQueryTable(datasetContext, associationName, tables, joinType, null, out _));
}
protected bool TryGetArgumentValue(
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext,
[CanBeNull] out object value)
{
return(TryGetArgumentValue(parameter, datasetContext, null, out value));
}
protected override object[] Args(IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] constructorArguments =
base.Args(datasetContext, testParameters, out tableParameters);
Assert.AreEqual(1, constructorArguments.Length,
"unexpected constructor argument count");
var allArguments = new List <object>(3)
{
constructorArguments[0]
};
foreach (TestParameter parameter in testParameters)
{
if (parameter.IsConstructorParameter)
{
// constructor parameters are already in list
continue;
}
object value;
if (!TryGetArgumentValue(parameter, datasetContext, out value))
{
value = parameter.DefaultValue;
}
allArguments.Add(value);
}
return(allArguments.ToArray());
}
private IEnumerable <ITest> CreateTests(
[NotNull] IEnumerable <QualitySpecificationElement> qualitySpecificationElements,
[CanBeNull] IDatasetContext datasetContext,
out IDictionary <ITest, QualitySpecificationElement> qualityConditionsByTest)
{
var result = new List <ITest>();
qualityConditionsByTest = new Dictionary <ITest, QualitySpecificationElement>();
if (datasetContext == null)
{
return(result);
}
IOpenDataset datasetOpener = _openDatasetFactory(datasetContext);
foreach (QualitySpecificationElement element in qualitySpecificationElements)
{
QualityCondition condition = element.QualityCondition;
TestFactory factory = Assert.NotNull(
TestFactoryUtils.CreateTestFactory(condition),
$"Cannot create test factory for condition {condition.Name}");
foreach (ITest test in factory.CreateTests(datasetOpener))
{
result.Add(test);
qualityConditionsByTest.Add(test, element);
}
}
return(result);
}
private static ICollection <Dataset> GetMissingDatasets(
[NotNull] QualityCondition condition,
[NotNull] IOpenDataset datasetOpener,
[NotNull] ICollection <Dataset> knownMissingDatasets,
[NotNull] ICollection <Dataset> knownExistingDatasets)
{
var result = new List <Dataset>();
foreach (var dataset in condition.GetDatasetParameterValues())
{
if (knownExistingDatasets.Contains(dataset))
{
continue;
}
if (knownMissingDatasets.Contains(dataset))
{
result.Add(dataset);
continue;
}
if (ExistsDataset(dataset, datasetOpener))
{
knownExistingDatasets.Add(dataset);
}
else
{
knownMissingDatasets.Add(dataset);
result.Add(dataset);
}
}
return(result);
}
protected override object[] Args(IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] args = base.Args(datasetContext, testParameters, out tableParameters);
Assert.True(args.Length == 5, "expected 5 arguments, got {0}", args.Length);
Assert.True(args[0] is ITable, "arg0 is {0}, expected ITable", args[0].GetType());
Assert.True(args[1] is ITable, "arg1 is {0}, expected ITable", args[1].GetType());
Assert.True(args[2] is string, "arg2 is {0}, expected string", args[2].GetType());
Assert.True(args[3] is bool, "arg3 is {0}, expected boolean", args[3].GetType());
Assert.True(args[4] is string, "arg4 is {0}, expected string", args[4].GetType());
var testArgs = new object[2];
string filterExpression = tableParameters[1].FilterExpression;
tableParameters.RemoveAt(1);
var invertCondition = (bool)args[3];
testArgs[0] = args[0];
testArgs[1] = GetConstraints((ITable)args[1],
filterExpression,
(string)args[2],
args[4] as string,
invertCondition);
return(testArgs);
}
protected override object[] Args(IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] objParams = base.Args(datasetContext, testParameters, out tableParameters);
if (objParams.Length != 2)
{
throw new ArgumentException(string.Format("expected 2 parameter, got {0}",
objParams.Length));
}
if (objParams[0] is IFeatureClass[] == false)
{
throw new ArgumentException(string.Format("expected IFeatureClass[], got {0}",
objParams[0].GetType()));
}
if (objParams[1] is string[] == false)
{
throw new ArgumentException(string.Format("expected string[], got {0}",
objParams[1].GetType()));
}
var objects = new object[2];
objects[0] = objParams[0];
var featureClasses = (IFeatureClass[])objParams[0];
var ruleParts = (string[])objParams[1];
objects[0] = featureClasses;
objects[1] = GetRuleArrays(featureClasses, ruleParts);
return(objects);
}
protected object[] GetConstructorArgs(
[NotNull] IOpenDataset datasetContext,
[NotNull] IList <TestParameter> testParameters,
[NotNull] out List <TableConstraint> tableParameters)
{
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
Assert.ArgumentNotNull(testParameters, nameof(testParameters));
tableParameters = new List <TableConstraint>();
var constructorArgs = new List <object>(testParameters.Count);
// TODO refactor, clarify
foreach (TestParameter parameter in testParameters.Where(
p => p.IsConstructorParameter))
{
object value;
if (!TryGetArgumentValue(parameter, datasetContext, tableParameters,
out value))
{
// TODO test; if this can EVER occur: apply DefaultValue?
Assert.Fail("no argument value for test parameter {0}",
parameter.Name);
}
constructorArgs.Add(value);
}
return(constructorArgs.ToArray());
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlBasedQualitySpecificationFactory"/> class.
/// </summary>
/// <param name="modelFactory">The model builder.</param>
/// <param name="datasetOpener"></param>
public XmlBasedQualitySpecificationFactory(
[NotNull] IVerifiedModelFactory modelFactory,
[NotNull] IOpenDataset datasetOpener)
{
Assert.ArgumentNotNull(modelFactory, nameof(modelFactory));
Assert.ArgumentNotNull(datasetOpener, nameof(datasetOpener));
_modelFactory = modelFactory;
_datasetOpener = datasetOpener;
}
protected bool TryGetArgumentValue(
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext,
[CanBeNull] out object value,
[CanBeNull] out List <TableConstraint> tableConstraint)
{
List <TableConstraint> constraints = new List <TableConstraint>();
bool success = TryGetArgumentValue(parameter, datasetContext, constraints, out value);
tableConstraint = constraints;
return(success);
}
private static object GetValue([NotNull] TestParameterValue paramVal,
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext)
{
Assert.ArgumentNotNull(paramVal, nameof(paramVal));
Assert.ArgumentNotNull(parameter, nameof(parameter));
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
var scalarParameterValue = paramVal as ScalarTestParameterValue;
if (scalarParameterValue != null)
{
if (scalarParameterValue.DataType == null)
{
scalarParameterValue.DataType = parameter.Type;
_msg.VerboseDebugFormat(
"DataType of scalarParameterValue {0} needed to be initialized.",
scalarParameterValue.TestParameterName);
}
return(scalarParameterValue.GetValue());
}
var datasetParameterValue = paramVal as DatasetTestParameterValue;
if (datasetParameterValue != null)
{
if (datasetParameterValue.DatasetValue == null &&
!parameter.IsConstructorParameter)
{
return(null);
}
Dataset dataset =
Assert.NotNull(datasetParameterValue.DatasetValue, "dataset is null");
datasetParameterValue.DataType = parameter.Type;
// TODO: Test in AO11 context and consider not running this test
Assert.True(datasetContext.CanOpen(dataset), "Cannot open dataset {0} of type {1}",
dataset, parameter.Type);
object result = datasetContext.OpenDataset(dataset, datasetParameterValue.DataType);
Assert.NotNull(result, "Dataset not found in current context: {0}",
dataset.Name);
return(result);
}
throw new ArgumentException($"Unhandled type {paramVal.GetType()}");
}
protected override object[] Args(
[NotNull] IOpenDataset datasetContext,
[NotNull] IList <TestParameter> testParameters,
[NotNull] out List <TableConstraint> tableParameters)
{
object[] objParams = base.Args(datasetContext, testParameters, out tableParameters);
if (objParams.Length != 1)
{
throw new ArgumentException(string.Format("expected 1 parameter, got {0}",
objParams.Length));
}
if (objParams[0] is IFeatureClass[] == false)
{
throw new ArgumentException(string.Format("expected IFeatureClass[], got {0}",
objParams[0].GetType()));
}
var objects = new object[2];
objects[0] = objParams[0];
var featureClasses = (IFeatureClass[])objParams[0];
int featureClassCount = featureClasses.Length;
var rules = new string[featureClassCount];
var constraint = new StringBuilder();
for (int featureClassIndex = 0;
featureClassIndex < featureClassCount;
featureClassIndex++)
{
string var = string.Format("m{0}", featureClassIndex);
rules[featureClassIndex] = string.Format("true; {0}: true", var);
if (constraint.Length > 0)
{
constraint.Append(" + ");
}
constraint.AppendFormat("{0}", var);
}
rules[0] = string.Format("{0}; {1} > 1", rules[0], constraint);
objects[0] = featureClasses;
objects[1] = new[] { rules };
return(objects);
}
protected override object[] Args(
[NotNull] IOpenDataset datasetContext,
[NotNull] IList <TestParameter> testParameters,
[NotNull] out List <TableConstraint> tableParameters)
{
object[] objParams = base.Args(datasetContext, testParameters, out tableParameters);
var objects = new object[2];
objects[0] = objParams[0];
objects[1] = ((double)objParams[1]) * Math.PI / 180.0;
return(objects);
}
protected override object[] Args(IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] objParams = base.Args(datasetContext, testParameters, out tableParameters);
if (objParams.Length != 4)
{
throw new ArgumentException(string.Format("expected 4 parameter, got {0}",
objParams.Length));
}
if (objParams[0] is IFeatureClass == false)
{
throw new ArgumentException(string.Format("expected IFeatureClass, got {0}",
objParams[0].GetType()));
}
if (objParams[1] is IFeatureClass == false)
{
throw new ArgumentException(string.Format("expected IFeatureClass, got {0}",
objParams[1].GetType()));
}
if (objParams[2] is int[] == false)
{
throw new ArgumentException(string.Format("expected int[], got {0}",
objParams[2].GetType()));
}
if (objParams[3] is string[] == false)
{
throw new ArgumentException(string.Format("expected string[], got {0}",
objParams[3].GetType()));
}
var objects = new object[4];
var featureClass = (IFeatureClass)objParams[0];
var referenceClass = (IFeatureClass)objParams[1];
var referenceSubtypes = (int[])objParams[2];
var rules = (string[])objParams[3];
objects[0] = featureClass;
objects[1] = referenceClass;
objects[2] = referenceSubtypes;
objects[3] = rules;
return(objects);
}
private static bool ExistsDataset([NotNull] IDdxDataset dataset,
[NotNull] IOpenDataset datasetOpener)
{
// -> allow work context to load dataset from other database ('master')
try
{
var aoDataset = datasetOpener.OpenDataset(dataset);
return(aoDataset != null);
}
catch (Exception e)
{
_msg.VerboseDebug($"Error opening dataset {dataset.Name}", e);
return(false);
}
}
protected override object[] Args(IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] objParams =
base.Args(datasetContext, testParameters, out tableParameters);
if (objParams.Length != 7)
{
throw new ArgumentException(string.Format("expected 7 parameter, got {0}",
objParams.Length));
}
var objects = new object[6];
var tables = ValidateType <IList <ITable> >(objParams[0], "IList<ITable>");
var associationName =
ValidateType <string>(objParams[1], "string (for relation)");
var join = ValidateType <JoinType>(objParams[2]);
objects[1] = ValidateType <double>(objParams[3]); // minEndDistance
objects[2] = ValidateType <double>(objParams[4]); // minGroupLength
objects[3] = ValidateType <double>(objParams[5]); // minLeafLength
objects[4] = ValidateType <string>(objParams[6]); // groupBy
objects[5] = tables;
ITable queryTable = CreateQueryTable(datasetContext, associationName, tables, join);
if (queryTable is IFeatureClass == false)
{
throw new InvalidOperationException(
"Relation table is not a FeatureClass, try change join type");
}
objects[0] = queryTable;
bool useCaseSensitiveQaSql;
string tableConstraint = CombineTableParameters(tableParameters,
out useCaseSensitiveQaSql);
tableParameters = new List <TableConstraint>
{
new TableConstraint(queryTable, tableConstraint,
useCaseSensitiveQaSql)
};
return(objects);
}
internal static IEnumerable <QualityCondition> GetOrderedQualityConditions(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IOpenDataset datasetOpener)
{
var list = new List <OrderedQualitySpecificationElement>();
var knownMissingDatasets = new HashSet <Dataset>();
var knownExistingDatasets = new HashSet <Dataset>();
var listOrder = 0;
foreach (QualitySpecificationElement element in qualitySpecification.Elements)
{
if (!element.Enabled)
{
continue;
}
QualityCondition condition = element.QualityCondition;
IList <TestParameterValue> deleted = condition.GetDeletedParameterValues();
if (deleted.Count > 0)
{
ReportInvalidConditionWarning(condition, deleted);
continue;
}
// try to open the datasets
ICollection <Dataset> missingDatasets = GetMissingDatasets(
condition, datasetOpener,
knownMissingDatasets, knownExistingDatasets);
if (missingDatasets.Count > 0)
{
ReportConditionWithMissingDatasetsWarning(condition, missingDatasets);
continue;
}
list.Add(new OrderedQualitySpecificationElement(element, listOrder));
listOrder++;
}
list.Sort();
return(list.Select(ordered =>
ordered.QualitySpecificationElement.QualityCondition));
}
protected override object[] Args(
IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] objParams = base.Args(datasetContext, testParameters, out tableParameters);
if (objParams.Length != 3)
{
throw new ArgumentException(string.Format("expected 3 parameters, got {0}",
objParams.Length));
}
if (!(objParams[0] is IFeatureClass[]))
{
throw new ArgumentException(string.Format("expected IFeatureClass[], got {0}",
objParams[0].GetType()));
}
if (!(objParams[1] is string[]))
{
throw new ArgumentException(string.Format("expected string[], got {0}",
objParams[1].GetType()));
}
if (!(objParams[2] is IFeatureClass[]))
{
throw new ArgumentException(string.Format("expected IFeatureClass[], got {0}",
objParams[2].GetType()));
}
object ignoreLoopEndpoints = GetIgnoreLoopEndpoints(testParameters, datasetContext);
var objects = new object[4];
objects[0] = objParams[0];
objects[2] = objParams[2];
objects[3] = ignoreLoopEndpoints;
var layers = (IFeatureClass[])objParams[0];
var ignoreFields = (string[])objParams[1];
objects[1] = GetIgnoreFieldsPerFeatureClass(layers, ignoreFields);
return(objects);
}
protected override object[] Args(IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
List <TableConstraint> ddxTableParameters;
object[] objParams = base.Args(datasetContext, testParameters, out ddxTableParameters);
if (objParams.Length != 6)
{
throw new ArgumentException(string.Format("expected 6 parameter, got {0}",
objParams.Length));
}
var tables = ValidateType <IList <ITable> >(objParams[0], "IList<ITable>");
var associationName =
ValidateType <string>(objParams[1], "string (for relation)");
var join = ValidateType <JoinType>(objParams[2]);
var nearClasses = ValidateType <IList <IFeatureClass> >(objParams[3]);
var maximumDistance = ValidateType <double>(objParams[4]);
var relevantRelationCondition = ValidateType <string>(objParams[5]);
ITable queryTable = CreateQueryTable(datasetContext, associationName, tables, join);
var objects = new object[5];
objects[0] = queryTable;
objects[1] = nearClasses;
objects[2] = maximumDistance;
objects[3] = relevantRelationCondition;
objects[4] = tables;
bool useCaseSensitiveQaSql;
string joinConstraint = CombineTableParameters(ddxTableParameters.GetRange(0, 2),
out useCaseSensitiveQaSql);
tableParameters = new List <TableConstraint>
{
new TableConstraint(queryTable, joinConstraint,
useCaseSensitiveQaSql)
};
tableParameters.AddRange(ddxTableParameters.GetRange(2, ddxTableParameters.Count - 2));
return(objects);
}
private object GetIgnoreLoopEndpoints(
[NotNull] IEnumerable <TestParameter> testParameters,
[NotNull] IOpenDataset datasetContext)
{
foreach (TestParameter testParameter in testParameters)
{
if (testParameter.Name == IgnoreLoopEndPointsParam)
{
object value;
if (TryGetArgumentValue(testParameter, datasetContext, out value))
{
return(value);
}
}
}
return(null);
}
private static IList <string> TranslateConstraints(
[NotNull] IEnumerable <string> constraints,
[NotNull] string associationName,
[NotNull] string relationshipClassName,
[NotNull] IEnumerable <DatasetTestParameterValue> datasetParameterValues,
[NotNull] IOpenDataset datasetContext)
{
IDictionary <string, string> replacements = GetTableNameReplacements(
datasetParameterValues, datasetContext, associationName, relationshipClassName);
if (replacements.Count == 0)
{
return(constraints.ToList());
}
return(constraints.Select(sql => ExpressionUtils.ReplaceTableNames(sql,
replacements))
.ToList());
}
private T GetParameterValue <T>(
[NotNull] IEnumerable <TestParameter> testParameters,
[NotNull] IOpenDataset datasetContext,
[NotNull] string parameterName)
{
var parameter = testParameters.First(p => string.Equals(
p.Name, parameterName,
StringComparison.OrdinalIgnoreCase));
object value;
if (!TryGetArgumentValue(parameter,
datasetContext,
out value))
{
value = parameter.DefaultValue;
}
return((T)value);
}
protected ITable CreateQueryTable([NotNull] IOpenDataset datasetContext,
[NotNull] string associationName,
[NotNull] IList <ITable> tables,
JoinType joinType,
[CanBeNull] string whereClause,
out string relationshipClassName)
{
ITable queryTable;
if (datasetContext is IQueryTableContext queryContext &&
queryContext.CanOpenQueryTables())
{
Model uniqueModel =
GetUniqueModel(Assert.NotNull(Condition, "No quality condition assigned"));
relationshipClassName =
queryContext.GetRelationshipClassName(associationName, uniqueModel);
queryTable = queryContext.OpenQueryTable(relationshipClassName, uniqueModel,
tables, joinType, whereClause);
}
private static IDictionary <string, string> GetTableNameReplacements(
[NotNull] IEnumerable <DatasetTestParameterValue> datasetParameterValues,
[NotNull] IOpenDataset datasetContext,
[NotNull] string associationName,
[NotNull] string relationshipClassName)
{
var replacements = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (!string.Equals(associationName, relationshipClassName,
StringComparison.OrdinalIgnoreCase))
{
replacements.Add(associationName, relationshipClassName);
}
foreach (DatasetTestParameterValue datasetParameterValue in datasetParameterValues)
{
Dataset dataset = datasetParameterValue.DatasetValue;
if (dataset == null)
{
continue;
}
var table = datasetContext.OpenDataset(
dataset, Assert.NotNull(datasetParameterValue.DataType)) as ITable;
if (table == null)
{
continue;
}
string tableName = DatasetUtils.GetName(table);
if (!string.Equals(dataset.Name, tableName))
{
replacements.Add(dataset.Name, tableName);
}
}
return(replacements);
}
protected override object[] Args(IOpenDataset datasetContext,
IList <TestParameter> testParameters,
out List <TableConstraint> tableParameters)
{
object[] objParams = base.Args(datasetContext, testParameters, out tableParameters);
if (objParams.Length != 3)
{
throw new ArgumentException(string.Format("expected 3 parameter, got {0}",
objParams.Length));
}
// TODO revise: the base class declares IFeatureClass[], but the subclass (QaMinSegAngleFactory) changes that to IFeatureClass.
//if (objParams[0] is IFeatureClass == false)
//{
// throw new ArgumentException(string.Format("expected IFeatureClass, got {0}",
// objParams[0].GetType()));
//}
if (objParams[1] is double == false)
{
throw new ArgumentException(string.Format("expected double, got {0}",
objParams[1].GetType()));
}
if (objParams[2] is bool == false)
{
throw new ArgumentException(string.Format("expected bool, got {0}",
objParams[2].GetType()));
}
var objects = new object[3];
objects[0] = objParams[0];
objects[1] = ((double)objParams[1]) * Math.PI / 180.0;
objects[2] = objParams[2];
return(objects);
}
private IList <ITest> CreateTests([NotNull] IOpenDataset datasetContext,
[NotNull] IList <TestParameter> testParameters)
{
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
Assert.ArgumentNotNull(testParameters, nameof(testParameters));
try
{
List <TableConstraint> sortedTableParameters;
object[] constructorArguments = Args(datasetContext,
testParameters,
out sortedTableParameters);
IList <ITest> tests = CreateTestInstances(constructorArguments);
foreach (ITest test in tests)
{
ApplyTableParameters(test, sortedTableParameters);
}
// apply non-constructor arguments
foreach (TestParameter parameter in testParameters.Where(
p => !p.IsConstructorParameter))
{
object value;
if (!TryGetArgumentValue(parameter, datasetContext, out value,
out List <TableConstraint> tableConstraints))
{
// TODO apply the defined DefaultValue?
continue;
}
foreach (ITest test in tests)
{
int preInvolvedTablesCount = test.InvolvedTables.Count;
SetPropertyValue(test, parameter, value);
SetNonConstructorConstraints(test, preInvolvedTablesCount,
tableConstraints);
}
}
return(tests);
}
catch (Exception e)
{
QualityCondition condition = Condition;
if (condition == null)
{
throw new AssertionException(
"Unable to create test for undefined condition", e);
}
var sb = new StringBuilder();
sb.AppendFormat("Unable to create test(s) for quality condition {0}",
condition.Name);
sb.AppendLine();
sb.AppendLine("with parameters:");
foreach (TestParameterValue value in condition.ParameterValues)
{
string stringValue;
try
{
stringValue = value.StringValue;
}
catch (Exception e1)
{
_msg.Debug(
string.Format(
"Error getting string value for parameter {0} of condition {1}",
value.TestParameterName,
condition.Name),
e1);
stringValue = $"<error: {e1.Message} (see log for details)>";
}
sb.AppendFormat(" {0} : {1}", value.TestParameterName, stringValue);
sb.AppendLine();
}
sb.AppendFormat("error message: {0}",
ExceptionUtils.GetInnermostMessage(e));
sb.AppendLine();
throw new InvalidOperationException(sb.ToString(), e);
}
}
private bool TryGetArgumentValue(
[NotNull] TestParameter parameter,
[NotNull] IOpenDataset datasetContext,
[CanBeNull] ICollection <TableConstraint> tableConstraints,
[CanBeNull] out object value)
{
if (Condition == null)
{
value = null;
return(false);
}
var valuesForParameter = new List <object>();
var parameterValueList = new List <DatasetTestParameterValue>();
foreach (TestParameterValue parameterValue in Condition.ParameterValues)
{
if (!Equals(parameterValue.TestParameterName, parameter.Name))
{
continue;
}
object valueForParameter = GetValue(parameterValue, parameter, datasetContext);
valuesForParameter.Add(valueForParameter);
// add value to list anyway,
// correct type is checked at the end of parameterIndex Loop
parameterValueList.Add(parameterValue as DatasetTestParameterValue);
}
if (valuesForParameter.Count == 0 && !parameter.IsConstructorParameter)
{
value = null;
return(false);
}
value = GetArgumentValue(parameter, valuesForParameter);
// if correct type, add to dataSetList
if (tableConstraints != null &&
valuesForParameter.Count > 0 &&
valuesForParameter[0] is ITable)
{
foreach (DatasetTestParameterValue datasetParameterValue in parameterValueList)
{
Dataset dataset =
Assert.NotNull(datasetParameterValue.DatasetValue, "dataset is null");
var table = (ITable)datasetContext.OpenDataset(
dataset, Assert.NotNull(datasetParameterValue.DataType));
Assert.NotNull(table, "Dataset not found in current context: {0}",
dataset.Name);
DdxModel dataModel = dataset.Model;
bool useCaseSensitiveSql = dataModel != null &&
ModelElementUtils.UseCaseSensitiveSql(
table, dataModel.SqlCaseSensitivity);
tableConstraints.Add(new TableConstraint(
table, datasetParameterValue.FilterExpression,
useCaseSensitiveSql));
}
}
return(true);
}
public IList <ITest> CreateTests([NotNull] IOpenDataset datasetContext)
{
return(CreateTests(datasetContext, Parameters));
}
