public override List<TestVariation> EnumerateVariations(TestCase testcase, MethodInfo method) {
// build data
var columnAttrs = method.GetCustomAttributes(typeof(MatrixColumnAttribute), false) as MatrixColumnAttribute[];
Debug.Assert(columnAttrs.Length > 0);
object[][] inputMatrix = new object[columnAttrs.Length][];
Dictionary<string, int> columnName2PositionMap = new Dictionary<string, int>();
foreach (var inputColumn in columnAttrs) {
#region Asserts
Debug.Assert(inputMatrix[inputColumn.ParamOrderId] == null);
Debug.Assert(!columnName2PositionMap.ContainsKey(inputColumn.Name));
Debug.Assert(!columnName2PositionMap.ContainsValue(inputColumn.ParamOrderId));
#endregion
inputMatrix[inputColumn.ParamOrderId] = inputColumn.Values;
columnName2PositionMap[inputColumn.Name] = inputColumn.ParamOrderId;
}
// Build Skip filters
List<object[]> skipConstraints = CreateSkipConstraints(method, columnName2PositionMap);
// Build Priority filters + default filter
Dictionary<int, List<object[]>> priFilters = CreatePriorityConstraints(method, Priority, columnName2PositionMap);
// Create Pairwise combinations based on the pri filters
Dictionary<int, List<object[]>> combinations = Pairwise(inputMatrix, skipConstraints, priFilters);
List<TestVariation> variations = new List<TestVariation>();
int variationCounter = 0;
//string orderedColumnNames = string.Concat(columnName2PositionMap.OrderBy(p => p.Value).Select((p, i) => i == 0 ? p.Key : string.Concat(",", p.Key)).ToArray());
foreach (int priority in combinations.Keys) {
foreach (object[] line in combinations[priority]) {
string name = GetVariationName(columnName2PositionMap, line);
TestVariation tv = new TestVariation(name, (TestFunc)Delegate.CreateDelegate(typeof(TestFunc), testcase, method));
tv.Priority = priority;
//// the last element in params will contain the parameter names (we need it to be able perform filters on the silverlight side);
//object[] linePlusNames = new object[line.Length + 1];
//Array.Copy(line, linePlusNames, line.Length);
//linePlusNames[line.Length] = orderedColumnNames ;
//tv.Params = linePlusNames;
tv.Params = line;
tv.Id = ++variationCounter;
variations.Add(tv);
}
}
return variations;
}
public TestVariation GenerateVariation(TestCase testcase, MethodInfo method, VariationAttribute testVarAttrib)
{
//do not generate variations for tests which have KeepInContent set to false and the version is not V2
if (!this.KeepInContent && !Versioning.Server.SupportsV2Features)
{
return null;
}
TestVariation ffTestVariation;
MethodInfo generateEpmMappingsMethod = testcase.GetType().GetMethod("GenerateEpmMappings");
FilterResourcesLambda = GenerateLambda();
TestFunc testMethodAction = delegate()
{
bool thisTestFailed = true;
SkipInvalidRuns();
try
{
generateEpmMappingsMethod.Invoke(testcase, new object[]{
KeepInContent,//bool pKeepInContent,
RemoveUnEligibleTypes,//bool pRemoveUnEligibleTypes,
GenerateClientTypes,//bool pGenerateClientTypes,
MapToAtomElements,//bool pMapPropertiesToAtomElements,
MapToNonAtomElements,//bool pMapPropertiesToNonAtomElements,
GenerateServerEPMMappings,//bool GenerateServerEPMMappings,
KeepSameNamespace,//bool KeepSameNamespace,
IncludeComplexTypes,//bool IncludeComplexTypes
PreDefinedPaths ,//string[] PreDefinedPaths
FilterResourcesLambda //Func<ResourceType, bool> pFilterResourcesLambda
});
method.Invoke(testcase, null);
thisTestFailed = AstoriaTestLog.FailureFound;
}
catch (Microsoft.OData.Client.DataServiceClientException dsException)
{
if (dsException.InnerException != null)
AstoriaTestLog.WriteLine(dsException.InnerException.Message);
}
catch (TestFailedException testException)
{
AstoriaTestLog.WriteLine("Test failed with :{0}", testException.Message);
AstoriaTestLog.WriteLine("Repro Details\r\nClient Code");
}
finally
{
//Disabling this as OOM errors prevent file copying
thisTestFailed = false;
#region //Clean out all the facets after the test , so that the next test is clear
object workspacePointer = null;
PropertyInfo testWorkspacesProperty = testcase.Parent.GetType().GetProperty("Workspaces");
workspacePointer = testcase.Parent;
if (testWorkspacesProperty == null)
{
testWorkspacesProperty = testcase.GetType().GetProperty("Workspaces");
workspacePointer = testcase;
}
Workspaces testWorkspaces = (Workspaces)testWorkspacesProperty.GetValue(workspacePointer, null);
foreach (Workspace workspace in testWorkspaces)
{
if (thisTestFailed)
{
string testFailureReproPath = String.Format("FF_Failure_{0}", System.Guid.NewGuid().ToString());
testFailureReproPath = System.IO.Path.Combine(Environment.CurrentDirectory, testFailureReproPath);
IOUtil.CopyFolder(workspace.DataService.DestinationFolder, testFailureReproPath, true);
AstoriaTestLog.WriteLine("Test failed , Repro available at : {0} ", testFailureReproPath);
}
if (!(workspace is EdmWorkspace))
{
workspace.GenerateClientTypes = true;
workspace.GenerateServerMappings = false;
workspace.ApplyFriendlyFeeds();
}
}
#endregion
}
};
ffTestVariation = new TestVariation(testMethodAction);
if (testVarAttrib != null)
{
ffTestVariation.Params = testVarAttrib.Params;
ffTestVariation.Param = testVarAttrib.Param;
ffTestVariation.Desc = String.Format(
"{3} , {0},{1},{2},{4}{5}{6}{7}",
GenerateClientTypes ? "Client Mapped" : "",
GenerateServerEPMMappings ? "Server Mapped" : "",
MapToAtomElements ? "Mapped to Atom" : "Mapped to Non-Atom Elements",
testVarAttrib.Desc, InheritanceFilter.ToString(),
KeepSameNamespace ? "Same Namespace" : "Different NameSpaces",
PreDefinedPaths != null ? ",PredefinedPaths" : "", KeepInContent.ToString());
if (AstoriaTestProperties.MaxPriority == 0)
{
ffTestVariation.Id = 1;
}
else
{
ffTestVariation.Id = idCounter++;
}
ffTestVariation.Priority = this.Priority;
}
return ffTestVariation;
}
public TestVariation GenerateVariation(TestCase testcase, MethodInfo method)
{
TestVariation rcTestVariation;
TestFunc testMethodAction = delegate()
{
method.Invoke(testcase, null);
};
rcTestVariation = new TestVariation(testMethodAction);
rcTestVariation.Params = this.Params;
rcTestVariation.Param = this.Param;
rcTestVariation.Desc = this.Desc;
rcTestVariation.Id = this.Id;
rcTestVariation.Priority = this.Priority;
return rcTestVariation;
}
public ExplicitCastNullVariation(Type nodeType, Type retType, bool shouldThrow, TestCase tc, string desc)
{
this.Desc = desc;
_nodeType = nodeType;
_retType = retType;
_shouldThrow = shouldThrow;
}
public ExplicitCastVariation(ExplicitCastTestType testType, NodeCreateType nodeCreateType, Type nodeType, object data, Type retType, TestCase testCase, string desc)
{
_desc = desc;
_data = data;
_nodeType = nodeType;
_testType = testType;
_retType = retType;
_nodeCreateType = nodeCreateType;
}
public virtual List<TestVariation> EnumerateVariations(TestCase testcase, MethodInfo method)
{
int id= StartingId;
List<object[]> rows = new List<object[]>();
List<MatrixColumnAttribute> matrixColumns = new List<MatrixColumnAttribute>();
object []attributes = method.GetCustomAttributes(false);
List<MatrixSkipConstraintAttribute> skipAttributes = new List<MatrixSkipConstraintAttribute>();
List<MatrixPriorityFilterAttribute> priorityAttributes = new List<MatrixPriorityFilterAttribute>();
foreach (MatrixColumnAttribute matrixColumn in attributes.OfType < MatrixColumnAttribute>())
{
matrixColumns.Insert(0,matrixColumn);
}
foreach (MatrixSkipConstraintAttribute skipConstraint in attributes.OfType<MatrixSkipConstraintAttribute>())
{
skipAttributes.Insert(0, skipConstraint);
}
foreach (MatrixPriorityFilterAttribute filter in attributes.OfType<MatrixPriorityFilterAttribute>())
{
// TODO: why aren't we just doing add? or .ToList()?
priorityAttributes.Insert(0, filter);
}
//Verify that no ParamOrderId's match
IEnumerable<IGrouping<int, MatrixColumnAttribute>> grouping = matrixColumns.GroupBy<MatrixColumnAttribute, int>(mc => mc.ParamOrderId);
foreach (IGrouping<int, MatrixColumnAttribute> group in grouping)
{
if (group.Key != -1)
{
if (group.Count() > 1)
throw new ArgumentException("For Matrix variation:" + this.PrefixName + " test method:" + method.Name + " Multiple MatrixColumnAttributes have the same ParamOrderId, this is invalid");
}
}
//Sort it by ParamOrderId
matrixColumns.Sort(CompareMatrixColumnParamId);
foreach (MatrixColumnAttribute matrixColumn in matrixColumns)
{
rows = MultiplyMatrixRowsByColumn(matrixColumn, rows);
}
List<TestVariation> variations = new List<TestVariation>();
foreach(object[] matrixRow in rows)
{
//Every method that has a [Variation attribute] = a variation
//Add this variation to our array
TestFunc func = null;
try
{
func = (TestFunc)Delegate.CreateDelegate(typeof(TestFunc), testcase, method);
}
catch(Exception e)
{
e = new TestFailedException("Variation: '" + method + "' doesn't match expected signature of 'void func()', unable to add that variation.", null, null, e);
TestLog.HandleException(e);
continue;
}
int i = 0;
string description = null;
//Calling from the list to reverse the attribute order so its in the order
//as its in the code
foreach (MatrixColumnAttribute matrixColumn in matrixColumns)
{
if (description == null)
description = this.PrefixName + " " + matrixColumn.Name + ":" + matrixRow[i].ToString();
else
description = description + " " + matrixColumn.Name + ":" + matrixRow[i].ToString();
i++;
}
if (!ShouldSkipVariation(testcase, matrixColumns, skipAttributes, matrixRow))
{
TestVariation var = new TestVariation(description, func);
var.Params = matrixRow;
var.Id = id;
var.Desc = description;
var.Priority = VariationPriority(testcase, matrixColumns, priorityAttributes, matrixRow);
variations.Add(var);
id++;
}
}
return variations;
}
private int VariationPriority(TestCase testCase, List<MatrixColumnAttribute> matrixColumns, List<MatrixPriorityFilterAttribute> priorityFilters, object[] matrixRow)
{
int maxPriority = this.Priority;
foreach (MatrixPriorityFilterAttribute filter in priorityFilters)
{
if (IsMatchAcrossRow(testCase, matrixColumns, matrixRow, filter.FilterColumns, filter.FilterValues))
maxPriority = Math.Max(maxPriority, filter.Priority);
}
return maxPriority;
}
private bool IsMatchAcrossRow(TestCase testCase, List<MatrixColumnAttribute> matrixColumns, object[] matrixRow, string[] filterNames, object[] filterValues)
{
bool allEqual = true;
for (int i = 0; i < filterNames.Count(); i++)
{
string columnName = filterNames[i];
object columnValue = filterValues[i];
bool found = false;
for (int j = 0; j < matrixColumns.Count; j++)
{
if (matrixColumns[j].Name == columnName)
{
found = true;
if (!matrixRow[j].Equals(columnValue))
allEqual = false;
break;
}
}
if (!found)
{
if (columnName.StartsWith("Parent.") && columnName.EndsWith(".Param"))
{
TestItem test = testCase;
string name = columnName;
while ((name = name.Remove(0, "Parent.".Length)).StartsWith("Parent."))
test = test.Parent;
if (name == "Param")
{
if (!test.Param.Equals(columnValue))
allEqual = false;
}
else
{
throw new TestFailedException("Could not parse inherited param name: " + columnName);
}
}
else
{
throw new TestFailedException("Could not find column: " + columnName);
}
}
}
return allEqual;
}
private bool ShouldSkipVariation(TestCase testCase, List<MatrixColumnAttribute> matrixColumns, List<MatrixSkipConstraintAttribute> skipConstraints, object[] matrixRow)
{
foreach (MatrixSkipConstraintAttribute skipConstraint in skipConstraints)
{
if (IsMatchAcrossRow(testCase, matrixColumns, matrixRow, skipConstraint.SkipColumns, skipConstraint.SkipValues))
return true;
}
return false;
}