static void Main(string[] args)
{
ILog logger = new AsyncLog();
for (int i = 0; i < 15; i++)
{
logger.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
logger.Flush();
logger.Stop();
ILog logger2 = new AsyncLog();
for (int i = 50; i > 0; i--)
{
logger2.Write("Number with No flush: " + i.ToString());
Thread.Sleep(20);
}
logger2.Stop();
Console.ReadLine();
}
public void testNewLogFileNextDay()
{
fileName = "test2";
AsyncLog test2 = new AsyncLog(fileName, filePath, threadSleep);
DateTime today = new DateTime();
Random rnd = new Random();
int startFiles;
int finishFiles;
int logSize = 100;
int randomNr = rnd.Next(26, 28);
startFiles = Directory.GetFiles(filePath).Length;
today = DateTime.Now;
for (int i = 0; i < logSize; i++)
{
if (i == randomNr)
{
test2.setDate(today.AddDays(randomNr));
}
test2.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
finishFiles = Directory.GetFiles(filePath).Length;
startFiles++;
Assert.AreEqual(finishFiles, startFiles);
}
public void testStopWithFlush()
{
fileName = "test3";
AsyncLog test3 = new AsyncLog(fileName, filePath, threadSleep);
Random rnd = new Random();
int logSize = 100;
int lines;
int randomNr = rnd.Next(1, 99);
for (int i = 0; i < logSize; i++)
{
if (i == randomNr)
{
test3.StopWithFlush();
}
test3.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
Thread.Sleep(500);
randomNr++;
lines = File.ReadLines(test3.fullFilePath).Count();
Assert.AreEqual(randomNr, lines);
}
public void testStopWithOutflush()
{
fileName = "test4";
AsyncLog test4 = new AsyncLog(fileName, filePath, threadSleep);
Random rnd = new Random();
int lines;
int randomNr = rnd.Next(1, 99);
for (int i = 0; i < randomNr; i++)
{
if (i == randomNr)
{
test4.StopWithoutFlush();
}
test4.Write("Number with out Flush: " + i.ToString());
Thread.Sleep(20);
}
randomNr++;
lines = File.ReadLines(test4.fullFilePath).Count();
Assert.IsTrue(randomNr > lines);
}
static void Main(string[] args)
{
ILog logger = new AsyncLog();
for (int i = 0; i < 15; i++)
{
logger.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
logger.StopWithFlush();
ILog logger2 = new AsyncLog();
for (int i = 5000; i > 0; i--)
{
logger2.Write("Number with No flush: " + i.ToString());
}
logger2.StopWithoutFlush();
Console.ReadLine();
Console.WriteLine("Day Change: " + (new Tests()).TestDayChange());
Console.WriteLine("Line Logged: " + (new Tests()).TestCallToWrite());
Console.WriteLine("Stop With Flush: " + (new Tests()).TestStopWithFlush());
Console.WriteLine("Stop Without Flush (test not deterministic!): " + (new Tests()).TestStopWithoutFlush());
}
public void NewFilesCreatedAfterMidnight()
{
var timeMock = new Mock <IDateTimeProvider>();
timeMock.SetupGet(x => x.DateTimeNow).Returns(new DateTime(2020, 3, 12, 11, 59, 00));
DateTimeProvider.Current = timeMock.Object;
var log = new AsyncLog(new LogsStorage());
log.Write(_demoText);
Thread.Sleep(50);
Assert.True(Directory.Exists(LogDir));
int numberOfFilesBeforeMidnight = Directory.GetFiles(LogDir).Count();
timeMock.SetupGet(x => x.DateTimeNow).Returns(new DateTime(2020, 3, 13, 00, 01, 00));
log.Write(_demoText);
Thread.Sleep(50);
int numberOfFilesAfterMidnight = Directory.GetFiles(LogDir).Count();
Assert.True(numberOfFilesBeforeMidnight < numberOfFilesAfterMidnight);
}
public async Task WriteToLogFile()
{
var dateProviderMock = new Mock <IDateTimeProvider>();
var dateTime = new DateTime(2020, 3, 11, 18, 55, 00);
dateProviderMock.SetupGet(x => x.DateTimeNow).Returns(dateTime);
DateTimeProvider.Current = dateProviderMock.Object;
var log = new AsyncLog(new LogsStorage());
log.Write(_demoText);
log.StopWithFlush();
Assert.True(Directory.Exists(LogDir));
var files = Directory.GetFiles(LogDir);
var dateTimeInLogfileName = dateTime.ToString("yyyyMMdd HHmmss fff");
foreach (var file in files)
{
var fileInfo = new FileInfo(file);
if (fileInfo.Name.Contains(dateTimeInLogfileName))
{
using (var streamReader = File.OpenText(file))
{
var fileContent = await streamReader.ReadToEndAsync();
Assert.True(fileContent.Contains(_demoText));
}
}
}
}
public void StopWithFlush_StopAtPoint3_AssertThat0IsWritten()
{
ILog writerAsync = new AsyncLog(new FakeLogOutputForUnitTestWithFlush());
for (int i = 30; i >= 0; i--)
{
writerAsync.Write(i.ToString());
System.Threading.Thread.Sleep(50);
}
writerAsync.StopWithFlush();
}
static void Do2()
{
ILog logger2 = new AsyncLog();
for (int i = 50; i > 0; i--)
{
logger2.Write("Number with No flush: " + i.ToString());
Thread.Sleep(20);
}
logger2.StopWithoutFlush();
}
static void Do1()
{
ILog logger = new AsyncLog();
for (int i = 0; i < 15; i++)
{
logger.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
logger.StopWithFlush();
}
public void TearDown()
{
_log.Dispose();
_log = null;
var files = Directory.GetFiles(OutputDir);
foreach (var file in files)
{
File.Delete(file);
}
Directory.Delete(OutputDir);
}
public void StopWithoutFlush_StopAtPoint10_AssertThatItPointIs11AndNotEqual10()
{
ILog writerAsync = new AsyncLog(new FakeLogOutput());
for (int i = 50; i >= 0; i--)
{
writerAsync.Write(i.ToString());
if (i == 10)
{
writerAsync.StopWithoutFlush();
}
System.Threading.Thread.Sleep(50);
}
}
/// <summary>
/// Run and Stop Without Flush
/// </summary>
static void StopWithFlushTest()
{
ILog logger2 = new AsyncLog();
for (int i = 0; i < 1000; i++)
{
logger2.Write("Number with Flush: " + i.ToString());
if (i == 500)
{
logger2.StopWithFlush();
}
}
logger2.CloseStreamWriter();
Thread.Sleep(2000);
}
public void Write_ExceptionThrown_NoExceptionExpected()
{
try
{
ILog writerAsync = new AsyncLog(new FakeLogOutputForUnitTestThrowException());
for (int i = 10; i >= 0; i--)
{
writerAsync.Write(i.ToString());
System.Threading.Thread.Sleep(50);
}
}
catch (Exception ex)
{
Assert.Fail("Expected no exception but got one : " + ex.Message);
}
}
/// <summary>
/// Run the task and change the date dynamicly
/// </summary>
void DoWork()
{
ILog logger2 = new AsyncLog();
for (int i = 1000; i > 0; i--)
{
logger2.Write("Number with No flush: " + i.ToString());
if (i == 500)
{
ChangeCurrentDate.ChangeDatetoTommorrow();
}
Thread.Sleep(20);
}
logger2.CloseStreamWriter();
Thread.Sleep(5000);
}
public void TestNewDayNewFile()
{
AsyncLog logger = new AsyncLog();
logger.Write("Number with Flush: ");
Thread.Sleep(1000);
DateTime plusOne = DateTime.Now.AddDays(1);
logger.logFile._curDate = plusOne;
logger.logFile.isTest = true;
logger.Write("Number with Flush: ");
Thread.Sleep(1000);
logger.StopWithoutFlush();
Assert.IsTrue(File.Exists(logger.logFile.filename));
Assert.IsTrue(logger.logFile.filename.Contains(plusOne.ToString("yyyyMMdd HHmmss fff")));
}
public void TestStopWithFlush()
{
// First logger
ILog firstFlushLog = new AsyncLog(nameof(firstFlushLog), Location);
string pathFirst = TestUtils.BuildFilePath(Location, nameof(firstFlushLog));
for (int i = 0; i < 15; i++)
{
firstFlushLog.AddLogToQueue("Number with Flush: " + i);
if (i == 10)
{
firstFlushLog.StopWithFlush();
}
}
Thread.Sleep(100);
var firstFile = File.OpenRead(pathFirst);
var firstFileLength = firstFile.Length;
firstFile.Dispose();
// Second logger
ILog secondFlushLog = new AsyncLog(nameof(secondFlushLog), Location);
string pathSecond = TestUtils.BuildFilePath(Location, nameof(secondFlushLog));
for (int i = 0; i < 15; i++)
{
if (i == 10)
{
secondFlushLog.StopWithFlush();
}
secondFlushLog.AddLogToQueue("Number with Flush: " + i);
}
Thread.Sleep(100);
var secondFile = File.OpenRead(pathSecond);
var secondFileLength = secondFile.Length;
secondFile.Dispose();
File.Delete(pathFirst);
File.Delete(pathSecond);
Assert.IsTrue(firstFileLength > secondFileLength);
}
public void TestWriteToLogWithFlush()
{
AsyncLog logger = new AsyncLog();
int numberOfLines = 15;
for (int i = 1; i < numberOfLines; i++)
{
logger.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
logger.StopWithFlush();
Thread.Sleep(5000);
logger.logFile._writer.Close();
string[] readText = File.ReadAllLines(logger.logFile.filename);
Assert.IsTrue(File.Exists(logger.logFile.filename));
Assert.IsTrue(readText.Length == numberOfLines);
}
public void TestOnException()
{
ILog testLogger = new AsyncLog(nameof(testLogger), Location);
string file = TestUtils.BuildFilePath(Location, nameof(testLogger));
try
{
for (int i = 0; i < 10; i++)
{
testLogger.AddLogToQueue("Test log no: " + i);
if (i == 5)
{
throw new Exception();
}
}
}
catch
{
// ignored
}
testLogger.StopWithFlush();
ILog testLogger2 = new AsyncLog(nameof(testLogger2), Location);
string file2 = TestUtils.BuildFilePath(Location, nameof(testLogger2));
for (int i = 0; i < 10; i++)
{
testLogger2.AddLogToQueue("Test log after exception no: " + i);
}
testLogger2.StopWithFlush();
Thread.Sleep(100);
Assert.IsTrue(File.Exists(file));
Assert.IsTrue(File.Exists(file2));
Thread.Sleep(1000);
File.Delete(file);
File.Delete(file2);
}
public async Task StopWritingWithoutFlush()
{
var dateTimeProviderMock = new Mock <IDateTimeProvider>();
var dateTime = new DateTime(2020, 3, 14, 12, 30, 00);
dateTimeProviderMock.SetupGet(x => x.DateTimeNow).Returns(dateTime);
DateTimeProvider.Current = dateTimeProviderMock.Object;
var log = new AsyncLog(new LogsStorage());
log.Write(_demoText);
var loopCounter = 5;
for (var i = 0; i <= loopCounter; i++)
{
log.Write($"{_demoText}{i}");
}
await Task.Delay(1);
log.StopWithoutFlush();
Assert.True(Directory.Exists(LogDir));
var files = Directory.GetFiles(LogDir);
var dateTimeInLogfileName = dateTime.ToString("yyyyMMdd HHmmss fff");
foreach (var file in files)
{
var fileInfo = new FileInfo(file);
if (fileInfo.Name.Contains(dateTimeInLogfileName))
{
using (var streamReader = File.OpenText(file))
{
var content = await streamReader.ReadToEndAsync();
Assert.False(content.Contains($"{_demoText}{loopCounter}"));
}
break;
}
}
}
public void TestFileDate()
{
var date = DateTime.Today.ToString("yyyyMMdd");
ILog logDateTester = new AsyncLog(nameof(logDateTester), Location);
string path = TestUtils.BuildFilePath(Location, nameof(logDateTester));
logDateTester.AddLogToQueue("Some random test log"); // file created on first log
logDateTester.StopWithFlush();
Thread.Sleep(1);
var file = File.OpenRead(path);
file.Dispose();
var fileDate = file.Name.Substring(24, 8);
File.Delete(path);
Assert.IsTrue(fileDate == date);
}
public void TestWithoutFlush()
{
ILog noFlushLog = new AsyncLog(nameof(noFlushLog), Location);
string path = TestUtils.BuildFilePath(Location, nameof(noFlushLog));
for (int i = 0; i < 15; i++)
{
noFlushLog.AddLogToQueue("Number with Flush: " + i);
}
noFlushLog.StopWithoutFlush();
Thread.Sleep(100);
var file = File.OpenRead(path);
Assert.IsTrue(File.Exists(path));
Assert.IsTrue(file.Length == 0);
file.Dispose();
File.Delete(path);
}
static void Main(string[] args)
{
string fileName = "Log";
string filePath = @"C:\LogTest";
int threadSleep = 50;
ILog logger = new AsyncLog(fileName, filePath, threadSleep);
while (true)
{
for (int i = 0; i < 15; i++)
{
logger.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
logger.StopWithFlush();
Thread.Sleep(50);
for (int i = 15; i < 50; i++)
{
logger.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
fileName = "Log";
filePath = @"C:\LogTest";
ILog logger2 = new AsyncLog(fileName, filePath, threadSleep);
for (int i = 100; i > 0; i--)
{
logger2.Write("Number with No flush: " + i.ToString());
Thread.Sleep(20);
}
logger2.StopWithoutFlush();
Console.WriteLine("finish");
Console.ReadLine();
}
}
static void Main(string[] args)
{
ILog logger = new AsyncLog(new FileWriter());
for (int i = 0; i < 15; i++)
{
logger.Write("Number with Flush: " + i);
}
Thread.Sleep(5);
logger.StopWithFlush();
ILog logger2 = new AsyncLog(new FileWriter());
for (int i = 50; i > 0; i--)
{
logger2.Write("Number with No flush: " + i);
}
Thread.Sleep(5);
logger2.StopWithoutFlush();
Console.ReadLine();
}
public void testLogWriten()
{
fileName = "test1";
AsyncLog test = new AsyncLog(fileName, filePath, threadSleep);
{
int logSize = 100;
int lines;
for (int i = 0; i < logSize; i++)
{
test.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
Thread.Sleep(500);
logSize++;
lines = File.ReadLines(test.fullFilePath).Count();
Assert.AreEqual(logSize, lines);
}
}
public static void Main(string[] args)
{
var flushLogger = new AsyncLog(new LogsStorage());
for (var i = 0; i < 15; i++)
{
flushLogger.Write($"Number with Flush: {i}");
Task.Delay(10).Wait();
}
flushLogger.StopWithFlush();
var noFlushLogger = new AsyncLog(new LogsStorage());
for (var i = 50; i > 0; i--)
{
noFlushLogger.Write($"Number with No flush: {i}");
Task.Delay(5).Wait();
}
noFlushLogger.StopWithoutFlush();
Console.ReadKey();
}
static void Main()
{
string location = @"C:\LogTest\";
ILog logger = new AsyncLog(nameof(logger), location);
for (int i = 0; i <= 14; i++)
{
logger.AddLogToQueue("Number with Flush: " + i);
//if (i == 10) logger.StopWithFlush();
}
ILog logger2 = new AsyncLog(nameof(logger2), location);
for (int i = 50; i > 0; i--)
{
logger2.AddLogToQueue("Number with No flush: " + i);
//if (i == 30) logger2.StopWithoutFlush();
}
Console.WriteLine("Main program done");
Console.ReadLine();
}
/// <summary>
/// If the works are done completely add "finish" to the last line
/// </summary>
static void DoWork()
{
ILog logger = new AsyncLog();
for (int i = 0; i < 15; i++)
{
logger.Write("Number with Flush: " + i.ToString());
Thread.Sleep(50);
}
logger.Write("Finish");
ILog logger2 = new AsyncLog();
for (int i = 100; i > 0; i--)
{
logger2.Write("Number with No flush: " + i.ToString());
Thread.Sleep(20);
}
logger2.Write("Finish");
logger.CloseStreamWriter();
logger2.CloseStreamWriter();
Thread.Sleep(5000);
}
public LogTestsFixture()
{
_writerMock = new Mock <IFileWriter>();
_writerMock.Setup(a => a.Write(It.IsAny <LogLine>())).Callback(() => { Thread.Sleep(2); });
Log = new AsyncLog(_writerMock.Object);
}
public LogIntegrationTestsFixture()
{
_directory = Path.Combine(Directory.GetCurrentDirectory(), "log" + Guid.NewGuid());
_fileWriter = new FileWriter(_directory);
Log = new AsyncLog(_fileWriter);
}
