public void Load_ValidFile_CorrectEntriesAreLoaded()
{
// Arrange
var builder = LogFiltersBuilder.Create().WithEnterMethodLogsHidden().WithMethodDurationHidden().WithSingleLineFormat();
builder.ExcludeTheseMethodNames(new string[] { @"\.ctor" });
builder.IncludeTheseMethodNames(new string[] { "Insuranceline.Ethil" });
var fileName = System.IO.Path.GetTempFileName();
var expectedFilters = builder.Build();
LogFilterFileHandler.Save(fileName, expectedFilters);
// Act
var loadedFilters = LogFilterFileHandler.Load(fileName);
System.IO.File.Delete(fileName);
// Assert
Assert.That(loadedFilters, Is.Not.Null);
Assert.That(loadedFilters.HideEnterMethodLogs, Is.EqualTo(expectedFilters.HideEnterMethodLogs));
Assert.That(loadedFilters.HideExitMethodLogs, Is.EqualTo(expectedFilters.HideExitMethodLogs));
Assert.That(loadedFilters.HideMethodDuration, Is.EqualTo(expectedFilters.HideMethodDuration));
Assert.That(loadedFilters.HideMethodParameters, Is.EqualTo(expectedFilters.HideMethodParameters));
Assert.That(loadedFilters.HideMethodReturnValue, Is.EqualTo(expectedFilters.HideMethodReturnValue));
Assert.That(loadedFilters.HideTimeStampInMethod, Is.EqualTo(expectedFilters.HideTimeStampInMethod));
Assert.That(loadedFilters.IgnoreCaseInFilter, Is.EqualTo(expectedFilters.IgnoreCaseInFilter));
Assert.That(loadedFilters.SingleLineFormat, Is.EqualTo(expectedFilters.SingleLineFormat));
Assert.That(loadedFilters.TimeStampFrom, Is.EqualTo(expectedFilters.TimeStampFrom));
Assert.That(loadedFilters.TimeStampTo, Is.EqualTo(expectedFilters.TimeStampTo));
Assert.That(loadedFilters.ExcludedKeysExpressionList, Is.EquivalentTo(expectedFilters.ExcludedKeysExpressionList));
Assert.That(loadedFilters.IncludedKeysExpressionList, Is.EquivalentTo(expectedFilters.IncludedKeysExpressionList));
}
public static void Save(string settingsFilePath, ILogFilters filters)
{
var serial = new XmlSerializer(typeof(LogFiltersBuilder));
var settings = new XmlWriterSettings()
{
Indent = true
};
using (var writer = XmlWriter.Create(settingsFilePath, settings))
{
serial.Serialize(writer, LogFiltersBuilder.Create(filters));
}
}
public void FormatMethodExit_HideMethodReturnValueIsSet_ExpectedTextIsReturned()
{
// Arrange
var filters = LogFiltersBuilder.Create().WithMethodReturnValueHidden().Build();
var formatter = new DefaultFormatter();
var entry = new MethodExit(1, "Yalf.TestMethod", 345, true, "returnVal");
var expectedText = "[Exit] Yalf.TestMethod() duration 345ms";
// Act
var outputText = formatter.FormatMethodExit(22, 1, 33, entry, filters, true);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
public void FormatMethodEntry_HideTimeStampInMethodIsSet_ExpectedTextIsReturned()
{
// Arrange
var filters = LogFiltersBuilder.Create().WithTimeStampInMethodHidden().Build();
var formatter = new DefaultFormatter();
var entry = new MethodEntry(1, "Yalf.TestMethod", new[] { "param1", "param2" }, DateTime.Parse("2022-10-22 22:22:31.678"));
var expectedText = "[Enter] Yalf.TestMethod(param1, param2)";
// Act
var outputText = formatter.FormatMethodEntry(22, 1, 33, entry, filters, true);
// Assert
Assert.That(outputText, Is.Not.Empty, "Expected a string to be returned");
Assert.That(outputText, Is.EqualTo(expectedText), "Not the expected output text, you may need to adjust the test if the formatter has been changed.");
}
private ILogFilters GetFiltersFromUiControls()
{
var excluded = this.ExcludedKeyList.Text.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).ToList();
var included = this.IncludedKeyList.Text.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).ToList();
var excludedValidation = ValidateRegex(excluded);
var includedValidation = ValidateRegex(included);
if (excludedValidation.Any() || includedValidation.Any())
{
var includedMessage = "";
var excludedMessage = "";
if (includedValidation.Any())
{
includedMessage = "Included:" + Environment.NewLine + string.Join(Environment.NewLine, includedValidation.Select(t => string.Format("[{0}] {1} => {2}", t.Item2, t.Item1, t.Item3)));
}
if (excludedValidation.Any())
{
excludedMessage = "Excluded:" + Environment.NewLine + string.Join(Environment.NewLine, excludedValidation.Select(t => string.Format("[{0}] {1} => {2}", t.Item2, t.Item1, t.Item3)));
}
MessageBox.Show(includedMessage + Environment.NewLine + excludedMessage, "Error compiling regular expression(s)", MessageBoxButtons.OK);
return(null);
}
var builder = new LogFiltersBuilder();
builder.ExcludedKeysExpressionList = excluded;
builder.IncludedKeysExpressionList = included;
builder.HideEnterMethodLogs = this.chkHideEnterMethod.Checked;
builder.HideExitMethodLogs = this.chkHideExitMethod.Checked;
builder.HideMethodDuration = this.chkHideDuration.Checked;
builder.HideMethodParameters = this.chkHodeMethodParameters.Checked;
builder.HideTimeStampInMethod = this.chkHideTimestamp.Checked;
builder.HideMethodReturnValue = this.chkHideMethodReturnValue.Checked;
builder.SingleLineFormat = this.chkSingleLineFormat.Checked;
builder.IgnoreCaseInFilter = this.chkIgnoreCase.Checked;
builder.TimeStampFrom = (String.IsNullOrWhiteSpace(this.txtTimeStampFrom.Text)) ? DateTime.MinValue : DateTime.Parse(this.txtTimeStampFrom.Text);
builder.TimeStampTo = (String.IsNullOrWhiteSpace(this.txtTimeStampTo.Text)) ? DateTime.MaxValue : DateTime.Parse(this.txtTimeStampTo.Text);
builder.ThreadId = (this.chkUseThreadGroupDisplay.Checked && (this.lstThreadList.SelectedItem != null)) ? (this.lstThreadList.SelectedItem as ListableThreadData).ThreadId : -1;
return(builder.Build());
}
public void FormatMethodExit_HideMethodDurationIsSet_ExpectedTextIsReturned()
{
// Arrange
var filters = LogFiltersBuilder.Create().WithMethodDurationHidden().Build();
var formatter = new SingleLineFormatter();
var entry = new MethodExit(1, "Yalf.TestMethod", 345, true, "returnVal");
var expectedText = "Yalf.TestMethod(returnVal) started 22:22:31.678";
var relatedEntry = new MethodEntry(1, "Yalf.TestMethod", new[] { "param1", "param2" }, DateTime.Parse("2022-10-22 22:22:31.678"));
formatter.FormatMethodEntry(1, 2, 33, relatedEntry, filters, true);
// Act
var orderedOutput = formatter.FormatMethodExitForSingleLineOutput(1, 2, 33, entry, filters, true);
// Assert
Assert.That(orderedOutput.Count, Is.EqualTo(1), "Expected one string to be returned");
Assert.That(orderedOutput[0].Level, Is.EqualTo(0), "Not the expected nested level, you may need to adjust the test if the formatter has been changed.");
Assert.That(orderedOutput[0].FormattedLine, Is.EqualTo(expectedText), "Not the expected formatted line, you may need to adjust the test if the formatter has been changed.");
}
private ILogFilters GetDefaultFilters()
{
var builder = new LogFiltersBuilder();
return(builder.Build());
}
public void FormatMethodExit_MixedNestting_ExpectedTextIsReturned()
{
// Arrange
var filters = LogFiltersBuilder.Create().Build();
var formatter = new DelimitedValuesFormatter();
var startDateTime = DateTime.Now;
int threadId = 22;
int lineNo = 0;
int indentLevel = 0;
var expectedText = (new string[]
{
string.Format("Yalf,Method,TopLevelMethod,blackSheep,{0:HH:mm:ss.fff},233,1,22", startDateTime),
string.Format("Yalf,Method,FirstMethod,,{0:HH:mm:ss.fff},200,1,22", startDateTime.AddSeconds(12)),
string.Format("Yalf,Method,SecondMethod,,{0:HH:mm:ss.fff},178,2,22", startDateTime.AddSeconds(45)),
string.Format("Yalf,Log,Information log message here,,{0:HH:mm:ss.fff},0,2,22", startDateTime.AddSeconds(47)),
string.Format("Yalf,Exception,Test the log Parameter name: lineNo,,{0:HH:mm:ss.fff},0,2,22", startDateTime.AddSeconds(53)),
string.Format("Yalf,Method,ThirdMethod,,{0:HH:mm:ss.fff},100,3,22", startDateTime.AddSeconds(75)),
string.Format("Yalf,Method,TopLevelMethod2,whiteSheep,{0:HH:mm:ss.fff},488,1,22", startDateTime.AddSeconds(99))
}
).ToList();
var entries = new BaseEntry[]
{
new MethodEntry(1, "TopLevelMethod", null, startDateTime),
new MethodExit(1, "TopLevelMethod", 233, true, "blackSheep"),
new MethodEntry(1, "FirstMethod", null, startDateTime.AddSeconds(12)),
new MethodEntry(2, "SecondMethod", null, startDateTime.AddSeconds(45)),
new LogEvent(LogLevel.Info, startDateTime.AddSeconds(47), "Information log message here"),
new ExceptionTrace(new ArgumentNullException("lineNo", "Test the log"), startDateTime.AddSeconds(53)),
new MethodEntry(3, "ThirdMethod", null, startDateTime.AddSeconds(75)),
new MethodExit(3, "ThirdMethod", 100, false, null),
new MethodExit(2, "SecondMethod", 178, false, null),
new MethodExit(1, "FirstMethod", 200, false, null),
new MethodEntry(1, "TopLevelMethod2", null, startDateTime.AddSeconds(99)),
new MethodExit(1, "TopLevelMethod2", 488, true, "whiteSheep"),
};
var actualText = new List <String>();
// Act
foreach (var entry in entries)
{
if (entry is MethodEntry)
{
formatter.FormatMethodEntry(threadId, indentLevel++, ++lineNo, (entry as MethodEntry), filters, true);
}
else if (entry is MethodExit)
{
var result = formatter.FormatMethodExitForSingleLineOutput(threadId, indentLevel--, lineNo++, (entry as MethodExit), filters, true);
if (result != null)
{
actualText.AddRange(result.Select(oo => oo.FormattedLine).ToList());
}
}
else if (entry is LogEvent)
{
var result = formatter.FormatLogEvent(threadId, indentLevel, lineNo++, (entry as LogEvent), filters, true);
if (result != null)
{
actualText.Add(result);
}
}
else if (entry is ExceptionTrace)
{
var result = formatter.FormatException(threadId, indentLevel, lineNo++, (entry as ExceptionTrace), filters);
if (result != null)
{
actualText.Add(result);
}
}
}
// Assert
Console.WriteLine(String.Join(Environment.NewLine, actualText.ToArray()));
Assert.That(actualText.Count, Is.EqualTo(expectedText.Count), "Expected {0} lines to be returned overall, but have {1}.", expectedText.Count, actualText.Count);
for (int logLine = 0; logLine < actualText.Count - 1; logLine++)
{
Assert.That(actualText[logLine], Is.EqualTo(expectedText[logLine]), "Text does not match on line {0}", logLine);
}
//var misMatchedResults = actualText.Where((at, i) => (at != expectedText[i]));
//Assert.That(misMatchedResults.Count(), Is.EqualTo(0), "{0} of the lines do not match.\nExpected:\n{1}\n\nActual:\n{2}"
// , misMatchedResults.Count()
// , String.Join(Environment.NewLine, expectedText.ToArray())
// , String.Join(Environment.NewLine, actualText.ToArray())
// );
}
public void FormatMethodExit_MixedNestting_ExpectedTextIsReturned()
{
// Arrange
var filters = LogFiltersBuilder.Create().Build();
var formatter = new SingleLineFormatter();
var startDateTime = DateTime.Now;
int threadId = 22;
int lineNo = 0;
int indentLevel = 0;
var expectedText = (new string[]
{
string.Format("TopLevelMethod(blackSheep) started {0:HH:mm:ss.fff} duration 233ms", startDateTime),
string.Format("FirstMethod() started {0:HH:mm:ss.fff} duration 200ms", startDateTime.AddSeconds(12)),
string.Format("SecondMethod() started {0:HH:mm:ss.fff} duration 178ms", startDateTime.AddSeconds(45)),
string.Format("[Log] [Info] Information log message here"),
string.Format("[Exception] {0:HH:mm:ss.fff} Test the log\r\nParameter name: lineNo", startDateTime.AddSeconds(53)),
string.Format("ThirdMethod() started {0:HH:mm:ss.fff} duration 100ms", startDateTime.AddSeconds(75)),
string.Format("TopLevelMethod2(whiteSheep) started {0:HH:mm:ss.fff} duration 488ms", startDateTime.AddSeconds(99))
}
).ToList();
var entries = new BaseEntry[]
{
new MethodEntry(1, "TopLevelMethod", null, startDateTime),
new MethodExit(1, "TopLevelMethod", 233, true, "blackSheep"),
new MethodEntry(1, "FirstMethod", null, startDateTime.AddSeconds(12)),
new MethodEntry(2, "SecondMethod", null, startDateTime.AddSeconds(45)),
new LogEvent(LogLevel.Info, startDateTime.AddSeconds(47), "Information log message here"),
new ExceptionTrace(new ArgumentNullException("lineNo", "Test the log"), startDateTime.AddSeconds(53)),
new MethodEntry(3, "ThirdMethod", null, startDateTime.AddSeconds(75)),
new MethodExit(3, "ThirdMethod", 100, false, null),
new MethodExit(2, "SecondMethod", 178, false, null),
new MethodExit(1, "FirstMethod", 200, false, null),
new MethodEntry(1, "TopLevelMethod2", null, startDateTime.AddSeconds(99)),
new MethodExit(1, "TopLevelMethod2", 488, true, "whiteSheep"),
};
var actualText = new List <String>();
// Act
foreach (var entry in entries)
{
if (entry is MethodEntry)
{
formatter.FormatMethodEntry(threadId, indentLevel++, ++lineNo, (entry as MethodEntry), filters, true);
}
else if (entry is MethodExit)
{
var result = formatter.FormatMethodExitForSingleLineOutput(threadId, indentLevel--, lineNo++, (entry as MethodExit), filters, true);
if (result != null)
{
actualText.AddRange(result.Select(oo => oo.FormattedLine).ToList());
}
}
else if (entry is LogEvent)
{
var result = formatter.FormatLogEvent(threadId, indentLevel, lineNo++, (entry as LogEvent), filters, true);
if (result != null)
{
actualText.Add(result);
}
}
else if (entry is ExceptionTrace)
{
var result = formatter.FormatException(threadId, indentLevel, lineNo++, (entry as ExceptionTrace), filters);
if (result != null)
{
actualText.Add(result);
}
}
}
// Assert
Assert.That(actualText.Count, Is.EqualTo(expectedText.Count), "Expected {0} lines to be returned overall, but have {1}.", expectedText.Count, actualText.Count);
var misMatchedResults = actualText.Where((at, i) => (at != expectedText[i]));
Assert.That(misMatchedResults.Count(), Is.EqualTo(0), "{0} of the lines do not match.\nExpected:\n{1}\n\nActual:\n{2}"
, misMatchedResults.Count()
, String.Join(Environment.NewLine, expectedText.ToArray())
, String.Join(Environment.NewLine, actualText.ToArray())
);
}
