/// <summary> /// Initializes a new instance of the <see cref="TwoDimensionalConstraint<FirstDomainType, SecondDomainType>"/> class. /// </summary> /// <param name="firstDimension">The first dimension.</param> /// <param name="secondDimension">The second dimension.</param> /// <param name="thirdDimension">The third dimension.</param> /// <param name="validator">The validator method to use.</param> /// <exception cref="ArgumentNullException">Any of the arguments is null.</exception> public ThreeDimensionalConstraint(QualifiedDimension <TFirstDomainType> firstDimension, QualifiedDimension <TSecondDomainType> secondDimension, QualifiedDimension <TThirdDomainType> thirdDimension, ThreeDimensionalValidator <TFirstDomainType, TSecondDomainType, TThirdDomainType> validator) { if (firstDimension == null) { throw new ArgumentNullException("firstDimension"); } if (secondDimension == null) { throw new ArgumentNullException("secondDimension"); } if (thirdDimension == null) { throw new ArgumentNullException("thirdDimension"); } if (validator == null) { throw new ArgumentNullException("validator"); } _firstDimension = firstDimension; _secondDimension = secondDimension; _thirdDimension = thirdDimension; _validator = validator; _requiredDimensions = new List <QualifiedDimension>() { _firstDimension, _secondDimension, _thirdDimension }.AsReadOnly(); }
private void SetDefaultStrategies(IEnumerable <Matrix> path, Matrix targetMatrix) { foreach (Dimension dim in targetMatrix.Dimensions) { Matrix asMatrix; Type underlyingType = Nullable.GetUnderlyingType(dim.Domain) ?? dim.Domain; if (underlyingType.IsEnum()) { _explorationStrategies.Add(QualifiedDimension.Create(dim, path), (IExplorationStrategy)typeof(ExhaustiveEnumStrategy <>).MakeGenericType(dim.Domain).GetInstanceConstructor(true, new Type[0]).Invoke(null)); } else if (typeof(bool).Equals(dim.Domain)) { _explorationStrategies.Add(QualifiedDimension.Create(dim, path), new ExhaustiveIEnumerableStrategy <bool>(true, false)); } else if (typeof(bool?).Equals(dim.Domain)) { _explorationStrategies.Add(QualifiedDimension.Create(dim, path), new ExhaustiveIEnumerableStrategy <bool?>(true, false, null)); } else if ((asMatrix = dim as Matrix) != null) { SetDefaultStrategies(path.Concat(Enumerable.Repeat(asMatrix, 1)), asMatrix); } } }
private void SetDimensionStrategyBase(QualifiedDimension dimension, IExplorationStrategy strategy) { Matrix currentMatrix = _targetMatrix; List <Matrix> innerPath = new List <Matrix>(); foreach (Matrix innerMatrix in dimension.Path) { if (!currentMatrix.Dimensions.Contains(innerMatrix)) { throw new DimensionNotInMatrixException(innerMatrix); } if (strategy != null) { _explorationStrategies.Remove(QualifiedDimension.Create(innerMatrix, innerPath)); } currentMatrix = innerMatrix; innerPath.Add(innerMatrix); } if (strategy == null) { _explorationStrategies.Remove(dimension); } else if (_explorationStrategies.ContainsKey(dimension)) { _explorationStrategies[dimension] = strategy; } else { _explorationStrategies.Add(dimension, strategy); } }
public void SetDimensionStrategy <T>(QualifiedDimension <T> dimension, ExplorationStrategy <T> strategy) { if (dimension == null) { throw new ArgumentNullException("dimension"); } SetDimensionStrategyBase(dimension, strategy); }
/// <summary> /// (Internal usage) Gets the current exploration strategy for the given dimension. /// </summary> /// <param name="dimension">The dimension.</param> /// <returns> /// The strategy set for the dimension, or null if none found. /// </returns> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null.</exception> public IExplorationStrategy GetBaseDimensionStrategy(Dimension dimension) { if (dimension == null) { throw new ArgumentNullException("dimension"); } return(GetBaseDimensionStrategy(QualifiedDimension.Create(dimension))); }
/// <summary> /// (Internal use) Gets the value of the given dimension in a non-generic way. /// </summary> /// <param name="dimension">The dimension.</param> /// <returns></returns> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null</exception> /// <exception cref="KeyNotFoundException">No value was ever set for this dimension.</exception> internal object GetBaseValue(QualifiedDimension dimension) { if (dimension.Path.Any()) { return(GetValue(dimension.Path[0]).GetBaseValue(QualifiedDimension.Create(dimension.BaseDimension, dimension.Path.Skip(1)))); } else { return(GetBaseValue(dimension.BaseDimension)); } }
/// <summary> /// Special constructors for sub-classes that just want to override <see cref="IsValidValue"/> instead of providing a delegate. /// </summary> /// <param name="targetDimension"></param> /// <exception cref="ArgumentNullException">Any of the arguments is null.</exception> protected OneDimensionalConstraint(QualifiedDimension <T> targetDimension) { if (targetDimension == null) { throw new ArgumentNullException("targetDimension"); } _targetDimension = targetDimension; _validator = null; _requiredDimensions = new List <QualifiedDimension>() { _targetDimension }.AsReadOnly(); }
/// <summary> /// (Internal use) Gets the category from which the value of the given dimension was chosen (can be null if it wasn't from a categorical exploration). /// </summary> /// <param name="dimension">The dimension.</param> /// <returns></returns> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null</exception> internal Category GetBaseCategory(QualifiedDimension dimension) { if (dimension == null) { throw new ArgumentNullException("dimension"); } if (dimension.Path.Any()) { return(GetValue(dimension.Path[0]).GetBaseCategory(QualifiedDimension.Create(dimension.BaseDimension, dimension.Path.Skip(1)))); } else { return(GetBaseCategory(dimension.BaseDimension)); } }
/// <summary> /// Initializes a new instance of the <see cref="OneDimensionalConstraint<T>"/> class. /// </summary> /// <param name="targetDimension">The target dimension.</param> /// <param name="validator">The validator.</param> /// <exception cref="ArgumentNullException">Any of the arguments is null.</exception> public OneDimensionalConstraint(QualifiedDimension <T> targetDimension, OneDimensionalValidator <T> validator) { if (targetDimension == null) { throw new ArgumentNullException("targetDimension"); } if (validator == null) { throw new ArgumentNullException("validator"); } _targetDimension = targetDimension; _validator = validator; _requiredDimensions = new List <QualifiedDimension>() { _targetDimension }.AsReadOnly(); }
private static int GetIndexOfDimension(QualifiedDimension targetDimension, ReadOnlyCollection <DimensionWithValues> dimensionValues, string origin) { int ret = 0; foreach (DimensionWithValues dv in dimensionValues) { if (targetDimension.Equals(dv.Dimension)) { return(ret); } ret++; } throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Dimension {0} from {1} was not found in the explored matrix (all dimensions: {2}).", targetDimension.FullyQualifiedName, origin, string.Join(",", dimensionValues.Select(dv => dv.Dimension.FullyQualifiedName)))); }
/// <summary> /// (Internal usage) Gets the current exploration strategy for the given dimension. /// </summary> /// <param name="dimension">The dimension.</param> /// <returns> /// The strategy set for the dimension, or null if none found. /// </returns> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null.</exception> public IExplorationStrategy GetBaseDimensionStrategy(QualifiedDimension dimension) { if (dimension == null) { throw new ArgumentNullException("dimension"); } IExplorationStrategy ret; if (_explorationStrategies.TryGetValue(dimension, out ret)) { return(ret); } else { return(null); } }
private static int GetIndexOfConstraintDimension(IConstraint constraint, ReadOnlyCollection <DimensionWithValues> dimensionValues, QualifiedDimension dimension) { int ret = 0; foreach (DimensionWithValues dv in dimensionValues) { if (IsSubset(dimension, dv.Dimension)) { return(ret); } ret++; } throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Dimension {0} from constraint {1} was not found in the matrix (all dimensions: {2}).", dimension.FullyQualifiedName, constraint.GetType().Name, string.Join(",", dimensionValues.Select(dv => dv.Dimension.FullyQualifiedName)))); }
/// <summary> /// Determines whether this vector has a value for the specified dimension. /// </summary> /// <param name="dimension">The dimension.</param> /// <returns> /// <c>true</c> if the vector has a value for the dimension; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null</exception> public bool HasValue(QualifiedDimension dimension) { if (dimension == null) { throw new ArgumentNullException("dimension"); } Vector innerVector = this; foreach (Matrix innerMatrix in dimension.Path) { if (!innerVector.HasValue(innerMatrix)) { return(false); } innerVector = innerVector.GetValue(innerMatrix); } return(innerVector._dimensionValues.ContainsKey(dimension.BaseDimension)); }
/// <summary> /// Checks that all dimensions have exploration strategies. /// </summary> /// <param name="path">The path.</param> /// <param name="targetMatrix">The target matrix.</param> /// <exception cref="DimensionStrategyNotSetException">Any dimension found with no corresponding strategy.</exception> private void CheckAllDimensionsHaveExplorationStrategies(IEnumerable <Matrix> path, Matrix targetMatrix) { foreach (Dimension dimension in targetMatrix.Dimensions) { if (!_explorationStrategies.ContainsKey(QualifiedDimension.Create(dimension, path))) { Matrix asMatrix; if ((asMatrix = dimension as Matrix) != null) { CheckAllDimensionsHaveExplorationStrategies(path.Concat(Enumerable.Repeat(asMatrix, 1)), asMatrix); } else { throw new DimensionStrategyNotSetException(dimension); } } } }
/// <summary> /// Special constructors for sub-classes that just want to override <see cref="IsValidValue"/> instead of providing a delegate. /// </summary> /// <param name="firstDimension">The first dimension.</param> /// <param name="secondDimension">The second dimension.</param> /// <exception cref="ArgumentNullException">Any of the arguments is null.</exception> protected TwoDimensionalConstraint(QualifiedDimension <TFirstDomainType> firstDimension, QualifiedDimension <TSecondDomainType> secondDimension) { if (firstDimension == null) { throw new ArgumentNullException("firstDimension"); } if (secondDimension == null) { throw new ArgumentNullException("secondDimension"); } _firstDimension = firstDimension; _secondDimension = secondDimension; _validator = null; _requiredDimensions = new List <QualifiedDimension>() { _firstDimension, _secondDimension }.AsReadOnly(); }
/// <summary> /// Gets all individual dimension values. /// </summary> /// <param name="path">The path.</param> /// <param name="targetMatrix">The target matrix.</param> /// <returns></returns> /// <exception cref="DimensionStrategyNotSetException">Any dimension found with no corresponding strategy.</exception> private ReadOnlyCollection <DimensionWithValues> GetAllDimensionValues(IEnumerable <Matrix> path, Matrix targetMatrix) { CheckAllDimensionsHaveExplorationStrategies(); List <DimensionWithValues> ret = new List <DimensionWithValues>(targetMatrix.Dimensions.Count); foreach (Dimension dimension in targetMatrix.Dimensions) { QualifiedDimension QualifiedDimension = QualifiedDimension.Create(dimension, path); if (_explorationStrategies.ContainsKey(QualifiedDimension)) { ret.Add(new DimensionWithValues(QualifiedDimension, GetValues(GetBaseDimensionStrategy(QualifiedDimension)))); } else { Matrix asMatrix = (Matrix)dimension; ret.AddRange(GetAllDimensionValues(path.Concat(Enumerable.Repeat(asMatrix, 1)), asMatrix)); } } return(ret.AsReadOnly()); }
/// <summary> /// Imports the dimension exploration strategies for the given innner matrix found with the given source combinatorial strategy. /// </summary> /// <param name="innerMatrixPath">The inner matrix path.</param> /// <param name="sourceStrategy">The source strategy.</param> /// <remarks> /// This is useful for exploring dimensions from a sub-matrix in the same strategy, which is useful e.g. for doing pairwise coverage /// across sub-matrix boundaries. /// </remarks> /// <returns>The number of strategies imported.</returns> /// <exception cref="ArgumentNullException"><paramref name="sourceStrategy"/> is null.</exception> public int ImportSubMatrixStrategies(IEnumerable <Matrix> innerMatrixPath, CombinatorialStrategy sourceStrategy) { if (sourceStrategy == null) { throw new ArgumentNullException("sourceStrategy"); } if (innerMatrixPath == null || innerMatrixPath.Any(m => m == null)) { throw new ArgumentNullException("innerMatrixPath"); } int ret = 0; foreach (KeyValuePair <QualifiedDimension, IExplorationStrategy> dimStrategy in sourceStrategy._explorationStrategies) { SetDimensionStrategyBase(QualifiedDimension.Create(dimStrategy.Key.BaseDimension, innerMatrixPath.Concat(dimStrategy.Key.Path)), dimStrategy.Value); ret++; } _constraints.AddRange(sourceStrategy._constraints.Select <IConstraint, IConstraint>(c => new InnerSubMatrixWrapperConstraint(c, innerMatrixPath))); return(ret); }
/// <summary> /// (Internal use/required for VectorInfo) Sets the value for the given dimension. /// </summary> /// <param name="dimension">The dimension.</param> /// <param name="value">The value.</param> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null</exception> internal void SetBaseValue(QualifiedDimension dimension, ValueFactoryWithOptionalConcreteValue value) { if (dimension.Path.Any()) { Vector innerVector; ValueFactoryWithOptionalConcreteValue valueFactory; if (_dimensionValues.TryGetValue(dimension.Path[0], out valueFactory)) { innerVector = (Vector)valueFactory.MakeConcrete().GetConcreteValue(); } else { innerVector = new Vector(); SetBaseValue(dimension.Path[0], innerVector); } innerVector.SetBaseValue(QualifiedDimension.Create(dimension.BaseDimension, dimension.Path.Skip(1)), value); } else { _dimensionValues[dimension.BaseDimension] = value; } }
/// <summary> /// Gets the value of the given dimension. /// </summary> /// <param name="dimension">The dimension.</param> /// <returns>The value of the dimension.</returns> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null</exception> /// <exception cref="KeyNotFoundException">No value was ever set for this dimension.</exception> public object GetValue(QualifiedDimension dimension) { return(GetBaseValue(dimension)); }
public bool IsValid(Vector target) { Vector innerVector = target.GetValue(QualifiedDimension.Create(_path.Last(), _path.Take(_path.Count - 1))); return(_innerConstraint.IsValid(innerVector)); }
private static bool IsSubset(QualifiedDimension superset, QualifiedDimension subset) { return(superset.Path.Count >= subset.Path.Count && superset.FullPath.Take(subset.FullPath.Count()).SequenceEqual(subset.FullPath)); }
public ExplorationStrategy <T> GetDimensionStrategy <T>(QualifiedDimension <T> dimension) { return((ExplorationStrategy <T>)(GetBaseDimensionStrategy(dimension))); }
public Category <T> GetCategory <T>(QualifiedDimension <T> dimension) { return((Category <T>)GetBaseCategory(dimension)); }
public void SetValue <T>(QualifiedDimension <T> dimension, T value) { SetBaseValue(dimension, value); }
public void SetValue <T>(QualifiedDimension <T> dimension, T value, Category <T> category) { SetBaseValue(dimension, value, category); }
/// <summary> /// (Internal use/required for VectorInfo) Sets the value for the given dimension, associating it with a category. /// </summary> /// <param name="dimension">The dimension.</param> /// <param name="value">The value.</param> /// <param name="category">The category. Can be null.</param> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null</exception> internal void SetBaseValue(QualifiedDimension dimension, object value, Category category) { SetBaseValue(dimension, new ValueFactoryWithOptionalConcreteValue( category == null ? new SingleValueFactory(value) : (IValueFactory)category, value)); }
private static IEnumerable <QualifiedDimension> ExpandOuterMatrixDimensionIfNeeded(QualifiedDimension toExpand, ReadOnlyCollection <DimensionWithValues> dimensionValues) { IEnumerable <QualifiedDimension> ret = dimensionValues.Select(dv => dv.Dimension).Where(d => IsSubset(d, toExpand)); if (toExpand.BaseDimension is Matrix && ret.Any()) { return(ret); } else { return(Enumerable.Repeat(toExpand, 1)); } }
/// <summary> /// (Internal use/required for VectorInfo) Sets the value for the given dimension. /// </summary> /// <param name="dimension">The dimension.</param> /// <param name="value">The value.</param> /// <exception cref="ArgumentNullException"><paramref name="dimension"/> is null</exception> internal void SetBaseValue(QualifiedDimension dimension, object value) { SetBaseValue(dimension, new ValueFactoryWithOptionalConcreteValue(new SingleValueFactory(value), value)); }
/// <summary> /// Initializes a new instance of the <see cref="DimensionWithValues"/> struct. /// </summary> /// <param name="dimension">The dimension.</param> /// <param name="values">The values.</param> public DimensionWithValues(QualifiedDimension dimension, IEnumerable <ValueFactoryWithOptionalConcreteValue> values) { _dimension = dimension; _values = new List <ValueFactoryWithOptionalConcreteValue>(values); }
/// <summary> /// Sets the exploration strategy for the given dimension to a categorical strategy with the given categories defined. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="dimension"></param> /// <param name="allCategories"></param> /// <exception cref="ArgumentNullException">Any of the parameters is null.</exception> /// <exception cref="DimensionNotInMatrixException"><paramref name="dimension"/> is not in the target matrix.</exception> /// <example><code><![CDATA[ /// _fullStrategy.PartitionDimension(_dataTypeDimension, /// new PointCategory<PimodType>("String", PimodType.VarChar(20), PimodType.NVarChar(10), PimodType.Char(5), PimodType.NChar(50)), /// new PointCategory<PimodType>("Integer", PimodType.TinyInt(), PimodType.SmallInt(), PimodType.Int(), PimodType.BigInt())); ///_fullStrategy.PartitionDimension(_tableSizeDimension, /// new PointCategory<int>("OneRow", 1), /// new IntegerRangeCategory("Small", 10, 20), /// new IntegerRangeCategory("Large", 10000, 15000)); /// ]]></code></example> public void PartitionDimension <T>(QualifiedDimension <T> dimension, params Category <T>[] allCategories) { SetDimensionStrategy(dimension, new CategoricalStrategy <T>(allCategories)); }