public void PushSimpleTest(string message, eMessageCategory category)
{
//Arrange
tc._msg.Text.Synchron = message;
tc._msg.Category.Synchron = (short)category;
tc._logger._plcCarret.Synchron = 0;
tc._logger.MinLogLevelCategory = category;
var index = tc._logger._plcCarret.Synchron;
//Act
tc.ExecuteProbeRun(3, (int)eTcoLoggerTests.SimplePush);
var msgs = tc._logger.Pop();
tc._logger.LogMessages(msgs);
Assert.AreEqual(3, msgs.Count());
//Assert
Assert.AreEqual(tc._msg.Text.Synchron, tc._logger._buffer[index].Text.Synchron);
Assert.AreEqual(tc._msg.Category.Synchron, tc._logger._buffer[index].Category.Synchron);
var logger = TcOpen.Inxton.TcoAppDomain.Current.Logger as DummyLoggerAdapter;
Assert.AreEqual(($"{message} {{@sender}}"), logger.LastMessage.message);
Assert.AreEqual(TranslateMessageCategoryToLogCategory(category), logger.LastMessage.serverity);
}
private string TranslateMessageCategoryToLogCategory(eMessageCategory category)
{
switch (category)
{
case eMessageCategory.Debug:
return("Debug");
case eMessageCategory.Trace:
return("Verbose");
case eMessageCategory.Info:
return("Information");
case eMessageCategory.TimedOut:
case eMessageCategory.Notification:
case eMessageCategory.Warning:
return("Warning");
case eMessageCategory.Error:
case eMessageCategory.ProgrammingError:
return("Error");
case eMessageCategory.Critical:
case eMessageCategory.Catastrophic:
return("Fatal");
case eMessageCategory.None:
break;
default:
return(string.Empty);
}
return(string.Empty);
}
public void PushCustomLoggerTest(string message, eMessageCategory category)
{
//Arrange
tc._msg.Text.Synchron = message;
tc._msg.Category.Synchron = (short)category;
tc._logger._plcCarret.Synchron = 0;
tc._logger.MinLogLevelCategory = category;
var index = tc._logger._plcCarret.Synchron;
var customLogger = new DummyLoggerAdapter();
tc._logger.InxtonLogger = customLogger;
//Act
tc.ExecuteProbeRun(1, (int)eTcoLoggerTests.PushMessage);
tc._logger.LogMessages(tc._logger.Pop());
//Assert
Assert.AreEqual(tc._msg.Text.Synchron, tc._logger._buffer[index].Text.Synchron);
Assert.AreEqual(tc._msg.Category.Synchron, tc._logger._buffer[index].Category.Synchron);
var logger = customLogger;
Assert.AreEqual(($"{message} {{@sender}}"), logger.LastMessage.message);
Assert.AreEqual(TranslateMessageCategoryToLogCategory(category), logger.LastMessage.serverity);
}
public void MinCategoryLevel_set(string message, eMessageCategory category, int expectedNoOfLogEntries)
{
tc._logger.MinLogLevelCategory = category;
tc._logger.Pop();
List <(string text, eMessageCategory cat)> messages = new List <(string text, eMessageCategory cat)>()
{
("This is (all) message", TcoCore.eMessageCategory.All),
("This is debug message", TcoCore.eMessageCategory.Debug),
("This is trace message", TcoCore.eMessageCategory.Trace),
("This is info message", TcoCore.eMessageCategory.Info),
("This is notification message", TcoCore.eMessageCategory.Notification),
("This is timed-out message", TcoCore.eMessageCategory.TimedOut),
("This is warning message", TcoCore.eMessageCategory.Warning),
("This is error message", TcoCore.eMessageCategory.Error),
("This is programming error message", TcoCore.eMessageCategory.ProgrammingError),
("This is critical message", TcoCore.eMessageCategory.Critical),
("This is catastrophic message", TcoCore.eMessageCategory.Catastrophic),
("This is (none) message", TcoCore.eMessageCategory.None)
};
foreach (var msg in messages)
{
tc._multiplesCount.Synchron = 1;
tc._msg.Text.Synchron = msg.text;
tc._msg.Category.Synchron = (short)msg.cat;
tc.ExecuteProbeRun(1, (int)eTcoLoggerTests.PushMessageMultipleInMoreCycles);
}
var actual = tc._logger.Pop();
Assert.AreEqual(expectedNoOfLogEntries, actual.Count());
}
public void T811_flush_message_to_plain_test()
{
var msgCategories = new eMessageCategory[] { eMessageCategory.Debug,
eMessageCategory.Trace,
eMessageCategory.Info,
eMessageCategory.TimedOut,
eMessageCategory.Notification,
eMessageCategory.Warning,
eMessageCategory.Error,
eMessageCategory.ProgrammingError,
eMessageCategory.Critical,
eMessageCategory.Catastrophic };
sut.SingleCycleRun(() => {
foreach (var category in msgCategories)
{
//--Arrange
var messageText = $"this is a {category} message";
//--Act
sut._category.Synchron = (short)category;
sut.Post(messageText);
//--Assert
Assert.AreEqual(sut.GetParent <TcoMessengerContextTest>()._startCycleCount.Synchron, sut._messenger._mime.PlainMessage.Cycle);
Assert.AreEqual(sut._messenger._mime.Text.Synchron, sut._messenger._mime.PlainMessage.Text);
Assert.AreEqual((eMessageCategory)sut._messenger._mime.Category.Synchron, (eMessageCategory)sut._messenger._mime.PlainMessage.Category);
Assert.AreEqual(sut._messenger._mime.TimeStamp.Synchron, sut._messenger._mime.PlainMessage.TimeStamp);
}
});
}
/// <summary>
/// Starts the event retrieval loop.
/// <note type="important">
/// The log retrieval operations for given logger can be started on one system only.
/// Make sure you do not run the log retrieval from the same logger in multiple instances.
/// </note>
/// </summary>
/// <param name="minLevelCategory">Sets the minimal logging level.</param>
/// <param name="interLoopDelay">Sets the delay between retrievals of logs.</param>
/// <param name="logTarget">Set custom log target. If default|null default application logger is used.</param>
public void StartLoggingMessages(eMessageCategory minLevelCategory, int interLoopDelay = 25, ILogger logTarget = null)
{
this._minLoggingLevel.Synchron = (short)minLevelCategory;
this.InxtonLogger = logTarget == null ? TcOpen.Inxton.TcoAppDomain.Current.Logger : logTarget;
Task.Run(() =>
{
while (true)
{
System.Threading.Thread.Sleep(interLoopDelay);
LogMessages(Pop());
}
});
}
public void T810_PostLevelUpSeverityTest()
{
var msgCategories = new eMessageCategory[] { eMessageCategory.Debug,
eMessageCategory.Trace,
eMessageCategory.Info,
eMessageCategory.TimedOut,
eMessageCategory.Notification,
eMessageCategory.Warning,
eMessageCategory.Error,
eMessageCategory.ProgrammingError,
eMessageCategory.Critical,
eMessageCategory.Catastrophic };
sut.SingleCycleRun(() => {
foreach (var category in msgCategories)
{
//--Arrange
var messageText = $"this is a {category} message";
//--Act
sut._category.Synchron = (short)category;
sut.Post(messageText);
//--Assert
Assert.AreEqual(sut.GetParent <TcoMessengerContextTest>()._startCycleCount.Synchron, sut._messenger._mime.Cycle.Synchron);
Assert.AreEqual(messageText, sut._messenger._mime.Text.Synchron);
Assert.AreEqual((eMessageCategory)sut._messenger._mime.Category.Synchron, category);
//Peter's original code
//Assert.IsTrue(sut._messenger._mime.TimeStamp.Synchron >= DateTime.Now.Subtract(new TimeSpan(0, 0, 0)));
//Code changed by Tomas
DateTime _plcTimeStamp = sut._messenger._mime.TimeStamp.Synchron;
DateTime _dotNetTime = DateTime.Now;
TimeSpan _diff = _dotNetTime - _plcTimeStamp;
Assert.LessOrEqual(_diff.TotalMilliseconds, 1000);
}
});
}
