private static void Compare(CommandLineOptions args, IResultsComparerProvider comparerProvider, IReporterProvider reporterProvider)
{
try
{
IResultsComparer comparer = string.IsNullOrEmpty(args.Comparer) ?
comparerProvider.GetForFile(args.BasePath) : comparerProvider.GetById(args.Comparer);
Console.WriteLine($"Comparer selected: {comparer.Name}\n");
ComparerOptions options = new()
{
StatisticalTestThreshold = args.StatisticalTestThreshold,
NoiseThreshold = args.NoiseThreshold,
FullId = args.FullId,
TopCount = args.TopCount,
Filters = args.Filters,
Metric = args.Metric
};
ComparerResults results = comparer.CompareResults(args.BasePath, args.DiffPath, options);
IReporter reporter = reporterProvider.GetDefault();
Stream output = Console.OpenStandardOutput();
reporter.GenerateReport(results, output, options, leaveStreamOpen: true);
}
catch (Exception ex)
{
Console.Error.WriteLine($"Error: {ex.Message}");
}
}
private static async Task Compare(CommandLineOptions args)
{
IResultsComparer comparer = new BdnComparer();
try
{
ComparerOptions options = new()
{
StatisticalTestThreshold = args.StatisticalTestThreshold,
NoiseThreshold = args.NoiseThreshold,
FullId = args.FullId,
TopCount = args.TopCount,
Filters = args.Filters
};
ComparerResults results = await comparer.CompareResults(args.BasePath, args.DiffPath, options);
if (results.NoDiff)
{
return;
}
ComparerResult[] resultsArray = results.Results.ToArray();
PrintSummary(resultsArray);
PrintTable(resultsArray, EquivalenceTestConclusion.Slower, args);
PrintTable(resultsArray, EquivalenceTestConclusion.Faster, args);
}
catch (Exception ex)
{
Console.Error.WriteLine($"Error: {ex.Message}");
}
}
public void ComparesObjectAllocationsReportFiles()
{
string basePath = "Samples/VsProfiler/VsProfilerObjectAllocations.txt";
string diffPath = "Samples/VsProfiler/VsProfilerObjectAllocations2.txt";
VsTypeAllocationsComparer comparer = new();
ComparerOptions options = new();
ComparerResults results = comparer.CompareResults(basePath, diffPath, options);
Assert.Equal("Allocations", results.MetricName);
Dictionary <string, ComparerResult> comparisons = results.Results.ToDictionary(r => r.Id);
Assert.Equal(6, comparisons.Count);
// entries with same results are excluded
Assert.False(comparisons.ContainsKey("System.Collections.Generic.List<>.Enumerator"));
Assert.False(comparisons.ContainsKey("System.Linq.Enumerable.EnumerablePartition<>"));
// diffs with smaller allocation values are considered better
var listComparison = comparisons["System.Collections.Generic.List<>"];
Assert.Equal(237933, listComparison.BaseResult.Result);
Assert.Equal(237000, listComparison.DiffResult.Result);
Assert.Equal(ComparisonConclusion.Better, listComparison.Conclusion);
var stringComparison = comparisons["System.String"];
Assert.Equal(128696, stringComparison.BaseResult.Result);
Assert.Equal(125696, stringComparison.DiffResult.Result);
Assert.Equal(ComparisonConclusion.Better, stringComparison.Conclusion);
// diffs with larger allocation values are considered worse
var intComparison = comparisons["System.Int32"];
Assert.Equal(115446, intComparison.BaseResult.Result);
Assert.Equal(125446, intComparison.DiffResult.Result);
Assert.Equal(ComparisonConclusion.Worse, intComparison.Conclusion);
// entries that exist in the base but not in the diff are considered missing
var collectionComparison = comparisons["System.Collections.ObjectModel.Collection<>"];
Assert.Equal(125001, collectionComparison.BaseResult.Result);
Assert.Null(collectionComparison.DiffResult);
Assert.Equal(ComparisonConclusion.Missing, collectionComparison.Conclusion);
// entries that exist in the diff but not the base are considered new
var odataPropertyComparison = comparisons["Microsoft.OData.ODataProperty"];
Assert.Null(odataPropertyComparison.BaseResult);
Assert.Equal(45000, odataPropertyComparison.DiffResult.Result);
Assert.Equal(ComparisonConclusion.New, odataPropertyComparison.Conclusion);
var arrayEnumeratorComparison = comparisons["System.SZGenericArrayEnumerator<>"];
Assert.Null(arrayEnumeratorComparison.BaseResult);
Assert.Equal(50147, arrayEnumeratorComparison.DiffResult.Result);
Assert.Equal(ComparisonConclusion.New, arrayEnumeratorComparison.Conclusion);
}
/// <inheritdoc/>
public void GenerateReport(ComparerResults results, Stream destination, ComparerOptions options, bool leaveStreamOpen = false)
{
ComparerResult[] resultsArray = results.Results.ToArray();
if (resultsArray.Length == 0)
{
return;
}
using StreamWriter writer = new(destination, leaveOpen : leaveStreamOpen);
PrintSummary(resultsArray, writer);
PrintTable(resultsArray, results.MetricName, ComparisonConclusion.Worse, writer, options);
PrintTable(resultsArray, results.MetricName, ComparisonConclusion.Better, writer, options);
PrintTable(resultsArray, results.MetricName, ComparisonConclusion.New, writer, options);
PrintTable(resultsArray, results.MetricName, ComparisonConclusion.Missing, writer, options);
writer.Flush();
}
public void ComparerReportFilesAndGenerateMarkdownReport(string comparerId, ComparerOptions options, string basePath, string diffPath, string reportPath)
{
IResultsComparerProvider comparerProvider = ComparerProviderFactory.CreateDefaultProvider();
IResultsComparer comparer = comparerProvider.GetById(comparerId);
ComparerResults results = comparer.CompareResults(basePath, diffPath, options);
MarkdownReporter reporter = new();
using MemoryStream output = new();
reporter.GenerateReport(results, output, options, leaveStreamOpen: true);
output.Seek(0, SeekOrigin.Begin);
string expectedReport = File.ReadAllText(reportPath);
string actualReport = new StreamReader(output).ReadToEnd();
Assert.Equal(expectedReport, actualReport);
}
