/// <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");
}
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"));
}));
int?nullableInt = 12;
tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/Int12",
delegate()
{
logger.EventNullableIntInt(nullableInt, 5);
},
delegate(Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventNullableIntInt", evt.EventName);
var payload = evt.PayloadValue(0, "nullableInt");
Assert.Equal(nullableInt, TestUtilities.UnwrapNullable <int>(payload));
Assert.Equal(5, evt.PayloadValue(1, "anInt"));
}));
int?nullableInt2 = null;
tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/IntNull",
delegate()
{
logger.EventNullableIntInt(nullableInt2, 5);
},
delegate(Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventNullableIntInt", evt.EventName);
var payload = evt.PayloadValue(0, "nullableInt");
Assert.Equal(nullableInt2, TestUtilities.UnwrapNullable <int>(payload));
Assert.Equal(5, evt.PayloadValue(1, "anInt"));
}));
DateTime?nullableDate = DateTime.Now;
tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/DateTimeNow",
delegate()
{
logger.EventNullableDateTimeInt(nullableDate, 5);
},
delegate(Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventNullableDateTimeInt", evt.EventName);
var payload = evt.PayloadValue(0, "nullableDate");
Assert.Equal(nullableDate, TestUtilities.UnwrapNullable <DateTime>(payload));
Assert.Equal(5, evt.PayloadValue(1, "anInt"));
}));
DateTime?nullableDate2 = null;
tests.Add(new SubTest("WriteEvent/SelfDescribingOnly/DateTimeNull",
delegate()
{
logger.EventNullableDateTimeInt(nullableDate2, 5);
},
delegate(Event evt)
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventNullableDateTimeInt", evt.EventName);
var payload = evt.PayloadValue(0, "nullableDate");
Assert.Equal(nullableDate2, TestUtilities.UnwrapNullable <DateTime>(nullableDate2));
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);
}
}
