/// <summary>
/// Helper method for the two tests above.
/// </summary>
private void Test_WriteEvent(Listener listener, bool useSelfDescribingEvents)
{
using (var logger = new SdtEventSources.EventSourceTest(useSelfDescribingEvents))
{
var tests = new List<SubTest>();
/*************************************************************************/
tests.Add(new SubTest("WriteEvent/Basic/EventII",
delegate () { logger.EventII(10, 11); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventII", evt.EventName);
Assert.Equal(evt.PayloadValue(0, "arg1"), 10);
Assert.Equal(evt.PayloadValue(1, "arg2"), 11);
}));
/*************************************************************************/
tests.Add(new SubTest("WriteEvent/Basic/EventSS",
delegate () { logger.EventSS("one", "two"); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventSS", evt.EventName);
Assert.Equal(evt.PayloadValue(0, "arg1"), "one");
Assert.Equal(evt.PayloadValue(1, "arg2"), "two");
}));
#if USE_ETW // TODO: Enable when TraceEvent is available on CoreCLR. GitHub issue #4864.
/*************************************************************************/
tests.Add(new SubTest("Write/Basic/EventWithManyTypeArgs",
delegate ()
{
logger.EventWithManyTypeArgs("Hello", 1, 2, 3, 'a', 4, 5, 6, 7,
(float)10.0, (double)11.0, logger.Guid);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithManyTypeArgs", evt.EventName);
Assert.Equal("Hello", evt.PayloadValue(0, "msg"));
Assert.Equal((float)10.0, evt.PayloadValue(9, "f"));
Assert.Equal((double)11.0, evt.PayloadValue(10, "d"));
Assert.Equal(logger.Guid, evt.PayloadValue(11, "guid"));
}));
#endif // USE_ETW
/*************************************************************************/
tests.Add(new SubTest("Write/Basic/EventWith7Strings",
delegate ()
{
logger.EventWith7Strings("s0", "s1", "s2", "s3", "s4", "s5", "s6");
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWith7Strings", evt.EventName);
Assert.Equal("s0", (string)evt.PayloadValue(0, "s0"));
Assert.Equal("s6", (string)evt.PayloadValue(6, "s6"));
}));
/*************************************************************************/
tests.Add(new SubTest("Write/Basic/EventWith9Strings",
delegate ()
{
logger.EventWith9Strings("s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8");
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWith9Strings", evt.EventName);
Assert.Equal("s0", (string)evt.PayloadValue(0, "s0"));
Assert.Equal("s8", (string)evt.PayloadValue(8, "s8"));
}));
#if USE_ETW // TODO: Enable when TraceEvent is available on CoreCLR. GitHub issue #4864.
/*************************************************************************/
tests.Add(new SubTest("Write/Activity/EventWithXferWeirdArgs",
delegate ()
{
var actid = Guid.NewGuid();
logger.EventWithXferWeirdArgs(actid,
(IntPtr)128,
true,
SdtEventSources.MyLongEnum.LongVal1);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
// We log EventWithXferWeirdArgs in one case and
// WorkWeirdArgs/Send in the other
Assert.True(evt.EventName.Contains("WeirdArgs"));
Assert.Equal("128", evt.PayloadValue(0, "iptr").ToString());
Assert.Equal(true, (bool)evt.PayloadValue(1, "b"));
Assert.Equal((long)SdtEventSources.MyLongEnum.LongVal1, (long)evt.PayloadValue(2, "le"));
}));
#endif // USE_ETW
/*************************************************************************/
/*************************** ENUM TESTING *******************************/
/*************************************************************************/
/*************************************************************************/
tests.Add(new SubTest("WriteEvent/Enum/EventEnum",
delegate ()
{
logger.EventEnum(SdtEventSources.MyColor.Blue);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventEnum", evt.EventName);
Assert.Equal(1, (int)evt.PayloadValue(0, "x"));
if (evt.IsEtw && !useSelfDescribingEvents)
Assert.Equal("Blue", evt.PayloadString(0, "x"));
}));
tests.Add(new SubTest("WriteEvent/Enum/EventEnum1",
delegate ()
{
logger.EventEnum1(SdtEventSources.MyColor.Blue);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventEnum1", evt.EventName);
Assert.Equal(1, (int)evt.PayloadValue(0, "x"));
if (evt.IsEtw && !useSelfDescribingEvents)
Assert.Equal("Blue", evt.PayloadString(0, "x"));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithIntIntString",
delegate () { logger.EventWithIntIntString(10, 11, "test"); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithIntIntString", evt.EventName);
Assert.Equal(evt.PayloadValue(0, "i1"), 10);
Assert.Equal(evt.PayloadValue(1, "i2"), 11);
Assert.Equal(evt.PayloadValue(2, "str"), "test");
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithIntLongString",
delegate () { logger.EventWithIntLongString(10, (long)11, "test"); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithIntLongString", evt.EventName);
Assert.Equal(evt.PayloadValue(0, "i1"), 10);
Assert.Equal(evt.PayloadValue(1, "l1"), (long)11);
Assert.Equal(evt.PayloadValue(2, "str"), "test");
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithString",
delegate () { logger.EventWithString(null); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(1, evt.PayloadCount);
Assert.Equal("", evt.PayloadValue(0, null));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithIntAndString",
delegate () { logger.EventWithIntAndString(12, null); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(2, evt.PayloadCount);
Assert.Equal(12, evt.PayloadValue(0, null));
Assert.Equal("", evt.PayloadValue(1, null));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithLongAndString",
delegate () { logger.EventWithLongAndString(120L, null); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(2, evt.PayloadCount);
Assert.Equal(120L, evt.PayloadValue(0, null));
Assert.Equal("", evt.PayloadValue(1, null));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithStringAndInt",
delegate () { logger.EventWithStringAndInt(null, 12); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(2, evt.PayloadCount);
Assert.Equal("", evt.PayloadValue(0, null));
Assert.Equal(12, evt.PayloadValue(1, null));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithStringAndIntAndInt",
delegate () { logger.EventWithStringAndIntAndInt(null, 12, 13); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(3, evt.PayloadCount);
Assert.Equal("", evt.PayloadValue(0, null));
Assert.Equal(12, evt.PayloadValue(1, null));
Assert.Equal(13, evt.PayloadValue(2, null));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithStringAndLong",
delegate () { logger.EventWithStringAndLong(null, 120L); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(2, evt.PayloadCount);
Assert.Equal("", evt.PayloadValue(0, null));
Assert.Equal(120L, evt.PayloadValue(1, null));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithStringAndString",
delegate () { logger.EventWithStringAndString(null, null); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(2, evt.PayloadCount);
Assert.Equal("", evt.PayloadValue(0, null));
Assert.Equal("", evt.PayloadValue(1, null));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithStringAndStringAndString",
delegate () { logger.EventWithStringAndStringAndString(null, null, null); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(3, evt.PayloadCount);
Assert.Equal("", evt.PayloadValue(0, null));
Assert.Equal("", evt.PayloadValue(1, null));
Assert.Equal("", evt.PayloadValue(2, null));
}));
if (useSelfDescribingEvents)
{
tests.Add(new SubTest("WriteEvent/Basic/EventVarArgsWithString",
delegate () { logger.EventVarArgsWithString(1, 2, 12, null); },
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal(4, evt.PayloadCount);
Assert.Equal(1, evt.PayloadValue(0, null));
Assert.Equal(2, evt.PayloadValue(1, null));
Assert.Equal(12, evt.PayloadValue(2, null));
Assert.Equal("", evt.PayloadValue(3, null));
}));
}
// Probably belongs in the user TestUsersErrors.cs.
if (!useSelfDescribingEvents)
{
tests.Add(new SubTest("WriteEvent/Basic/EventWithIncorrectNumberOfParameters",
delegate ()
{
logger.EventWithIncorrectNumberOfParameters("TestMessage", "TestPath", 10);
},
delegate (List<Event> evts)
{
Assert.True(0 < evts.Count);
// We give an error message in EventListener case but not the ETW case.
if (1 < evts.Count)
{
Assert.Equal(2, evts.Count);
Assert.Equal(logger.Name, evts[0].ProviderName);
Assert.Equal("EventSourceMessage", evts[0].EventName);
string errorMsg = evts[0].PayloadString(0, "message");
Assert.True(Regex.IsMatch(errorMsg, "called with 1.*defined with 3"));
}
int eventIdx = evts.Count - 1;
Assert.Equal(logger.Name, evts[eventIdx].ProviderName);
Assert.Equal("EventWithIncorrectNumberOfParameters", evts[eventIdx].EventName);
Assert.Equal("{TestPath:10}TestMessage", evts[eventIdx].PayloadString(0, "message"));
}));
}
// If you only wish to run one or several of the tests you can filter them here by
// Uncommenting the following line.
// tests = tests.FindAll(test => Regex.IsMatch(test.Name, "ventWithByteArray"));
// Next run the same tests with the TraceLogging path.
EventTestHarness.RunTests(tests, listener, logger);
}
}
private void Test_WriteEvent_ByteArray(bool useSelfDescribingEvents, Listener listener)
{
EventSourceSettings settings = EventSourceSettings.EtwManifestEventFormat;
if (useSelfDescribingEvents)
settings = EventSourceSettings.EtwSelfDescribingEventFormat;
using (var logger = new EventSourceTestByteArray(settings))
{
var tests = new List<SubTest>();
/*************************************************************************/
/**************************** byte[] TESTING *****************************/
/*************************************************************************/
// We only support arrays of any type with the SelfDescribing case.
/*************************************************************************/
byte[] blob = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
tests.Add(new SubTest("Write/Array/EventWithByteArrayArg",
delegate ()
{
logger.EventWithByteArrayArg(blob, 1000);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithByteArrayArg", evt.EventName);
if (evt.IsEventListener)
{
byte[] retBlob = (byte[])evt.PayloadValue(0, "blob");
Assert.NotNull(retBlob);
Assert.True(Equal(blob, retBlob));
Assert.Equal(1000, (int)evt.PayloadValue(1, "n"));
}
}));
if (!useSelfDescribingEvents)
{
/*************************************************************************/
tests.Add(new SubTest("Write/Array/NonEventCallingEventWithBytePtrArg",
delegate ()
{
logger.NonEventCallingEventWithBytePtrArg(blob, 2, 4, 1001);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithBytePtrArg", evt.EventName);
if (evt.IsEtw)
{
Assert.Equal(2, evt.PayloadCount);
byte[] retBlob = (byte[])evt.PayloadValue(0, "blob");
Assert.Equal(4, retBlob.Length);
Assert.Equal(retBlob[0], blob[2]);
Assert.Equal(retBlob[3], blob[2 + 3]);
Assert.Equal(1001, (int)evt.PayloadValue(1, "n"));
}
else
{
Assert.Equal(3, evt.PayloadCount);
byte[] retBlob = (byte[])evt.PayloadValue(1, "blob");
Assert.Equal(1001, (int)evt.PayloadValue(2, "n"));
}
}));
}
tests.Add(new SubTest("Write/Array/EventWithLongByteArray",
delegate ()
{
logger.EventWithLongByteArray(blob, 1000);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithLongByteArray", evt.EventName);
Assert.Equal(2, evt.PayloadCount);
byte[] retBlob = (byte[])evt.PayloadValue(0, "blob");
Assert.True(Equal(blob, retBlob));
Assert.Equal(1000, (long)evt.PayloadValue(1, "lng"));
}));
// If you only wish to run one or several of the tests you can filter them here by
// Uncommenting the following line.
// tests = tests.FindAll(test => Regex.IsMatch(test.Name, "ventWithByteArray"));
// Next run the same tests with the TraceLogging path.
EventTestHarness.RunTests(tests, listener, logger);
}
}
private void Test_Write_Metric(Listener listener)
{
TestUtilities.CheckNoEventSourcesRunning("Start");
using (var logger = new MyEventSource())
{
var tests = new List<SubTest>();
/*************************************************************************/
tests.Add(new SubTest("Log 1 event",
delegate ()
{
listener.EnableTimer(logger, 1); /* Poll every 1 s */
logger.Request(37);
Thread.Sleep(1500); // Sleep for 1.5 seconds
listener.EnableTimer(logger, 0);
},
delegate (List<Event> evts)
{
Assert.Equal(2, evts.Count);
ValidateSingleEventCounter(evts[0], "Request", 1, 37, 0, 37, 37);
}));
/*************************************************************************/
tests.Add(new SubTest("Log 2 event in single period",
delegate ()
{
listener.EnableTimer(logger, 1); /* Poll every 1 s */
logger.Request(37);
logger.Request(25);
Thread.Sleep(1500); // Sleep for 1.5 seconds
listener.EnableTimer(logger, 0);
},
delegate (List<Event> evts)
{
Assert.Equal(2, evts.Count);
ValidateSingleEventCounter(evts[0], "Request", 2, 31, 6, 25, 37);
}));
/*************************************************************************/
tests.Add(new SubTest("Log 2 event in two periods",
delegate ()
{
listener.EnableTimer(logger, 1); /* Poll every 1 s */
logger.Request(37);
Thread.Sleep(1500); // Sleep for 1.5 seconds
logger.Request(25);
Thread.Sleep(1000); // Sleep for 1 seconds (at time = 2.5 second exactly two messages should be received)
listener.EnableTimer(logger, 0);
},
delegate (List<Event> evts)
{
Assert.Equal(4, evts.Count);
ValidateSingleEventCounter(evts[0], "Request", 1, 37, 0, 37, 37);
ValidateSingleEventCounter(evts[2], "Request", 1, 25, 0, 25, 25);
}));
/*************************************************************************/
tests.Add(new SubTest("Log 2 different events in a period",
delegate ()
{
listener.EnableTimer(logger, 1); /* Poll every 1 s */
logger.Request(25);
logger.Error();
Thread.Sleep(1500); // Sleep for 1.5 seconds
listener.EnableTimer(logger, 0);
},
delegate (List<Event> evts)
{
Assert.Equal(2, evts.Count);
ValidateSingleEventCounter(evts[0], "Request", 1, 25, 0, 25, 25);
ValidateSingleEventCounter(evts[1], "Error", 1, 1, 0, 1, 1);
}));
/*************************************************************************/
EventTestHarness.RunTests(tests, listener, logger);
}
TestUtilities.CheckNoEventSourcesRunning("Stop");
}
private void Test_WriteEvent_ComplexData_SelfDescribing(Listener listener)
{
using (var logger = new EventSourceTestSelfDescribingOnly())
{
var tests = new List<SubTest>();
byte[] byteArray = { 0, 1, 2, 3 };
tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/Byte[]",
delegate ()
{
logger.EventByteArrayInt(byteArray, 5);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventByteArrayInt", evt.EventName);
var eventArray = evt.PayloadValue(0, "array");
Array.Equals(eventArray, byteArray);
Assert.Equal(5, evt.PayloadValue(1, "anInt"));
}));
tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/UserData",
delegate ()
{
logger.EventUserDataInt(new UserData() { x = 3, y = 8 }, 5);
},
delegate (Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventUserDataInt", evt.EventName);
var aClass = (IDictionary<string, object>)evt.PayloadValue(0, "aClass");
Assert.Equal(3, (int)aClass["x"]);
Assert.Equal(8, (int)aClass["y"]);
Assert.Equal(5, evt.PayloadValue(1, "anInt"));
}));
// If you only wish to run one or several of the tests you can filter them here by
// Uncommenting the following line.
// tests = tests.FindAll(test => Regex.IsMatch(test.Name, "ventWithByteArray"));
// Next run the same tests with the TraceLogging path.
EventTestHarness.RunTests(tests, listener, logger);
}
}
/// <summary>
/// A helper that can run the test under a variety of conditions
/// * Whether the eventSource is enabled at startup
/// * Whether the listener is ETW or an EventListern
/// * Whether the ETW output is self describing or not.
/// </summary>
private void Test_Bad_EventSource_Startup(bool onStartup, Listener listener, EventSourceSettings settings)
{
var eventSourceName = typeof(BadEventSource_MismatchedIds).Name;
Debug.WriteLine("***** Test_BadEventSource_Startup(OnStartUp: " + onStartup + " Listener: " + listener + " Settings: " + settings + ")");
// Activate the source before the source exists (if told to).
if (onStartup)
listener.EventSourceCommand(eventSourceName, EventCommand.Enable);
var events = new List<Event>();
listener.OnEvent = delegate (Event data) { events.Add(data); };
using (var source = new BadEventSource_MismatchedIds(settings))
{
Assert.Equal(eventSourceName, source.Name);
// activate the source after the source exists (if told to).
if (!onStartup)
listener.EventSourceCommand(eventSourceName, EventCommand.Enable);
source.Event1(1); // Try to send something.
}
listener.Dispose();
// Confirm that we get exactly one event from this whole process, that has the error message we expect.
Assert.Equal(events.Count, 1);
Event _event = events[0];
Assert.Equal("EventSourceMessage", _event.EventName);
string message = _event.PayloadString(0, "message");
Debug.WriteLine(String.Format("Message=\"{0}\"", message));
// expected message: "ERROR: Exception in Command Processing for EventSource BadEventSource_MismatchedIds: Event Event2 is given event ID 2 but 1 was passed to WriteEvent. "
Assert.True(Regex.IsMatch(message, "Event Event2 is givien event ID 2 but 1 was passed to WriteEvent"));
}
