public void AutoFlushTargetWrapperAsyncTest1()
{
var myTarget = new MyAsyncTarget();
var wrapper = new AutoFlushTargetWrapper(myTarget);
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.Null(lastException);
Assert.Equal(1, myTarget.FlushCount);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
Assert.Equal(2, myTarget.FlushCount);
}
public void AutoFlushTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var wrapper = new AutoFlushTargetWrapper
{
WrappedTarget = myTarget,
};
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
bool continuationHit = false;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit = true;
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(1, myTarget.FlushCount);
Assert.Equal(1, myTarget.WriteCount);
continuationHit = false;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
Assert.Equal(2, myTarget.FlushCount);
}
public void AsyncTargetWrapperAsyncTest1()
{
var myTarget = new MyAsyncTarget();
var targetWrapper = new AsyncTargetWrapper(myTarget) { Name = "AsyncTargetWrapperAsyncTest1_Wrapper" };
targetWrapper.Initialize(null);
myTarget.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit.WaitOne());
Assert.Null(lastException);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
}
public void FilteringTargetWrapperAsyncTest2()
{
var myMockCondition = new MyMockCondition(false);
var myTarget = new MyAsyncTarget();
var wrapper = new FilteringTargetWrapper(myTarget, myMockCondition);
wrapper.Initialize(CommonCfg);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
Action<Exception> continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNull(lastException);
Assert.AreEqual(0, myTarget.WriteCount);
Assert.AreEqual(1, myMockCondition.CallCount);
continuationHit.Reset();
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNull(lastException);
Assert.AreEqual(0, myTarget.WriteCount);
Assert.AreEqual(2, myMockCondition.CallCount);
}
public void FilteringTargetWrapperAsyncTest1()
{
var myMockCondition = new MyMockCondition(true);
var myTarget = new MyAsyncTarget();
var wrapper = new FilteringTargetWrapper(myTarget, myMockCondition);
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNull(lastException);
Assert.AreEqual(1, myTarget.WriteCount);
Assert.AreEqual(1, myMockCondition.CallCount);
continuationHit.Reset();
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNull(lastException);
Assert.AreEqual(2, myTarget.WriteCount);
Assert.AreEqual(2, myMockCondition.CallCount);
}
public void AutoFlushTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var wrapper = new AutoFlushTargetWrapper
{
WrappedTarget = myTarget,
};
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
bool continuationHit = false;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit = true;
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.IsTrue(continuationHit);
Assert.IsNull(lastException);
Assert.AreEqual(1, myTarget.FlushCount);
Assert.AreEqual(1, myTarget.WriteCount);
continuationHit = false;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.IsTrue(continuationHit);
Assert.IsNull(lastException);
Assert.AreEqual(2, myTarget.WriteCount);
Assert.AreEqual(2, myTarget.FlushCount);
}
public void AsyncTargetWrapperAsyncWithExceptionTest1()
{
var myTarget = new MyAsyncTarget
{
ThrowExceptions = true,
};
var targetWrapper = new AsyncTargetWrapper(myTarget)
{
Name = "AsyncTargetWrapperAsyncWithExceptionTest1_Wrapper"
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit.WaitOne(5000));
Assert.NotNull(lastException);
Assert.IsType <InvalidOperationException>(lastException);
// no flush on exception
Assert.Equal(0, myTarget.FlushCount);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
lastException = null;
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit.WaitOne(5000));
Assert.NotNull(lastException);
Assert.IsType <InvalidOperationException>(lastException);
Assert.Equal(0, myTarget.FlushCount);
Assert.Equal(2, myTarget.WriteCount);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
public void AutoFlushTargetWrapperAsyncTest2()
{
var myTarget = new MyAsyncTarget();
var wrapper = new AutoFlushTargetWrapper(myTarget);
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
for (int i = 0; i < 100; ++i)
{
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(ex => lastException = ex));
}
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
continuationHit.Set();
};
wrapper.Flush(ex => { });
Assert.Null(lastException);
wrapper.Flush(continuation);
Assert.Null(lastException);
continuationHit.WaitOne();
Assert.Null(lastException);
wrapper.Flush(ex => { }); // Executed right away
Assert.Null(lastException);
Assert.Equal(100, myTarget.WriteCount);
Assert.Equal(103, myTarget.FlushCount);
}
public Task FlushAsync()
{
var flushTcs = new TaskCompletionSource <object>();
Enqueue(flushCompletionMarker.WithContinuation(_ => flushTcs.SetResult(null)), Timeout.Infinite);
return(flushTcs.Task);
}
public void AsyncTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper
{
WrappedTarget = myTarget,
Name = "AsyncTargetWrapperSyncTest1_Wrapper",
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
var logEvent = new LogEventInfo();
Exception lastException = null;
ManualResetEvent continuationHit = new ManualResetEvent(false);
Thread continuationThread = null;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationThread = Thread.CurrentThread;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
// continuation was not hit
Assert.True(continuationHit.WaitOne(5000));
Assert.NotSame(continuationThread, Thread.CurrentThread);
Assert.Null(lastException);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit.WaitOne(5000));
Assert.NotSame(continuationThread, Thread.CurrentThread);
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
public void NlogWriteAsyncLogEventsCore()
{
for (var r = 0; r <= repeats; r++)
{
var tasks = new List <Task>();
for (var u = 0; u <= usersCount; u++)
{
var task = Task.Run(
() =>
{
for (var o = 0; o <= operations; o++)
{
var verboseMessages = LogTestManager.Generate();
var count = verboseMessages.Count();
var i = 0;
var list = new List <AsyncLogEventInfo>();
int originalThreadId = Thread.CurrentThread.ManagedThreadId;
var at = DateTime.Now;
foreach (var verbose in verboseMessages)
{
var logEventInfo = new LogEventInfo()
{
Level = LogLevel.Info,
TimeStamp = verbose.DateTime,
Message = verbose.Message,
};
logEventInfo.Properties["LoggedAt"] = verbose.DateTime;
logEventInfo.Properties["FlushedAt"] = at;
logEventInfo.Properties["A1"] = $"testtesttest";
logEventInfo.Properties["A2"] = $"testtesttest";
logEventInfo.Properties["A3"] = $"testtesttest";
logEventInfo.Properties["A4"] = $"testtesttest";
logEventInfo.Properties["Description"] = $"BufferedVerbose";
logEventInfo.Properties["Buffered"] = $"{i++}/{count}";
var asyncLogEventInfo = logEventInfo.WithContinuation((ex) =>
{
if (ex != null)
{
if (NLog.LogManager.ThrowExceptions && Thread.CurrentThread.ManagedThreadId == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
}
});
list.Add(asyncLogEventInfo);
}
verboseTarget.WriteAsyncLogEvents(list.ToArray());
Thread.Sleep(puaseBetweenOperationsMs);
}
}
);
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
}
}
public void AutoFlushTargetWrapperAsyncWithExceptionTest1()
{
var myTarget = new MyAsyncTarget
{
ThrowExceptions = true,
};
var wrapper = new AutoFlushTargetWrapper(myTarget);
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNotNull(lastException);
Assert.IsInstanceOfType(typeof(InvalidOperationException), lastException);
// no flush on exception
Assert.AreEqual(0, myTarget.FlushCount);
Assert.AreEqual(1, myTarget.WriteCount);
continuationHit.Reset();
lastException = null;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNotNull(lastException);
Assert.IsInstanceOfType(typeof(InvalidOperationException), lastException);
Assert.AreEqual(0, myTarget.FlushCount);
Assert.AreEqual(2, myTarget.WriteCount);
}
public void AsyncTargetWrapperAsyncTest1()
{
var myTarget = new MyAsyncTarget();
var targetWrapper = new AsyncTargetWrapper(myTarget)
{
Name = "AsyncTargetWrapperAsyncTest1_Wrapper"
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit.WaitOne(5000));
Assert.Null(lastException);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit.WaitOne(5000));
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
public void FilteringTargetWrapperSyncTest2()
{
var myMockCondition = new MyMockCondition(false);
var myTarget = new MyTarget();
var wrapper = new FilteringTargetWrapper
{
WrappedTarget = myTarget,
Condition = myMockCondition,
};
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
bool continuationHit = false;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit = true;
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.Equal(1, myMockCondition.CallCount);
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(0, myTarget.WriteCount);
Assert.Equal(1, myMockCondition.CallCount);
continuationHit = false;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(0, myTarget.WriteCount);
Assert.Equal(2, myMockCondition.CallCount);
}
public void FilteringTargetWrapperSyncTest1()
{
var myMockCondition = new MyMockCondition(true);
var myTarget = new MyTarget();
var wrapper = new FilteringTargetWrapper
{
WrappedTarget = myTarget,
Condition = myMockCondition,
};
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
bool continuationHit = false;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit = true;
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.Equal(1, myMockCondition.CallCount);
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(1, myTarget.WriteCount);
continuationHit = false;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit);
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
Assert.Equal(2, myMockCondition.CallCount);
}
public void AsyncTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper
{
WrappedTarget = myTarget,
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
ManualResetEvent continuationHit = new ManualResetEvent(false);
Thread continuationThread = null;
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationThread = Thread.CurrentThread;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
// continuation was not hit
Assert.True(continuationHit.WaitOne(2000));
Assert.NotSame(continuationThread, Thread.CurrentThread);
Assert.Null(lastException);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.NotSame(continuationThread, Thread.CurrentThread);
Assert.Null(lastException);
Assert.Equal(2, myTarget.WriteCount);
}
public void AsyncTargetWrapperAsyncWithExceptionTest1()
{
var myTarget = new MyAsyncTarget
{
ThrowExceptions = true,
};
var targetWrapper = new AsyncTargetWrapper(myTarget);
targetWrapper.Initialize(null);
myTarget.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
Assert.True(continuationHit.WaitOne());
Assert.NotNull(lastException);
Assert.IsType(typeof(InvalidOperationException), lastException);
// no flush on exception
Assert.Equal(0, myTarget.FlushCount);
Assert.Equal(1, myTarget.WriteCount);
continuationHit.Reset();
lastException = null;
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.NotNull(lastException);
Assert.IsType(typeof(InvalidOperationException), lastException);
Assert.Equal(0, myTarget.FlushCount);
Assert.Equal(2, myTarget.WriteCount);
}
public void FilteringTargetWrapperAsyncWithExceptionTest1()
{
var myMockCondition = new MyMockCondition(true);
var myTarget = new MyAsyncTarget
{
ThrowExceptions = true,
};
var wrapper = new FilteringTargetWrapper(myTarget, myMockCondition);
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNotNull(lastException);
Assert.IsInstanceOfType(typeof(InvalidOperationException), lastException);
Assert.AreEqual(1, myTarget.WriteCount);
Assert.AreEqual(1, myMockCondition.CallCount);
continuationHit.Reset();
lastException = null;
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNotNull(lastException);
Assert.IsInstanceOfType(typeof(InvalidOperationException), lastException);
Assert.AreEqual(2, myTarget.WriteCount);
Assert.AreEqual(2, myMockCondition.CallCount);
}
public void AsyncTargetWrapperSyncTest_WhenTimeToSleepBetweenBatchesIsEqualToZero()
{
LogManager.ThrowConfigExceptions = true;
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper() {
WrappedTarget = myTarget,
TimeToSleepBetweenBatches = 0,
BatchSize = 4,
QueueLimit = 2, // Will make it "sleep" between every second write
OverflowAction = AsyncTargetWrapperOverflowAction.Block
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
int flushCounter = 0;
AsyncContinuation flushHandler = (ex) => { ++flushCounter; };
List<KeyValuePair<LogEventInfo, AsyncContinuation>> itemPrepareList = new List<KeyValuePair<LogEventInfo, AsyncContinuation>>(2500);
List<int> itemWrittenList = new List<int>(itemPrepareList.Capacity);
for (int i = 0; i< itemPrepareList.Capacity; ++i)
{
var logEvent = new LogEventInfo();
int sequenceID = logEvent.SequenceID;
itemPrepareList.Add(new KeyValuePair<LogEventInfo, AsyncContinuation>(logEvent, (ex) => itemWrittenList.Add(sequenceID)));
}
long startTicks = Environment.TickCount;
for (int i = 0; i < itemPrepareList.Count; ++i)
{
var logEvent = itemPrepareList[i].Key;
targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(itemPrepareList[i].Value));
}
targetWrapper.Flush(flushHandler);
for (int i = 0; i < itemPrepareList.Count * 2 && itemWrittenList.Count != itemPrepareList.Count; ++i)
System.Threading.Thread.Sleep(1);
long elapsedMilliseconds = Environment.TickCount - startTicks;
Assert.Equal(itemPrepareList.Count, itemWrittenList.Count);
int prevSequenceID = 0;
for (int i = 0; i < itemWrittenList.Count; ++i)
{
Assert.True(prevSequenceID < itemWrittenList[i]);
prevSequenceID = itemWrittenList[i];
}
#if MONO || NET3_5
Assert.True(elapsedMilliseconds < 2500); // Skip timing test when running within OpenCover.Console.exe
#endif
targetWrapper.Flush(flushHandler);
for (int i = 0; i < 2000 && flushCounter != 2; ++i)
System.Threading.Thread.Sleep(1);
Assert.Equal(2, flushCounter);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
private static bool WriteToTargetWithFilterChain(TargetWithFilterChain targetListHead, LogEventInfo logEvent, AsyncContinuation onException)
{
Target target = targetListHead.Target;
FilterResult result = GetFilterResult(targetListHead.FilterChain, logEvent);
if ((result == FilterResult.Ignore) || (result == FilterResult.IgnoreFinal))
{
if (InternalLogger.IsDebugEnabled)
{
InternalLogger.Debug("{0}.{1} Rejecting message because of a filter.", logEvent.LoggerName, logEvent.Level);
}
if (result == FilterResult.IgnoreFinal)
{
return false;
}
return true;
}
target.WriteAsyncLogEvent(logEvent.WithContinuation(onException));
if (result == FilterResult.LogFinal)
{
return false;
}
return true;
}
/// <summary>
/// Test Fix for https://github.com/NLog/NLog/issues/1069
/// </summary>
private void AsyncTargetWrapperSyncTest_WhenTimeToSleepBetweenBatchesIsEqualToZero(bool forceLockingQueue)
{
LogManager.ThrowConfigExceptions = true;
var myTarget = new MyTarget();
var targetWrapper = new AsyncTargetWrapper()
{
WrappedTarget = myTarget,
TimeToSleepBetweenBatches = 0,
#if NET4_5
ForceLockingQueue = forceLockingQueue,
OptimizeBufferReuse = !forceLockingQueue,
#endif
BatchSize = 3,
QueueLimit = 5, // Will make it "sleep" between every second write
FullBatchSizeWriteLimit = 1,
OverflowAction = AsyncTargetWrapperOverflowAction.Block
};
targetWrapper.Initialize(null);
myTarget.Initialize(null);
try
{
int flushCounter = 0;
AsyncContinuation flushHandler = (ex) => { ++flushCounter; };
var itemPrepareList = new List <AsyncLogEventInfo>(500);
var itemWrittenList = new List <int>(itemPrepareList.Capacity);
for (int i = 0; i < itemPrepareList.Capacity; ++i)
{
var logEvent = new LogEventInfo();
int sequenceID = logEvent.SequenceID;
bool blockConsumer = (itemPrepareList.Capacity / 2) == i; // Force producers to get into blocking-mode
itemPrepareList.Add(logEvent.WithContinuation((ex) => { if (blockConsumer)
{
Thread.Sleep(125);
}
itemWrittenList.Add(sequenceID); }));
}
var eventProducer0 = new ManualResetEvent(false);
var eventProducer1 = new ManualResetEvent(false);
ParameterizedThreadStart producerMethod = (s) =>
{
var eventProducer = (ManualResetEvent)s;
if (eventProducer != null)
{
eventProducer.Set(); // Signal we are ready
}
int partitionNo = ReferenceEquals(eventProducer, eventProducer1) ? 1 : 0;
for (int i = 0; i < itemPrepareList.Count; ++i)
{
if (i % 2 == partitionNo)
{
targetWrapper.WriteAsyncLogEvent(itemPrepareList[i]);
}
}
};
Thread producer0 = new Thread(producerMethod);
producer0.IsBackground = true;
Thread producer1 = new Thread(producerMethod);
producer1.IsBackground = true;
producer1.Start(eventProducer0);
producer0.Start(eventProducer1);
Assert.True(eventProducer0.WaitOne(5000), "Producer0 Start Timeout");
Assert.True(eventProducer1.WaitOne(5000), "Producer1 Start Timeout");
long startTicks = Environment.TickCount;
Assert.True(producer0.Join(5000), "Producer0 Complete Timeout"); // Wait for producer0 to complete
Assert.True(producer1.Join(5000), "Producer1 Complete Timeout"); // Wait for producer1 to complete
long elapsedMilliseconds = Environment.TickCount - startTicks;
targetWrapper.Flush(flushHandler);
for (int i = 0; i < itemPrepareList.Count * 2 && itemWrittenList.Count != itemPrepareList.Count; ++i)
{
Thread.Sleep(1);
}
Assert.Equal(itemPrepareList.Count, itemWrittenList.Count);
int producer0sequenceID = 0;
int producer1sequenceID = 0;
for (int i = 1; i < itemWrittenList.Count; ++i)
{
if (itemWrittenList[i] % 2 == 0)
{
Assert.True(producer0sequenceID < itemWrittenList[i], "Producer0 invalid sequence");
producer0sequenceID = itemWrittenList[i];
}
else
{
Assert.True(producer1sequenceID < itemWrittenList[i], "Producer1 invalid sequence");
producer1sequenceID = itemWrittenList[i];
}
}
#if NET4_5
if (!IsAppVeyor()) // Skip timing test when running within OpenCover.Console.exe
#endif
Assert.InRange(elapsedMilliseconds, 0, 950);
targetWrapper.Flush(flushHandler);
for (int i = 0; i < 2000 && flushCounter != 2; ++i)
{
Thread.Sleep(1);
}
Assert.Equal(2, flushCounter);
}
finally
{
myTarget.Close();
targetWrapper.Close();
}
}
public void AutoFlushTargetWrapperAsyncTest1()
{
var myTarget = new MyAsyncTarget();
var wrapper = new AutoFlushTargetWrapper(myTarget);
myTarget.Initialize(null);
wrapper.Initialize(null);
var logEvent = new LogEventInfo();
Exception lastException = null;
var continuationHit = new ManualResetEvent(false);
AsyncContinuation continuation =
ex =>
{
lastException = ex;
continuationHit.Set();
};
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNull(lastException);
Assert.AreEqual(1, myTarget.FlushCount);
Assert.AreEqual(1, myTarget.WriteCount);
continuationHit.Reset();
wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation));
continuationHit.WaitOne();
Assert.IsNull(lastException);
Assert.AreEqual(2, myTarget.WriteCount);
Assert.AreEqual(2, myTarget.FlushCount);
}