public void RemoveListener(SimpleEventListener listener)
{
if (_eventListeners.Contains(listener))
{
_eventListeners.Remove(listener);
}
}
public void AddListener(SimpleEventListener listener)
{
if (!_eventListeners.Contains(listener))
{
_eventListeners.Add(listener);
}
}
public void test_manually_invoke_targets()
{
var instance = new SimpleEventListener();
var count = 0;
var target = new TestEvent();
instance.AddSupportedType <TestEvent>();
instance.AddEventHandler <TestEvent>((ep) =>
{ if (ep == target)
{
count += 1;
}
});
instance.AddEventHandler <TestEvent>((ep) =>
{ if (ep == target)
{
count += 1;
}
});
foreach (var handler in instance.Handlers)
{
handler.localHandler(target);
}
Assert(count == 2);
Assert(instance.Count == 2);
}
/// Factory to use to create groups
protected override IEventListener EventListenerFor(System.Type T)
{
var rtn = new SimpleEventListener();
rtn.AddSupportedType(T);
return(rtn);
}
public static void Main(string[] args)
{
using (var listener = new SimpleEventListener())
{
listener.Sink.Start();
CreateWebHostBuilder(args).Build().Run();
}
}
public void test_add_event_handler()
{
var instance = new SimpleEventListener();
instance.AddSupportedType<TestEvent>();
instance.AddEventHandler<TestEvent>((ep) => { });
instance.AddEventHandler<TestEvent>((ep) => { });
Assert(instance.Count == 2);
}
public void test_add_event_handler()
{
var instance = new SimpleEventListener();
instance.AddSupportedType <TestEvent>();
instance.AddEventHandler <TestEvent>((ep) => { });
instance.AddEventHandler <TestEvent>((ep) => { });
Assert(instance.Count == 2);
}
public void test_add_remove_handler_during_event()
{
var instance = new SimpleEventListener();
var count = 0;
var target = new TestEvent();
EventHandler <TestEvent> handler1 = (ep) =>
{
count = 100;
};
EventHandler <TestEvent> handler2 = (ep) =>
{
count += 1;
};
EventHandler <TestEvent> handler3 = null;
handler3 = (ep) =>
{
instance.RemoveEventHandler(handler3);
instance.RemoveEventHandler(handler2);
instance.AddEventHandler(handler1);
};
instance.AddSupportedType <TestEvent>();
instance.AddEventHandler(handler2);
Assert(instance.Count == 1);
foreach (var handler in instance.Handlers)
{
handler.localHandler(target);
}
instance.AddEventHandler(handler3);
Assert(instance.Count == 2);
foreach (var handler in instance.Handlers)
{
handler.localHandler(target);
}
Assert(instance.Count == 1);
foreach (var handler in instance.Handlers)
{
handler.localHandler(target);
}
Assert(instance.Count == 1);
Assert(count == 100);
}
public void test_remove_target()
{
var instance = new SimpleEventListener();
instance.AddSupportedType <TestEvent>();
EventHandler <TestEvent> ep = (ep2) => { };
instance.AddEventHandler <TestEvent>(ep);
Assert(instance.Count == 1);
instance.RemoveEventHandler(ep);
Assert(instance.Count == 0);
}
public static int Main(string[] args)
{
int iter = 100;
// Create an EventListener.
using (SimpleEventListener myListener = new SimpleEventListener("SimpleEventSource", EventLevel.Verbose, iter))
{
string displayName = "Mock Counter";
string displayUnits = "Count";
SimpleEventSource eventSource = new SimpleEventSource(displayName, displayUnits);
// increment 100 times
for (int i = 0; i < iter; i++)
{
eventSource.IncrementCounter();
}
evnt.WaitOne(10000);
if (iter != myListener.incrementSum)
{
Console.WriteLine("Test Failed");
Console.WriteLine($"Expected to see {iter} events - saw {myListener.incrementSum}");
return(1);
}
if (displayName != myListener.displayName)
{
Console.WriteLine("Test Failed");
Console.WriteLine($"Expected to see {displayName} as DisplayName property in payload - saw {myListener.displayName}");
return(1);
}
if (displayUnits != myListener.displayUnits)
{
Console.WriteLine("Test Failed");
Console.WriteLine($"Expected to see {displayUnits} as DisplayUnits property in payload - saw {myListener.displayUnits}");
return(1);
}
if (!myListener.displayRateTimeScale.Equals("00:00:01"))
{
Console.WriteLine("Test failed");
Console.WriteLine($"Wrong DisplayRateTimeScale: {myListener.displayRateTimeScale}");
}
Console.WriteLine("Test passed");
return(100);
}
}
public void test_reject_invalid_type()
{
var instance = new SimpleEventListener();
try
{
instance.AddEventHandler <TestEvent>((ep) => { });
Unreachable();
}
catch (EventException err)
{
Assert(err.errorCode == EventErrors.INVALID_HANDLER_TYPE);
}
}
public static int Main(string[] args)
{
// Create an EventListener.
using (SimpleEventListener myListener = new SimpleEventListener("SimpleEventSource", EventLevel.Verbose))
{
string displayName = "Mock Counter";
string displayUnits = "Count";
SimpleEventSource eventSource = new SimpleEventSource(displayName, displayUnits);
int iter = 100;
// increment 100 times
for (int i = 0; i < iter; i++)
{
eventSource.WriteOne();
}
myListener.sawEvent.WaitOne(-1); // Block until we see at least one event
if (!myListener.validateMean())
{
Console.WriteLine("Test Failed - Incorrect mean calculation");
return(1);
}
if (displayName != myListener.displayName)
{
Console.WriteLine("Test Failed");
Console.WriteLine($"Expected to see {displayName} as DisplayName property in payload - saw {myListener.displayName}");
return(1);
}
if (displayUnits != myListener.displayUnits)
{
Console.WriteLine("Test Failed");
Console.WriteLine($"Expected to see {displayUnits} as DisplayUnits property in payload - saw {myListener.displayUnits}");
return(1);
}
if (myListener.callbackCount == 0)
{
Console.WriteLine("Test Failed: Expected to see 1 or more EventListener callback but got none");
}
Console.WriteLine("Test passed");
return(100);
}
}
public void test_manually_invoke_targets()
{
var instance = new SimpleEventListener();
var count = 0;
var target = new TestEvent();
instance.AddSupportedType<TestEvent>();
instance.AddEventHandler<TestEvent>((ep) =>
{ if (ep == target) { count += 1; } });
instance.AddEventHandler<TestEvent>((ep) =>
{ if (ep == target) { count += 1; } });
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(count == 2);
Assert(instance.Count == 2);
}
public void test_add_remove_handler_during_event()
{
var instance = new SimpleEventListener();
var count = 0;
var target = new TestEvent();
EventHandler<TestEvent> handler1 = (ep) =>
{
count = 100;
};
EventHandler<TestEvent> handler2 = (ep) =>
{
count += 1;
};
EventHandler<TestEvent> handler3 = null;
handler3 = (ep) =>
{
instance.RemoveEventHandler(handler3);
instance.RemoveEventHandler(handler2);
instance.AddEventHandler(handler1);
};
instance.AddSupportedType<TestEvent>();
instance.AddEventHandler(handler2);
Assert(instance.Count == 1);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
instance.AddEventHandler(handler3);
Assert(instance.Count == 2);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(instance.Count == 1);
foreach (var handler in instance.Handlers) { handler.localHandler(target); }
Assert(instance.Count == 1);
Assert(count == 100);
}
public static int Main(string[] args)
{
// Create an EventListener.
using (SimpleEventListener myListener = new SimpleEventListener("SimpleEventSource", EventLevel.Verbose))
{
SimpleEventSource eventSource = new SimpleEventSource(getMockedCount, getSuccessCount);
// Want to sleep for 5000 ms to get some counters piling up.
Thread.Sleep(5000);
if (myListener.FailureEventCount > 0 && myListener.SuccessEventCount > 0 && !myListener.Failed && (mockedCountCalled > 0 && successCountCalled > 0))
{
Console.WriteLine("Test Passed");
return(100);
}
else
{
Console.WriteLine("Test Failed");
return(1);
}
}
}
public static int Main(string[] args)
{
// Create an EventListener.
using (SimpleEventListener myListener = new SimpleEventListener("SimpleEventSource", EventLevel.Verbose))
{
SimpleEventSource eventSource = new SimpleEventSource(getMockedCount);
// Want to sleep for 5000 ms to get some counters piling up.
Thread.Sleep(5000);
if (myListener.Failed || mockedCountCalled <= 0)
{
Console.WriteLine($"Test Failed - mockedCountCalled = {mockedCountCalled}, myListener.Failed = {myListener.Failed}");
return(1);
}
if (myListener.displayRateTimeScale != "00:00:01")
{
Console.WriteLine($"Test Failed - Incorrect DisplayRateTimeScale in payload: {myListener.displayRateTimeScale}");
return(1);
}
if (myListener.displayName != "Failure Count")
{
Console.WriteLine($"Test Failed - Incorrect DisplayName in payload: {myListener.displayName}");
return(1);
}
if (myListener.displayUnits != "Count")
{
Console.WriteLine($"Test failed - Incorrect DisplayUnits in payload: {myListener.displayUnits}");
return(1);
}
Console.WriteLine("Test passed");
return(100);
}
}
public static int Main(string[] args)
{
// Create an EventListener.
using (SimpleEventListener myListener = new SimpleEventListener("SimpleEventSource", EventLevel.Verbose))
{
// Reflect over System.Private.CoreLib and get the PollingCounter type.
Assembly SPC = typeof(System.Diagnostics.Tracing.EventSource).Assembly;
if (SPC == null)
{
Console.WriteLine("Failed to get System.Private.CoreLib assembly.");
return(1);
}
Type PollingCounterType = SPC.GetType("System.Diagnostics.Tracing.PollingCounter");
if (PollingCounterType == null)
{
Console.WriteLine("Failed to get System.Diagnostics.Tracing.PollingCounter type.");
return(1);
}
SimpleEventSource eventSource = new SimpleEventSource(getMockedCount, getSuccessCount, PollingCounterType);
// Want to sleep for 5000 ms to get some counters piling up.
Thread.Sleep(5000);
if (myListener.FailureEventCount > 0 && myListener.SuccessEventCount > 0 && !myListener.Failed && (mockedCountCalled > 0 && successCountCalled > 0))
{
Console.WriteLine("Test Passed");
return(100);
}
else
{
Console.WriteLine("Test Failed");
return(1);
}
}
}
public void test_remove_target()
{
var instance = new SimpleEventListener();
instance.AddSupportedType<TestEvent>();
EventHandler<TestEvent> ep = (ep2) => { };
instance.AddEventHandler<TestEvent>(ep);
Assert(instance.Count == 1);
instance.RemoveEventHandler(ep);
Assert(instance.Count == 0);
}
public static void Main(string[] args)
{
var l = new SimpleEventListener();
CreateHostBuilder(args).Build().Run();
}
public void test_reject_invalid_type()
{
var instance = new SimpleEventListener();
try
{
instance.AddEventHandler<TestEvent>((ep) => { });
Unreachable();
}
catch (EventException err)
{
Assert(err.errorCode == EventErrors.INVALID_HANDLER_TYPE);
}
}
