public void ForOddExecutionsCount_ShouldComputeMedianCorrectly()
{
//Act
for (int j = 0; j < 32; j++)
{
var execution = ExecutionTimeCounter.Start("0");
Thread.Sleep(1);
ExecutionTimeCounter.Stop(execution);
executionsDictionary["0"].Add(execution.Elapsed.TotalMilliseconds);
}
var results = ExecutionTimeCounter.Results();
//Assert
var medianExpected = executionsDictionary["0"].OrderBy(x => x).ElementAt(23);
Assert.AreEqual(medianExpected, results.Single(r => r.SectionName == "0").Median.TotalMilliseconds, 0.001);
for (int i = 1; i < iterations; i++)
{
medianExpected = executionsDictionary[i.ToString()].OrderBy(x => x).ElementAt(7);
Assert.AreEqual(medianExpected, results.Single(r => r.SectionName == i.ToString()).Median.TotalMilliseconds, 0.001);
}
}
public void ForThreeExecutions_ShouldComputeMedianCorrectly()
{
//Act
List <double> executions = new List <double>();
var execution1 = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(1);
ExecutionTimeCounter.Stop(execution1);
executions.Add(execution1.Elapsed.TotalMilliseconds);
var execution2 = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(6);
ExecutionTimeCounter.Stop(execution2);
executions.Add(execution2.Elapsed.TotalMilliseconds);
var execution3 = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(1);
ExecutionTimeCounter.Stop(execution3);
executions.Add(execution3.Elapsed.TotalMilliseconds);
var medianExpected = executions.OrderBy(x => x).ElementAt(1);
var median = ExecutionTimeCounter.Results().Single(r => r.SectionName == "TEST").Median;
//Assert
Assert.AreEqual(medianExpected, median.TotalMilliseconds, 0.001);
}
public void ShouldReturnNotEmptyExecution()
{
//Arrange & Act
var execution = ExecutionTimeCounter.Start("SectionName");
//Assert
Assert.IsNotNull(execution);
}
public void ShouldInitializeExecutionWithCorrectSectionName(string sectionName)
{
//Arrange & Act
var execution = ExecutionTimeCounter.Start(sectionName);
//Assert
Assert.AreEqual(sectionName, execution.SectionName);
}
public void ShouldClearExecutions()
{
//Act
CreateExecutions(5, 1);
ExecutionTimeCounter.Reset();
//Assert
Assert.AreEqual(0, ExecutionTimeCounter.Executions.Count);
}
public void ShouldReturnStartedExecution()
{
//Arrange & Act
var execution = ExecutionTimeCounter.Start("SectionName");
Thread.Sleep(1);
//Assert
Assert.Greater(execution.Elapsed, new TimeSpan(0));
}
public void ShouldContainExpectedNumberOfLines()
{
//Act
var result = ExecutionTimeCounter.ResultsToString();
//Assert
int expectedLinesPerSection = 7;
Assert.AreEqual(iterations * expectedLinesPerSection, new Regex(Environment.NewLine).Matches(result).Count);
}
public void ShouldContainAllSectionNames()
{
//Act
var result = ExecutionTimeCounter.ResultsToString();
//Assert
for (int i = 0; i < 5; i++)
{
Assert.IsTrue(result.Contains($"{i}:"));
}
}
public void ShouldReturnAllExecutions()
{
//Act
var results = ExecutionTimeCounter.Results();
//Assert
foreach (var result in results)
{
Assert.AreEqual(iterations * 3, result.Executions.Count);
}
}
public void ShouldComputeSlowestCorrectly()
{
//Act
var results = ExecutionTimeCounter.Results();
//Assert
foreach (var result in results)
{
double slowestExpected = executionsDictionary[result.SectionName].Max();
Assert.AreEqual(slowestExpected, result.Slowest.TotalMilliseconds, 0.001);
}
}
public void ShouldComputeAverageCorrectly()
{
//Act
var results = ExecutionTimeCounter.Results();
//Assert
foreach (var result in results)
{
double averageExpected = executionsDictionary[result.SectionName].Average();
Assert.AreEqual(averageExpected, result.Average.TotalMilliseconds, 0.001);
}
}
public void ShouldReturnAllCodeSections()
{
//Act
var results = ExecutionTimeCounter.Results();
//Assert
Assert.AreEqual(iterations, results.Count);
foreach (var result in results)
{
Assert.AreEqual(1, results.Count(r => r.SectionName == result.SectionName));
}
}
public void ForOneExecution_ShouldComputeMedianCorrectly()
{
//Act
var execution = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(4);
ExecutionTimeCounter.Stop(execution);
var median = ExecutionTimeCounter.Results().Single(r => r.SectionName == "TEST").Median;
//Assert
Assert.AreEqual(execution.Elapsed, median);
}
public void ShouldStopStopwatch()
{
//Arrange & Act
var execution = ExecutionTimeCounter.Start("SectionName");
ExecutionTimeCounter.Stop(execution);
var elapsed = execution.Elapsed;
Thread.Sleep(1);
//Assert
Assert.AreEqual(elapsed, execution.Elapsed);
}
public void ShouldContainAllStats()
{
//Act
var result = ExecutionTimeCounter.ResultsToString();
//Assert
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(iterations, new Regex("Average").Matches(result).Count);
Assert.AreEqual(iterations, new Regex("Median").Matches(result).Count);
Assert.AreEqual(iterations, new Regex("Fastest").Matches(result).Count);
Assert.AreEqual(iterations, new Regex("Slowest").Matches(result).Count);
Assert.AreEqual(iterations, new Regex("Executions").Matches(result).Count);
}
}
public void ShouldAlwaysReturnNewExecution()
{
//Arrange
var iterations = 5;
var executions = new List <Execution>();
//Act
for (int i = 0; i < iterations; i++)
{
executions.Add(ExecutionTimeCounter.Start("SectionName"));
}
//Assert
for (int i = 0; i < iterations; i++)
{
Assert.AreEqual(1, executions.Count(e => e == executions[i]));
}
}
protected void CreateExecutions(int iterations, int sleepTime)
{
for (int i = 0; i < iterations; i++)
{
if (!executionsDictionary.ContainsKey(i.ToString()))
{
executionsDictionary.Add(i.ToString(), new List <double>());
}
for (int j = 0; j < iterations; j++)
{
var execution = ExecutionTimeCounter.Start(i.ToString());
Thread.Sleep(sleepTime);
ExecutionTimeCounter.Stop(execution);
executionsDictionary[i.ToString()].Add(execution.Elapsed.TotalMilliseconds);
}
}
}
public void ForTwoExecutions_ShouldComputeMedianCorrectly()
{
//Act
var execution1 = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(3);
ExecutionTimeCounter.Stop(execution1);
var execution2 = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(5);
ExecutionTimeCounter.Stop(execution2);
var medianExpected = (execution1.Elapsed.TotalMilliseconds + execution2.Elapsed.TotalMilliseconds) / 2.0;
var median = ExecutionTimeCounter.Results().Single(r => r.SectionName == "TEST").Median;
//Assert
Assert.AreEqual(medianExpected, median.TotalMilliseconds, 0.001);
}
public void ForEvenUnsortedExecutionsCount_ShouldComputeMedianCorrectly()
{
//Act
List <double> executions = new List <double>();
var execution = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(5);
ExecutionTimeCounter.Stop(execution);
executions.Add(execution.Elapsed.TotalMilliseconds);
execution = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(1);
ExecutionTimeCounter.Stop(execution);
executions.Add(execution.Elapsed.TotalMilliseconds);
execution = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(3);
ExecutionTimeCounter.Stop(execution);
executions.Add(execution.Elapsed.TotalMilliseconds);
execution = ExecutionTimeCounter.Start("TEST");
Thread.Sleep(7);
ExecutionTimeCounter.Stop(execution);
executions.Add(execution.Elapsed.TotalMilliseconds);
var orderedExecutions = executions.OrderBy(x => x);
var medianExpected = (orderedExecutions.ElementAt(1) + orderedExecutions.ElementAt(2)) / 2.0;
var medianActual = ExecutionTimeCounter.Results().Single(r => r.SectionName == "TEST").Median;
//Assert
Assert.AreEqual(medianExpected, medianActual.TotalMilliseconds, 0.001);
}
public void TearDown()
{
ExecutionTimeCounter.Reset();
executionsDictionary.Clear();
}
public void TearDown()
{
ExecutionTimeCounter.Reset();
}
