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); } }
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); } } }
/// <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> /// (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> /// 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> /// 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; } }
public bool IsValid(Vector target) { Vector innerVector = target.GetValue(QualifiedDimension.Create(_path.Last(), _path.Take(_path.Count - 1))); return(_innerConstraint.IsValid(innerVector)); }