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)); }