static partial void Test_Write_Fuzzy_TestEtw(List <SubTest> tests, EventSource logger) { if (TestUtilities.IsProcessElevated) { using (var listener = new EtwListener()) { EventTestHarness.RunTests(tests, listener, logger); } } }
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); } }
public void Test_WriteEvent_NoAttribute() { using (EventSourceNoAttribute es = new EventSourceNoAttribute()) { Listener el = new EventListenerListener(true); var tests = new List <SubTest>(); string arg = "a sample string"; tests.Add(new SubTest("Write/Basic/EventWith9Strings", delegate() { es.EventNoAttributes(arg); }, delegate(Event evt) { Assert.Equal(es.Name, evt.ProviderName); Assert.Equal("EventNoAttributes", evt.EventName); Assert.Equal(arg, (string)evt.PayloadValue(0, null)); })); EventTestHarness.RunTests(tests, el, es); } }
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_Write_Metric(Listener listener) { TestUtilities.CheckNoEventSourcesRunning("Start"); using (var logger = new MyEventSource()) { var tests = new List <SubTest>(); /*************************************************************************/ tests.Add(new SubTest("EventCounter: Log 1 event, explicit poll at end", delegate() { listener.EnableTimer(logger, 1); // Set to poll every second, but we dont actually care because the test ends before that. logger.Request(5); listener.EnableTimer(logger, 0); }, delegate(List <Event> evts) { // There will be two events (request and error) for time 0 and 2 more at 1 second and 2 more when we shut it off. Assert.Equal(4, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[2], "Request", 1, 5, 0, 5, 5); ValidateSingleEventCounter(evts[3], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); })); /*************************************************************************/ tests.Add(new SubTest("EventCounter: Log 2 events, explicit poll at end", delegate() { listener.EnableTimer(logger, 1); // Set to poll every second, but we dont actually care because the test ends before that. logger.Request(5); logger.Request(10); listener.EnableTimer(logger, 0); // poll }, delegate(List <Event> evts) { Assert.Equal(4, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[2], "Request", 2, 7.5f, 2.5f, 5, 10); ValidateSingleEventCounter(evts[3], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); })); /*************************************************************************/ tests.Add(new SubTest("EventCounter: Log 3 events in two polling periods (explicit polling)", delegate() { listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ logger.Request(5); logger.Request(10); logger.Error(); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ logger.Request(8); logger.Error(); logger.Error(); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ }, delegate(List <Event> evts) { Assert.Equal(6, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[2], "Request", 2, 7.5f, 2.5f, 5, 10); ValidateSingleEventCounter(evts[3], "Error", 1, 1, 0, 1, 1); ValidateSingleEventCounter(evts[4], "Request", 1, 8, 0, 8, 8); ValidateSingleEventCounter(evts[5], "Error", 2, 1, 0, 1, 1); })); /*************************************************************************/ int num100msecTimerTicks = 0; tests.Add(new SubTest("EventCounter: Log multiple events in multiple periods", delegate() { // We have had problems with timer ticks not being called back 100% reliably. // However timers really don't have a strong guarantee (only that the happen eventually) // So what we do is create a timer callback that simply counts the number of callbacks. // This acts as a marker to show whether the timer callbacks are happening promptly. // If we don't get enough of these tick callbacks then we don't require EventCounter to // be sending periodic callbacks either. num100msecTimerTicks = 0; using (var timer = new System.Threading.Timer(delegate(object state) { num100msecTimerTicks++; EventTestHarness.LogWriteLine("Tick"); }, null, 100, 100)) { listener.EnableTimer(logger, .1); /* Poll every .1 s */ // logs at 0 seconds because of EnableTimer command Sleep(100); logger.Request(1); Sleep(100); logger.Request(2); logger.Error(); Sleep(100); logger.Request(4); Sleep(100); logger.Request(8); logger.Error(); Sleep(100); logger.Request(16); Sleep(220); listener.EnableTimer(logger, 0); } }, delegate(List <Event> evts) { int requestCount = 0; float requestSum = 0; float requestMin = float.MaxValue; float requestMax = float.MinValue; int errorCount = 0; float errorSum = 0; float errorMin = float.MaxValue; float errorMax = float.MinValue; float timeSum = 0; for (int j = 0; j < evts.Count; j += 2) { var requestPayload = ValidateEventHeaderAndGetPayload(evts[j]); Assert.Equal("Request", requestPayload["Name"]); var count = (int)requestPayload["Count"]; requestCount += count; if (count > 0) { requestSum += (float)requestPayload["Mean"] * count; } requestMin = Math.Min(requestMin, (float)requestPayload["Min"]); requestMax = Math.Max(requestMax, (float)requestPayload["Max"]); float requestIntervalSec = (float)requestPayload["IntervalSec"]; var errorPayload = ValidateEventHeaderAndGetPayload(evts[j + 1]); Assert.Equal("Error", errorPayload["Name"]); count = (int)errorPayload["Count"]; errorCount += count; if (count > 0) { errorSum += (float)errorPayload["Mean"] * count; } errorMin = Math.Min(errorMin, (float)errorPayload["Min"]); errorMax = Math.Max(errorMax, (float)errorPayload["Max"]); float errorIntervalSec = (float)requestPayload["IntervalSec"]; Assert.Equal(requestIntervalSec, errorIntervalSec); timeSum += requestIntervalSec; } EventTestHarness.LogWriteLine("Validating: Count={0} RequestSum={1:n3} TimeSum={2:n3} ", evts.Count, requestSum, timeSum); Assert.Equal(5, requestCount); Assert.Equal(31, requestSum); Assert.Equal(1, requestMin); Assert.Equal(16, requestMax); Assert.Equal(2, errorCount); Assert.Equal(2, errorSum); Assert.Equal(1, errorMin); Assert.Equal(1, errorMax); Assert.True(.4 < timeSum, $"FAILURE: .4 < {timeSum}"); // We should have at least 400 msec Assert.True(timeSum < 2, $"FAILURE: {timeSum} < 2"); // But well under 2 sec. // Do all the things that depend on the count of events last so we know everything else is sane Assert.True(4 <= evts.Count, "We expect two metrics at the beginning trigger and two at the end trigger. evts.Count = " + evts.Count); Assert.True(evts.Count % 2 == 0, "We expect two metrics for every trigger. evts.Count = " + evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); // We should always get the unconditional callback at the start and end of the trace. Assert.True(4 <= evts.Count, $"FAILURE EventCounter Multi-event: 4 <= {evts.Count} ticks: {num100msecTimerTicks} thread: {Environment.CurrentManagedThreadId}"); // We expect the timer to have gone off at least twice, plus the explicit poll at the beginning and end. // Each one fires two events (one for requests, one for errors). so that is (2 + 2)*2 = 8 // We expect about 7 timer requests, but we don't get picky about the exact count // Putting in a generous buffer, we double 7 to say we don't expect more than 14 timer fires // so that is (2 + 14) * 2 = 32 if (num100msecTimerTicks > 3) // We seem to have problems with timer events going off 100% reliably. To avoid failures here we only check if in the 700 msec test we get at least 3 100 msec ticks. { Assert.True(8 <= evts.Count, $"FAILURE: 8 <= {evts.Count}"); } Assert.True(evts.Count <= 32, $"FAILURE: {evts.Count} <= 32"); })); /*************************************************************************/ tests.Add(new SubTest("EventCounter: Dispose()", delegate() { // Creating and destroying var myCounter = new EventCounter("counter for a transient object", logger); myCounter.WriteMetric(10); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ myCounter.Dispose(); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ }, delegate(List <Event> evts) { // The static counters (Request and Error), should not log any counts and stay at zero. // The new counter will exist for the first poll but will not exist for the second. Assert.Equal(5, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[2], "counter for a transient object", 1, 10, 0, 10, 10); ValidateSingleEventCounter(evts[3], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[4], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); })); /*************************************************************************/ EventTestHarness.RunTests(tests, listener, logger); } TestUtilities.CheckNoEventSourcesRunning("Stop"); }
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); } }
/// <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); } }
/// <summary> /// Te /// </summary> /// <param name="listener"></param> private void Test_Write_T(Listener listener) { TestUtilities.CheckNoEventSourcesRunning("Start"); using (var logger = new EventSource("EventSourceName")) { var tests = new List <SubTest>(); /*************************************************************************/ tests.Add(new SubTest("Write/Basic/String", delegate() { logger.Write("Greeting", new { msg = "Hello, world!" }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("Greeting", evt.EventName); Assert.Equal("Hello, world!", evt.PayloadValue(0, "msg")); })); /*************************************************************************/ decimal myMoney = 300; tests.Add(new SubTest("Write/Basic/decimal", delegate() { logger.Write("Decimal", new { money = myMoney }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("Decimal", evt.EventName); var eventMoney = evt.PayloadValue(0, "money"); // TOD FIX ME - Fix TraceEvent to return decimal instead of double. //Assert.Equal((decimal)eventMoney, (decimal)300); })); /*************************************************************************/ DateTime now = DateTime.Now; tests.Add(new SubTest("Write/Basic/DateTime", delegate() { logger.Write("DateTime", new { nowTime = now }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("DateTime", evt.EventName); var eventNow = evt.PayloadValue(0, "nowTime"); Assert.Equal(eventNow, now); })); /*************************************************************************/ byte[] byteArray = { 0, 1, 2, 3 }; tests.Add(new SubTest("Write/Basic/byte[]", delegate() { logger.Write("Bytes", new { bytes = byteArray }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("Bytes", evt.EventName); var eventArray = evt.PayloadValue(0, "bytes"); Array.Equals(eventArray, byteArray); })); /*************************************************************************/ int?nullableInt = 12; tests.Add(new SubTest("Write/Basic/int?/12", delegate() { logger.Write("Int12", new { nInteger = nullableInt }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("Int12", evt.EventName); var payload = evt.PayloadValue(0, "nInteger"); Assert.Equal(nullableInt, TestUtilities.UnwrapNullable <int>(payload)); })); /*************************************************************************/ int?nullableInt2 = null; tests.Add(new SubTest("Write/Basic/int?/null", delegate() { logger.Write("IntNull", new { nInteger = nullableInt2 }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("IntNull", evt.EventName); var payload = evt.PayloadValue(0, "nInteger"); Assert.Equal(nullableInt2, TestUtilities.UnwrapNullable <int>(payload)); })); ///*************************************************************************/ DateTime?nullableDate = DateTime.Now; tests.Add(new SubTest("Write/Basic/DateTime?/Now", delegate() { logger.Write("DateTimeNow", new { nowTime = nullableDate }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("DateTimeNow", evt.EventName); var payload = evt.PayloadValue(0, "nowTime"); Assert.Equal(nullableDate, TestUtilities.UnwrapNullable <DateTime>(payload)); })); /*************************************************************************/ DateTime?nullableDate2 = null; tests.Add(new SubTest("Write/Basic/DateTime?/Null", delegate() { logger.Write("DateTimeNull", new { nowTime = nullableDate2 }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("DateTimeNull", evt.EventName); var payload = evt.PayloadValue(0, "nowTime"); Assert.Equal(nullableDate2, TestUtilities.UnwrapNullable <DateTime>(payload)); })); /*************************************************************************/ tests.Add(new SubTest("Write/Basic/PartBOnly", delegate() { // log just a PartB logger.Write("UserInfo", new EventSourceOptions { Keywords = EventKeywords.None }, new { _1 = new PartB_UserInfo { UserName = "******" } }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("UserInfo", evt.EventName); var structValue = evt.PayloadValue(0, "PartB_UserInfo"); var structValueAsDictionary = structValue as IDictionary <string, object>; Assert.NotNull(structValueAsDictionary); Assert.Equal("Someone Else", structValueAsDictionary["UserName"]); })); /*************************************************************************/ tests.Add(new SubTest("Write/Basic/PartBAndC", delegate() { // log a PartB and a PartC logger.Write("Duration", new EventSourceOptions { Keywords = EventKeywords.None }, new { _1 = new PartB_UserInfo { UserName = "******" }, msec = 10 }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("Duration", evt.EventName); var structValue = evt.PayloadValue(0, "PartB_UserInfo"); var structValueAsDictionary = structValue as IDictionary <string, object>; Assert.NotNull(structValueAsDictionary); Assert.Equal("Myself", structValueAsDictionary["UserName"]); Assert.Equal(10, evt.PayloadValue(1, "msec")); })); /*************************************************************************/ /*************************** ENUM TESTING *******************************/ /*************************************************************************/ /*************************************************************************/ GenerateEnumTest <Color>(ref tests, logger, Color.Green); GenerateEnumTest <ColorUInt32>(ref tests, logger, ColorUInt32.Green); GenerateEnumTest <ColorByte>(ref tests, logger, ColorByte.Green); GenerateEnumTest <ColorSByte>(ref tests, logger, ColorSByte.Green); GenerateEnumTest <ColorInt16>(ref tests, logger, ColorInt16.Green); GenerateEnumTest <ColorUInt16>(ref tests, logger, ColorUInt16.Green); GenerateEnumTest <ColorInt64>(ref tests, logger, ColorInt64.Green); GenerateEnumTest <ColorUInt64>(ref tests, logger, ColorUInt64.Green); /*************************************************************************/ /*************************** ARRAY TESTING *******************************/ /*************************************************************************/ /*************************************************************************/ GenerateArrayTest <bool>(ref tests, logger, new bool[] { false, true, false }); GenerateArrayTest <byte>(ref tests, logger, new byte[] { 1, 10, 100 }); GenerateArrayTest <sbyte>(ref tests, logger, new sbyte[] { 1, 10, 100 }); GenerateArrayTest <short>(ref tests, logger, new short[] { 1, 10, 100 }); GenerateArrayTest <ushort>(ref tests, logger, new ushort[] { 1, 10, 100 }); GenerateArrayTest <int>(ref tests, logger, new int[] { 1, 10, 100 }); GenerateArrayTest <uint>(ref tests, logger, new uint[] { 1, 10, 100 }); GenerateArrayTest <long>(ref tests, logger, new long[] { 1, 10, 100 }); GenerateArrayTest <ulong>(ref tests, logger, new ulong[] { 1, 10, 100 }); GenerateArrayTest <char>(ref tests, logger, new char[] { 'a', 'c', 'b' }); GenerateArrayTest <double>(ref tests, logger, new double[] { 1, 10, 100 }); GenerateArrayTest <float>(ref tests, logger, new float[] { 1, 10, 100 }); GenerateArrayTest <IntPtr>(ref tests, logger, new IntPtr[] { (IntPtr)1, (IntPtr)10, (IntPtr)100 }); GenerateArrayTest <UIntPtr>(ref tests, logger, new UIntPtr[] { (UIntPtr)1, (UIntPtr)10, (UIntPtr)100 }); GenerateArrayTest <Guid>(ref tests, logger, new Guid[] { Guid.Empty, new Guid("121a11ee-3bcb-49cc-b425-f4906fb14f72") }); /*************************************************************************/ /*********************** DICTIONARY TESTING ******************************/ /*************************************************************************/ var dict = new Dictionary <string, string>() { { "elem1", "10" }, { "elem2", "20" } }; var dictInt = new Dictionary <string, int>() { { "elem1", 10 }, { "elem2", 20 } }; /*************************************************************************/ tests.Add(new SubTest("Write/Dict/EventWithStringDict_C", delegate() { // log a dictionary logger.Write("EventWithStringDict_C", new { myDict = dict, s = "end" }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("EventWithStringDict_C", evt.EventName); var keyValues = evt.PayloadValue(0, "myDict"); IDictionary <string, object> vDict = GetDictionaryFromKeyValueArray(keyValues); Assert.Equal("10", vDict["elem1"]); Assert.Equal("20", vDict["elem2"]); Assert.Equal("end", evt.PayloadValue(1, "s")); })); /*************************************************************************/ tests.Add(new SubTest("Write/Dict/EventWithStringDict_BC", delegate() { // log a PartB and a dictionary as a PartC logger.Write("EventWithStringDict_BC", new { PartB_UserInfo = new { UserName = "******", LogTime = "Now" }, PartC_Dict = dict, s = "end" }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("EventWithStringDict_BC", evt.EventName); var structValue = evt.PayloadValue(0, "PartB_UserInfo"); var structValueAsDictionary = structValue as IDictionary <string, object>; Assert.NotNull(structValueAsDictionary); Assert.Equal("Me", structValueAsDictionary["UserName"]); Assert.Equal("Now", structValueAsDictionary["LogTime"]); var keyValues = evt.PayloadValue(1, "PartC_Dict"); var vDict = GetDictionaryFromKeyValueArray(keyValues); Assert.NotNull(dict); Assert.Equal("10", vDict["elem1"]); // string values. Assert.Equal("20", vDict["elem2"]); Assert.Equal("end", evt.PayloadValue(2, "s")); })); /*************************************************************************/ tests.Add(new SubTest("Write/Dict/EventWithIntDict_BC", delegate() { // log a Dict<string, int> as a PartC logger.Write("EventWithIntDict_BC", new { PartB_UserInfo = new { UserName = "******", LogTime = "Now" }, PartC_Dict = dictInt, s = "end" }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("EventWithIntDict_BC", evt.EventName); var structValue = evt.PayloadValue(0, "PartB_UserInfo"); var structValueAsDictionary = structValue as IDictionary <string, object>; Assert.NotNull(structValueAsDictionary); Assert.Equal("Me", structValueAsDictionary["UserName"]); Assert.Equal("Now", structValueAsDictionary["LogTime"]); var keyValues = evt.PayloadValue(1, "PartC_Dict"); var vDict = GetDictionaryFromKeyValueArray(keyValues); Assert.NotNull(vDict); Assert.Equal(10, vDict["elem1"]); // Notice they are integers, not strings. Assert.Equal(20, vDict["elem2"]); Assert.Equal("end", evt.PayloadValue(2, "s")); })); /*************************************************************************/ /**************************** Empty Event TESTING ************************/ /*************************************************************************/ tests.Add(new SubTest("Write/Basic/Message", delegate() { logger.Write("EmptyEvent"); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("EmptyEvent", evt.EventName); })); /*************************************************************************/ /**************************** EventSourceOptions TESTING *****************/ /*************************************************************************/ EventSourceOptions options = new EventSourceOptions(); options.Level = EventLevel.LogAlways; options.Keywords = EventKeywords.All; options.Opcode = EventOpcode.Info; options.Tags = EventTags.None; tests.Add(new SubTest("Write/Basic/MessageOptions", delegate() { logger.Write("EmptyEvent", options); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("EmptyEvent", evt.EventName); })); tests.Add(new SubTest("Write/Basic/WriteOfTWithOptios", delegate() { logger.Write("OptionsEvent", options, new { OptionsEvent = "test options!" }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("OptionsEvent", evt.EventName); Assert.Equal("test options!", evt.PayloadValue(0, "OptionsEvent")); })); tests.Add(new SubTest("Write/Basic/WriteOfTWithRefOptios", delegate() { var v = new { OptionsEvent = "test ref options!" }; logger.Write("RefOptionsEvent", ref options, ref v); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("RefOptionsEvent", evt.EventName); Assert.Equal("test ref options!", evt.PayloadValue(0, "OptionsEvent")); })); tests.Add(new SubTest("Write/Basic/WriteOfTWithNullString", delegate() { string nullString = null; logger.Write("NullStringEvent", new { a = (string)null, b = nullString }); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("NullStringEvent", evt.EventName); Assert.Equal("", evt.PayloadValue(0, "a")); Assert.Equal("", evt.PayloadValue(1, "b")); })); // This test only applies to ETW and will fail on EventListeners due to different behavior // for strings with embedded NULL characters. Test_Write_T_AddEtwTests(listener, tests, logger); Guid activityId = new Guid("00000000-0000-0000-0000-000000000001"); Guid relActivityId = new Guid("00000000-0000-0000-0000-000000000002"); tests.Add(new SubTest("Write/Basic/WriteOfTWithOptios", delegate() { var v = new { ActivityMsg = "test activity!" }; logger.Write("ActivityEvent", ref options, ref activityId, ref relActivityId, ref v); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("ActivityEvent", evt.EventName); Assert.Equal("test activity!", evt.PayloadValue(0, "ActivityMsg")); })); // 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, "Write/Basic/EventII")); // Here is where we actually run tests. First test the ETW path EventTestHarness.RunTests(tests, listener, logger); } TestUtilities.CheckNoEventSourcesRunning("Stop"); }
/// <summary> /// Helper method for the two tests above. /// </summary> private void Test_WriteEvent(Listener listener, bool useSelfDescribingEvents, bool isEtwListener = false) { using (var logger = new 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(10, evt.PayloadValue(0, "arg1")); Assert.Equal(11, evt.PayloadValue(1, "arg2")); })); /*************************************************************************/ 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("one", evt.PayloadValue(0, "arg1")); Assert.Equal("two", evt.PayloadValue(1, "arg2")); })); /*************************************************************************/ 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")); })); /*************************************************************************/ Test_WriteEvent_AddEtwTests(tests, logger); /*************************************************************************/ /*************************** 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, ((IConvertible)evt.PayloadValue(0, "x")).ToInt32(null)); if (evt.IsEtw && !useSelfDescribingEvents) { Assert.Equal("Blue", evt.PayloadString(0, "x")); } })); tests.Add(new SubTest("WriteEvent/Enum/EventEnum1", delegate() { logger.EventEnum1(MyColor.Blue); }, delegate(Event evt) { Assert.Equal(logger.Name, evt.ProviderName); Assert.Equal("EventEnum1", evt.EventName); Assert.Equal(1, ((IConvertible)evt.PayloadValue(0, "x")).ToInt32(null)); 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(10, evt.PayloadValue(0, "i1")); Assert.Equal(11, evt.PayloadValue(1, "i2")); Assert.Equal("test", evt.PayloadValue(2, "str")); })); 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(10, evt.PayloadValue(0, "i1")); Assert.Equal(evt.PayloadValue(1, "l1"), (long)11); Assert.Equal("test", evt.PayloadValue(2, "str")); })); 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)); })); // Self-describing ETW does not support NULL arguments. if (useSelfDescribingEvents && !(isEtwListener)) { 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.Matches("called with 1.*defined with 3", errorMsg); } 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_Write_Metric(Listener listener) { Console.WriteLine("Version of Runtime {0}", Environment.Version); Console.WriteLine("Version of OS {0}", Environment.OSVersion); TestUtilities.CheckNoEventSourcesRunning("Start"); using (var logger = new MyEventSource()) { var tests = new List <SubTest>(); /*************************************************************************/ tests.Add(new SubTest("Log 1 event, explicit poll at end", delegate() { listener.EnableTimer(logger, 1); // Set to poll every second, but we dont actually care because the test ends before that. logger.Request(5); listener.EnableTimer(logger, 0); }, delegate(List <Event> evts) { // There will be two events (request and error) for time 0 and 2 more at 1 second and 2 more when we shut it off. Assert.Equal(4, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[2], "Request", 1, 5, 0, 5, 5); ValidateSingleEventCounter(evts[3], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); })); /*************************************************************************/ tests.Add(new SubTest("Log 2 events, explicit poll at end", delegate() { listener.EnableTimer(logger, 1); // Set to poll every second, but we dont actually care because the test ends before that. logger.Request(5); logger.Request(10); listener.EnableTimer(logger, 0); // poll }, delegate(List <Event> evts) { Assert.Equal(4, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[2], "Request", 2, 7.5f, 2.5f, 5, 10); ValidateSingleEventCounter(evts[3], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); })); /*************************************************************************/ tests.Add(new SubTest("Log 3 events in two polling periods (explicit polling)", delegate() { listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ logger.Request(5); logger.Request(10); logger.Error(); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ logger.Request(8); logger.Error(); logger.Error(); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ }, delegate(List <Event> evts) { Assert.Equal(6, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[2], "Request", 2, 7.5f, 2.5f, 5, 10); ValidateSingleEventCounter(evts[3], "Error", 1, 1, 0, 1, 1); ValidateSingleEventCounter(evts[4], "Request", 1, 8, 0, 8, 8); ValidateSingleEventCounter(evts[5], "Error", 2, 1, 0, 1, 1); })); /*************************************************************************/ tests.Add(new SubTest("Log multiple events in", delegate() { listener.EnableTimer(logger, .1); /* Poll every .1 s */ // logs at 0 seconds because of EnableTimer command Sleep(100); logger.Request(1); Sleep(100); logger.Request(2); logger.Error(); Sleep(100); logger.Request(4); Sleep(100); logger.Error(); logger.Request(8); Sleep(100); logger.Request(16); Sleep(200); listener.EnableTimer(logger, 0); }, delegate(List <Event> evts) { int requestCount = 0; float requestSum = 0; float requestMin = float.MaxValue; float requestMax = float.MinValue; int errorCount = 0; float errorSum = 0; float errorMin = float.MaxValue; float errorMax = float.MinValue; float timeSum = 0; for (int j = 0; j < evts.Count; j += 2) { var requestPayload = ValidateEventHeaderAndGetPayload(evts[j]); Assert.Equal("Request", requestPayload["Name"]); var count = (int)requestPayload["Count"]; requestCount += count; if (count > 0) { requestSum += (float)requestPayload["Mean"] * count; } requestMin = Math.Min(requestMin, (float)requestPayload["Min"]); requestMax = Math.Max(requestMax, (float)requestPayload["Max"]); float requestIntevalSec = (float)requestPayload["IntervalSec"]; var errorPayload = ValidateEventHeaderAndGetPayload(evts[j + 1]); Assert.Equal("Error", errorPayload["Name"]); count = (int)errorPayload["Count"]; errorCount += count; if (count > 0) { errorSum += (float)errorPayload["Mean"] * count; } errorMin = Math.Min(errorMin, (float)errorPayload["Min"]); errorMax = Math.Max(errorMax, (float)errorPayload["Max"]); float errorIntevalSec = (float)requestPayload["IntervalSec"]; Assert.Equal(requestIntevalSec, errorIntevalSec); timeSum += requestIntevalSec; } Assert.Equal(requestCount, 5); Assert.Equal(requestSum, 31); Assert.Equal(requestMin, 1); Assert.Equal(requestMax, 16); Assert.Equal(errorCount, 2); Assert.Equal(errorSum, 2); Assert.Equal(errorMin, 1); Assert.Equal(errorMax, 1); Assert.True(.4 < timeSum, $"FAILURE: .4 < {timeSum}"); // We should have at least 400 msec Assert.True(timeSum < 2, $"FAILURE: {timeSum} < 2"); // But well under 2 sec. // Do all the things that depend on the count of events last so we know everything else is sane Assert.True(4 <= evts.Count, "We expect two metrices at the begining trigger and two at the end trigger. evts.Count = " + evts.Count); Assert.True(evts.Count % 2 == 0, "We expect two metrics for every trigger. evts.Count = " + evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity); // We expect the timer to have gone off at least twice, plus the explicit poll at the begining and end. // Each one fires two events (one for requests, one for errors). so that is (2 + 2)*2 = 8 // We expect about 5 timer requests, but we don't get picky about the exact count // We don't expect more than say 9 timer request so that is (2 + 9) * 2 = 22 Assert.True(8 <= evts.Count, $"FAILURE: 8 <= {evts.Count}"); Assert.True(evts.Count <= 22, $"FAILURE: {evts.Count} <= 22"); })); /*************************************************************************/ // TODO expose Dispose() method and activate this test. #if EventCounterDispose tests.Add(new SubTest("EventCounter.Dispose()", delegate() { // Creating and destroying var myCounter = new EventCounter("counter for a transient object", logger); myCounter.WriteMetric(10); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ myCounter.Dispose(); listener.EnableTimer(logger, 0); /* Turn off (but also poll once) */ }, delegate(List <Event> evts) { Assert.Equal(5, evts.Count); ValidateSingleEventCounter(evts[0], "Request", 0, 0, 0, 0, 0); ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, 0, 0); ValidateSingleEventCounter(evts[2], "counter for a transient object", 1, 10, 0, 10, 10); ValidateSingleEventCounter(evts[3], "Request", 0, 0, 0, 0, 0); ValidateSingleEventCounter(evts[4], "Error", 0, 0, 0, 0, 0); })); #endif /*************************************************************************/ EventTestHarness.RunTests(tests, listener, logger); } TestUtilities.CheckNoEventSourcesRunning("Stop"); }