public BlockerResolverResult Resolve(List <Blocker> blockers)
{
var blockerIdsToResolve = blockers.Select(x => x.Id);
var unresolvedBlockers = _extendedBlockers.Where(x => !blockerIdsToResolve.Contains(x.Id)).Select(x => new Blocker
{
Id = x.Id,
Name = x.Name,
Cost = x.Cost
});
var resolvedTestcases = InitialDataset.Testcases.Select(x => new Testcase
{
Id = x.Id,
Name = x.Name,
TestType = x.TestType,
ApplicationModule = x.ApplicationModule,
BlockerIds = x.BlockerIds.Except(blockerIdsToResolve).ToList()
});
var localDataset = new TestcaseBlockerDataset
{
Blockers = unresolvedBlockers.ToList(),
Testcases = resolvedTestcases.ToList()
};
var result = new BlockerResolverResult(_initialDataset, localDataset);
return(result);
}
public BlockerResolver(TestcaseBlockerDataset initialDataset)
{
_initialDataset = initialDataset;
_extendedBlockers = InitialDataset.Blockers.Select(x => new ExtendedBlocker
{
Id = x.Id,
Name = x.Name,
Cost = x.Cost,
Testcases = InitialDataset.Testcases.Where(t => t.BlockerIds.Contains(x.Id)).ToList()
}).ToList();
}
public void EnsureDeepClonedDatasetIsEqualToOriginal()
{
var numBlockers = 10;
var numTestcases = 50;
TestcaseBlockerDataset originalDataset = DataGenerator.GenerateRandomData(numBlockers, numTestcases);
var clonedDataset = (TestcaseBlockerDataset)CloneHelper.GetDeepClone(originalDataset);
Assert.IsInstanceOf <TestcaseBlockerDataset>(clonedDataset);
Assert.IsTrue(clonedDataset.Blockers.Count == numBlockers);
Assert.IsTrue(clonedDataset.Testcases.Count == numTestcases);
}
public static TestcaseBlockerDataset GenerateRandomData(int numberOfBlockers, int numberOfTestcases)
{
var blockers = new List <Blocker>();
var testcases = new List <Testcase>();
var rnd = new Random();
// Generate Blockers
for (int i = 1; i <= numberOfBlockers; i++)
{
blockers.Add(new Blocker
{
Id = Guid.NewGuid().ToString(),
Name = $"Blocker {i}"
});
}
// Generate Testcases
for (int i = 1; i <= numberOfTestcases; i++)
{
var testcase = new Testcase
{
Id = Guid.NewGuid().ToString(),
Name = $"Testcase {i}"
};
var numberOfBlockersForTestcase = rnd.Next(0, (int)Math.Ceiling(0.5 * numberOfBlockers));
while (testcase.BlockerIds.Count < numberOfBlockersForTestcase)
{
var blockerId = blockers[rnd.Next(0, numberOfBlockers)].Id;
if (!testcase.BlockerIds.Contains(blockerId))
{
testcase.BlockerIds.Add(blockerId);
}
}
testcases.Add(testcase);
}
TestcaseBlockerDataset configuration = new TestcaseBlockerDataset
{
Blockers = blockers,
Testcases = testcases
};
return(configuration);
}
public static async Task ExportDataset(TestcaseBlockerDataset dataset)
{
if (dataset is null)
{
Console.WriteLine("Cannot export an empty dataset. First generate or load a dataset.");
return;
}
Console.Write("Enter filename without extension: ");
string filename = Console.ReadLine();
var path = Path.Combine(GetDataPath(), filename + ".xlsx");
Console.WriteLine($"Exporting dataset to {path}");
await dataset.ExportAsXlsxAsync(path);
}
public static async Task SaveDataset(TestcaseBlockerDataset dataset)
{
if (dataset is null)
{
Console.WriteLine("Cannot save an empty dataset. First generate or load a dataset.");
return;
}
Console.Write("Enter filename without extension: ");
string filename = Console.ReadLine();
var path = Path.Combine(GetDataPath(), filename + ".json");
Console.WriteLine($"Saving dataset to {path}");
await IOOperations.SaveAsync <TestcaseBlockerDataset>(path, dataset);
}
public void EnsureCopiedDatasetIsSameInstanceAsOriginalDataset()
{
var numBlockers = 10;
var numTestcases = 50;
TestcaseBlockerDataset originalDataset = DataGenerator.GenerateRandomData(numBlockers, numTestcases);
var copiedDataset = originalDataset;
var originalTestcase = originalDataset.Testcases.Where(x => x.BlockerIds.Count > 0).FirstOrDefault();
var copiedTestcase = copiedDataset.Testcases.Where(x => x.Id == originalTestcase.Id).FirstOrDefault();
Assert.IsTrue(originalTestcase.Name == copiedTestcase.Name);
Assert.IsTrue(originalTestcase.BlockerIds.Count == copiedTestcase.BlockerIds.Count);
copiedTestcase.BlockerIds.Clear();
Assert.IsTrue(originalTestcase.BlockerIds.Count == copiedTestcase.BlockerIds.Count);
}
public void EnsureDeepClonedDatasetIsDifferentInstanceThanOriginalDataset()
{
var numBlockers = 10;
var numTestcases = 50;
TestcaseBlockerDataset originalDataset = DataGenerator.GenerateRandomData(numBlockers, numTestcases);
var clonedDataset = (TestcaseBlockerDataset)CloneHelper.GetDeepClone(originalDataset);
var originalTestcase = originalDataset.Testcases.Where(x => x.BlockerIds.Count > 0).FirstOrDefault();
var clonedTestcase = clonedDataset.Testcases.Where(x => x.Id == originalTestcase.Id).FirstOrDefault();
Assert.IsTrue(originalTestcase.Name == clonedTestcase.Name);
Assert.IsTrue(originalTestcase.BlockerIds.Count == clonedTestcase.BlockerIds.Count);
clonedTestcase.BlockerIds.Clear();
Assert.IsFalse(originalTestcase.BlockerIds.Count == clonedTestcase.BlockerIds.Count);
}
public static async Task RunOptimization(TestcaseBlockerDataset dataset)
{
if (dataset is null)
{
Console.WriteLine("Cannot run optimization for an empty dataset. First generate or load a dataset.");
return;
}
var debugOutput = true;
Console.Write("Suppress output information for each generation (y)? ");
if (Console.ReadLine().ToLower() == "y")
{
debugOutput = false;
}
var watch = new Stopwatch();
watch.Start();
var optimizer = new Optimizer(dataset);
if (debugOutput)
{
optimizer.ChromosomeEvaluated += Optimizer_ChromosomeEvaluated;
optimizer.GenerationEvaluated += Optimizer_GenerationEvaluated;
}
else
{
optimizer.GenerationEvaluated += Optimizer_GenerationProgress;
}
var result = optimizer.Optimize();
var duration = TimeSpan.FromMilliseconds(watch.ElapsedMilliseconds);
watch.Stop();
var resolvedBlockers = string.Join(",", result.ResolvedBlockers.Select(x => x.Name).ToList());
if (resolvedBlockers.Length > 100)
{
resolvedBlockers = resolvedBlockers.Substring(0, 97) + "...";
}
var resolvedTestcases = string.Join(",", result.ResolvedTestcases.Select(x => x.Id).ToList());
if (resolvedTestcases.Length > 100)
{
resolvedTestcases = resolvedTestcases.Substring(0, 97) + "...";
}
var resolvedTestcasesIncludingUnblocked = string.Join(",", result.ResolvedTestcasesIncludingUnblocked.Select(x => x.Id).ToList());
if (resolvedTestcasesIncludingUnblocked.Length > 100)
{
resolvedTestcasesIncludingUnblocked = resolvedTestcasesIncludingUnblocked.Substring(0, 97) + "...";
}
Console.WriteLine();
Console.WriteLine($"Duration : {duration.ToString()} (including output)");
Console.WriteLine($"Best solution fitness : {result.Fitness}");
Console.WriteLine($"Resolved Blockers : ({result.NumberOfResolvedBlockers}/{result.Cost}) [{resolvedBlockers}]");
Console.WriteLine($"Resolved Testcases : ({result.NumberOfResolvedTestcases}/{result.Value}) [{resolvedTestcases}]");
Console.WriteLine($"Resolved Testcases w/unblocked: ({result.NumberOfResolvedTestcasesIncludingUnblocked}/{result.ValueIncludingUnblocked}) [{resolvedTestcasesIncludingUnblocked}]");
Console.WriteLine();
Console.Write("Save result (y|n)? ");
var saveResult = Console.ReadLine().Trim().ToLower();
if (saveResult == "y")
{
Console.Write("Enter filename without extension: ");
string filename = Console.ReadLine();
var path = Path.Combine(GetDataPath(), filename + ".json");
Console.WriteLine($"Saving result to {path}");
await IOOperations.SaveAsync <OptimizationResult>(path, result);
}
}
static async Task Main(string[] args)
{
var runApp = true;
TestcaseBlockerDataset dataset = null;
while (runApp)
{
PrintMenu();
var choice = Console.ReadLine();
switch (choice.ToLower())
{
case "q":
runApp = false;
break;
case "0":
dataset = ImportDataset();
Console.ReadKey();
break;
case "1":
dataset = await GenerateDataset();
Console.ReadKey();
break;
case "2":
ShowAvailableDatasets();
Console.ReadKey();
break;
case "3":
dataset = await LoadDataset();
Console.ReadKey();
break;
case "4":
await SaveDataset(dataset);
Console.ReadKey();
break;
case "5":
await ExportDataset(dataset);
Console.ReadKey();
break;
case "6":
await RunOptimization(dataset);
Console.ReadKey();
break;
default:
break;
}
}
}
public BlockerResolverResult(TestcaseBlockerDataset initialDataset, TestcaseBlockerDataset resolvedDataset)
{
_initialDataset = initialDataset;
_resolvedDataset = resolvedDataset;
}
private DataView ConvertDatasetToTable(TestcaseBlockerDataset dataset)
{
if (dataset == null)
{
return(null);
}
var table = new DataTable();
// Spalten
table.Columns.Add(new DataColumn("#", typeof(int)));
table.Columns.Add(new DataColumn("Testcase Id", typeof(string)));
table.Columns.Add(new DataColumn("Testcase Name", typeof(string)));
table.Columns.Add(new DataColumn("Test Type", typeof(string)));
table.Columns.Add(new DataColumn("App. Module", typeof(string)));
table.Columns.Add(new DataColumn("Value", typeof(string)));
Dictionary <string, int> sumOfBlockedTestcases = new Dictionary <string, int>();
foreach (var blocker in dataset.Blockers)
{
table.Columns.Add(new DataColumn(blocker.Name, typeof(string)));
sumOfBlockedTestcases.Add(blocker.Id, 0);
}
table.Columns.Add(new DataColumn("Number of Blockers", typeof(int)));
// Zeilen
for (var testcaseIndex = 0; testcaseIndex < dataset.Testcases.Count; testcaseIndex++)
{
var testcase = dataset.Testcases[testcaseIndex];
var newRow = table.NewRow();
newRow[0] = testcaseIndex + 1;
newRow[1] = testcase.Id;
newRow[2] = testcase.Name;
newRow[3] = testcase.TestType;
newRow[4] = testcase.ApplicationModule;
newRow[5] = dataset.GetValueForTestcases(new List <Testcase> {
testcase
});
for (int i = 0; i < dataset.Blockers.Count; i++)
{
var blockerId = dataset.Blockers[i].Id;
if (testcase.BlockerIds.Contains(blockerId))
{
newRow[i + 6] = "x";
sumOfBlockedTestcases[blockerId]++;
}
}
newRow[dataset.Blockers.Count + 6] = testcase.BlockerIds.Count;
table.Rows.Add(newRow);
}
// Ergebniszeile
var resultRow = table.NewRow();
for (int i = 0; i < dataset.Blockers.Count; i++)
{
var blockerId = dataset.Blockers[i].Id;
var blocked = sumOfBlockedTestcases[blockerId];
resultRow[i + 6] = blocked;
}
table.Rows.Add(resultRow);
return(table.DefaultView);
}
public static TestcaseBlockerDataset ImportFromExcel(string filename, ExcelImportOptions options)
{
if (string.IsNullOrEmpty(options.WorksheetName))
{
throw new ArgumentException("WorksheetName is empty");
}
if (string.IsNullOrEmpty(options.BlockerSeparator))
{
throw new ArgumentException("BlockerSeparator is empty");
}
if (options.ColumnNumberTestcaseId <= 0)
{
throw new ArgumentException("ColumnNumberTestcaseId must be greater than zero.");
}
if (options.ColumnNumberTestcaseName <= 0)
{
throw new ArgumentException("ColumnNumberTestcaseName must be greater than zero.");
}
if (options.ColumnNumberBlockerNames <= 0)
{
throw new ArgumentException("ColumnNumberBlockerNames must be greater than zero.");
}
if (options.FirstDataRow <= 0)
{
throw new ArgumentException("FirstDataRow must be greater than zero.");
}
try
{
var blockers = new List <Blocker>();
var testcases = new List <Testcase>();
FileInfo existingFile = new FileInfo(filename);
using (var excel = new ExcelPackage(existingFile))
{
var ws = excel.Workbook.Worksheets[options.WorksheetName];
if (!options.LastDataRow.HasValue)
{
options.LastDataRow = ws.Dimension.End.Row;
}
for (int row = options.FirstDataRow; row <= options.LastDataRow.Value; row++)
{
var testcaseId = (Convert.ToString(ws.Cells[row, options.ColumnNumberTestcaseId].Value)).Trim();
var testcaseName = (Convert.ToString(ws.Cells[row, options.ColumnNumberTestcaseName].Value)).Trim();
var blockerNamesString = (Convert.ToString(ws.Cells[row, options.ColumnNumberBlockerNames].Value)).Trim();
var blockerNames = new List <string>(blockerNamesString.Split(options.BlockerSeparator.ToCharArray()));
var testtype = options.ColumnNumberTestType.HasValue ? (Convert.ToString(ws.Cells[row, options.ColumnNumberTestType.Value].Value)).Trim() : string.Empty;
var applicationModule = options.ColumnNumberApplicationModule.HasValue ? (Convert.ToString(ws.Cells[row, options.ColumnNumberApplicationModule.Value].Value)).Trim(): string.Empty;
var testcase = new Testcase
{
Id = testcaseId,
Name = testcaseName,
TestType = testtype,
ApplicationModule = applicationModule
};
foreach (var blockerName in blockerNames)
{
var trimmedBlockerName = blockerName.Trim().ToLower();
if (!string.IsNullOrEmpty(trimmedBlockerName))
{
var existingBlocker = blockers.Where(x => x.Name == trimmedBlockerName).FirstOrDefault();
if (existingBlocker == null)
{
existingBlocker = new Blocker
{
Id = Guid.NewGuid().ToString().Replace("-", ""),
Name = trimmedBlockerName,
Cost = 1
};
blockers.Add(existingBlocker);
}
if (!testcase.BlockerIds.Contains(existingBlocker.Id))
{
testcase.BlockerIds.Add(existingBlocker.Id);
}
}
}
testcases.Add(testcase);
}
}
var dataset = new TestcaseBlockerDataset
{
Blockers = blockers,
Testcases = testcases
};
return(dataset);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw;
}
}
public Optimizer(TestcaseBlockerDataset dataset)
{
_dataset = dataset;
_resolver = new BlockerResolver(_dataset);
}
