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