public void Performance_Tracing_To_DebugOutput()
{
TracerConfig.Reset(@"DebugOutput; * *");
Action acc = GenerateTraces;
acc.Profile(50 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Trace_From_ManyThreads()
{
TracerConfig.Reset("null;* *");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
List <Thread> threads = new List <Thread>();
int Threads = 5;
int GenerateCount = 10 * 1000;
int LinesPerGenerate = 5;
for (int i = 0; i < Threads; i++)
{
Thread t = new Thread(new ParameterizedThreadStart(GenerateTraces));
t.IsBackground = true;
t.Start(GenerateCount);
threads.Add(t);
}
threads.ForEach((t) => t.Join());
Assert.AreEqual(Threads * GenerateCount * LinesPerGenerate, stringTracer.Messages.Count);
HashSet <int> threadIds = new HashSet <int>();
foreach (var line in stringTracer.Messages)
{
threadIds.Add(int.Parse(line.Substring(20, 4)));
}
Assert.AreEqual(Threads, threadIds.Count);
}
public void Performance_Tracing_To_Null_Device_Not_Matching()
{
TracerConfig.Reset("null; xxx *");
Action acc = GenerateTraces;
acc.Profile(500 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Trace_Only_Exceptions()
{
TracerConfig.Reset("null;* Exception");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
const int Runs = 20;
for (int i = 0; i < Runs; i++)
{
string exStr = "Ex Nr" + i;
try
{
using (Tracer tr1 = new Tracer(myType, "Enclosing Method"))
{
using (Tracer tracer = new Tracer(myType, "Thread Method"))
{
throw new NotImplementedException(exStr);
}
}
}
catch (Exception)
{ }
Assert.AreEqual(i + 1, stringTracer.Messages.Count);
Assert.IsTrue(stringTracer.Messages[i].Contains(exStr),
String.Format("Got {0} but did not find substring {1}", stringTracer.Messages[i], exStr));
}
}
public void Performance_Static_Traces_To_Null_Device()
{
TracerConfig.Reset("null; * *");
Action acc = GenerateStaticTraces;
acc.Profile(500 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Performance_Tracing_To_File()
{
TracerConfig.Reset(@"file c:\temp\trace_uTest.txt; * *");
Action acc = GenerateTraces;
acc.Profile(50 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Performance_Tracing_Is_Off()
{
TracerConfig.Reset(null);
Action acc = GenerateTraces;
acc.Profile(5 * 1000 * 1000, "Could trace {0} with {frequency} traces/s in {time}s");
}
public void Can_Trace_Info()
{
TracerConfig.Reset("null;* *");
Tracer t = new Tracer();
t.Info("Hello world {0}", "test");
t.Warning("");
t.Error("");
t.Dispose();
}
public void Trace_Static_Messages_To_DebugOutput()
{
TracerConfig.Reset("debugoutput");
const string MethodName = "Trace_Static_Messages_To_DebugOutput";
Tracer.Info(Level.L1, myType, MethodName, "Info {0}", "world");
Tracer.Warning(Level.L2, myType, MethodName, "Warning {0}", "world");
Tracer.Error(Level.L3, myType, MethodName, "Error {0}", "world");
Tracer.Error(Level.L4, myType, MethodName, new Exception("Test Exception"));
Tracer.Error(Level.L5, myType, MethodName, new Exception("Other Test Exception"), "Error {0}", "world");
}
public void Trace_Instance_Messages_To_DebugOutput()
{
TracerConfig.Reset("debugoutput");
using (Tracer t = new Tracer(myType, "Test_Method"))
{
t.Info("Info message");
t.Warning("Warning message");
t.Error("Error message");
}
}
public void Inject_Fault_After_File_Open()
{
DoSomeLogic();
TracerConfig.Reset("null");
Tracer.TraceEvent += (severity, typemethod, time, message) =>
{
if (severity == Tracer.MsgType.Instrument)
{
throw new IOException("Hi this is an injected fault");
}
};
Assert.Throws <IOException>(() => DoSomeLogic());
}
public void Leave_Method_WithException()
{
TracerConfig.Reset("debugoutput");
try
{
using (Tracer t = new Tracer(myType, "Leave_Method_WithException"))
{
throw new InvalidCastException("test ex");
}
}
catch (Exception)
{
}
}
public void Performance_Of_Action_Delegate()
{
int called = 0;
TracerConfig.Reset("null;* Level1");
Action prof = () =>
{
Tracer.Execute(MessageTypes.Info, Level.L1, myType, () => called++);
};
const int Runs = 1000 * 1000;
prof.Profile(Runs, "Could execute {0} trace callbacks with {frequency} calls/s in {time}s");
Assert.AreEqual(Runs, called);
Console.WriteLine("Executed {0}", called);
}
public void Every_Thread_Prints_His_Exception_Only_Once()
{
TracerConfig.Reset("null");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
ThreadStart method = () =>
{
try
{
using (Tracer tr1 = new Tracer(myType, "Enclosing Method"))
{
using (Tracer tracer = new Tracer(myType, "Thread Method"))
{
throw new NotImplementedException(Thread.CurrentThread.Name);
}
}
}
catch (Exception)
{ }
};
List <Thread> threads = new List <Thread>();
const int ThreadCount = 3;
List <string> threadNames = new List <string>();
for (int i = 0; i < ThreadCount; i++)
{
Thread t = new Thread(method);
string threadName = "Tracer Thread " + i;
t.Name = threadName;
threadNames.Add(threadName);
t.Start();
threads.Add(t);
}
threads.ForEach(t => t.Join());
var exLines = stringTracer.GetMessages(line => line.Contains("Exception"));
Assert.AreEqual(ThreadCount, exLines.Count);
for (int i = 0; i < threadNames.Count; i++)
{
Assert.IsTrue(exLines.Any(traceLine => traceLine.Contains(threadNames[i])),
String.Format("Thread with name {0} not found in output", exLines[i]));
}
Assert.AreEqual(ThreadCount * 5, stringTracer.Messages.Count);
}
public void When_Level2_IsEnabled_NoOtherTracesArrive()
{
TracerConfig.Reset("null;* level2");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
GenerateLevelTraces(Level.L1);
try
{
Assert.AreEqual(0, stringTracer.Messages.Count);
}
finally
{
ExceptionHelper.WhenException(() => stringTracer.Messages.ForEach((str) => Console.Write(str)));
}
}
public void Events_Can_Survive_TraceConfig_Reset()
{
TracerConfig.Reset("null");
Tracer.TraceEvent += (msgType, typemethod, time, msg) =>
{
if (msg == "Error trace")
{
throw new InvalidOperationException("Injectect Fault");
}
};
Assert.Throws <InvalidOperationException>(() => GenerateLevelTraces(Level.All));
TracerConfig.Reset("null", false);
Assert.Throws <InvalidOperationException>(() => GenerateLevelTraces(Level.All));
TracerConfig.Reset("null", true);
GenerateLevelTraces(Level.All);
}
public void Can_Inject_Faults()
{
TracerConfig.Reset("null");
GenerateLevelTraces(Level.All);
Tracer.TraceEvent += (msgType, typemethod, time, msg) =>
{
if (msgType == Tracer.MsgType.Error)
{
throw new InvalidOperationException("Injectect Fault");
}
};
Assert.Throws <InvalidOperationException>(() => GenerateLevelTraces(Level.All));
TracerConfig.Reset(null);
GenerateLevelTraces(Level.All);
}
public void When_Level1_And_Error_IsEnabled_NothingElse_Must_Pass()
{
TracerConfig.Reset("null;* l1+error");
StringListTraceListener stringTracer = new StringListTraceListener();
TracerConfig.Listeners.Add(stringTracer);
GenerateLevelTraces(Level.L1);
try
{
Assert.AreEqual(4, stringTracer.Messages.Count);
}
finally
{
ExceptionHelper.WhenException(() => stringTracer.Messages.ForEach((str) => Console.Write(str)));
}
}
public void Inject_Fault_During_Stream_Read()
{
TracerConfig.Reset("null");
DoSomeLogic();
int lineCount = 0;
Tracer.TraceEvent += (severity, typemethod, time, message) =>
{
if (severity == Tracer.MsgType.Information && message.Contains("Got line from"))
{
lineCount++;
if (lineCount == 2)
{
throw new IOException("Exception during read of second line");
}
}
};
Assert.Throws <IOException>(() => DoSomeLogic());
}
public void AA_Enable_DebugOutput()
{
TracerConfig.Reset("debugoutput");
}
public CommandData Parse(string[] args)
{
CommandData cmdArgs = new CommandData();
myArgs = args;
for (myParseIdx = 0; myParseIdx < args.Length; myParseIdx++)
{
string curArg = MakeArgLowerCase(args[myParseIdx]);
List <string> hookCmd = null;
curArg = TranslateShortToLong(curArg);
switch (curArg)
{
case "corflags":
cmdArgs.Command = Commands.CorFlags;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd);
break;
case "cwd":
var rootDir = NextOptionForArgument();
if (rootDir.Count == 0)
{
cmdArgs.InvalidComandLineSwitch = "cwd";
break;
}
cmdArgs.Cwd = rootDir[0];
break;
case "diff":
cmdArgs.Command = Commands.Diff;
DoNotExpectAdditionalParameters(cmdArgs);
break;
case "in":
AddQuery(cmdArgs.Queries2, cmdArgs);
break;
case "old":
AddQuery(cmdArgs.Queries1, cmdArgs);
break;
case "old2":
AddQuery(cmdArgs.OldFiles2, cmdArgs);
break;
case "searchin":
AddQuery(cmdArgs.SearchInQuery, cmdArgs);
break;
case "new":
AddQuery(cmdArgs.Queries2, cmdArgs);
break;
case "imbalance":
cmdArgs.EventSubscriptionImbalance = true;
break;
case "trace":
TracerConfig.Reset("console;* Level1");
break;
case WhoUsesMethodCommand.Argument:
cmdArgs.Command = Commands.MethodUsage;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
string potentialQuery = hookCmd[0];
if (potentialQuery.Contains("("))
{
cmdArgs.TypeAndInnerQuery = potentialQuery;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesTypeCommand.Argument:
cmdArgs.Command = Commands.WhoUsesType;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesFieldCommand.Argument:
cmdArgs.Command = Commands.WhoUsesField;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeAndInnerQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesEventCommand.Argument:
cmdArgs.Command = Commands.WhoUsesEvent;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeAndInnerQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoImplementsInterfaceCommand.Argument:
cmdArgs.Command = Commands.WhoImplementsInterface;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.TypeQuery = hookCmd[0];
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
break;
case WhoUsesStringConstantCommand.Argument:
cmdArgs.Command = Commands.WhoUsesStringConstant;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.StringConstant = hookCmd[0];
if (hookCmd.Count > 1)
{
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd.GetRange(1, hookCmd.Count - 1));
}
break;
case "word":
cmdArgs.WordMatch = true;
break;
case "case":
cmdArgs.CaseSensitiveMatch = true;
break;
case GetFileInfoCommand.Argument:
cmdArgs.Command = Commands.GetFileInfo;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd);
break;
case "whoreferences":
cmdArgs.Command = Commands.WhoReferences;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, hookCmd);
break;
case "getpdbs":
cmdArgs.Command = Commands.DownloadPdbs;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
AddQuery(cmdArgs.Queries1, cmdArgs, new List <string> {
hookCmd[0]
});
if (hookCmd.Count > 1)
{
cmdArgs.PdbDownloadDir = hookCmd[1];
}
if (hookCmd.Count > 2)
{
cmdArgs.InvalidComandLineSwitch = String.Format("The argument {0} is not valid for this command", hookCmd[2]);
}
break;
case "showrebuildtargets":
cmdArgs.Command = Commands.ShowRebuildTargets;
DoNotExpectAdditionalParameters(cmdArgs);
break;
case "showstrongname":
cmdArgs.Command = Commands.ShowStrongName;
AddQuery(cmdArgs.Queries1, cmdArgs);
break;
case "showreferences":
cmdArgs.Command = Commands.ShowReferences;
AddQuery(cmdArgs.Queries1, cmdArgs);
break;
case "verbose":
cmdArgs.Verbose = true;
break;
case "excel":
cmdArgs.OutputToExcel = true;
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
cmdArgs.ExcelOutputFileName = hookCmd[0];
break;
case "threads":
hookCmd = NextOptionForArgument();
if (hookCmd.Count == 0)
{
break;
}
int newThreadCount = 0;
if (int.TryParse(hookCmd[0], out newThreadCount) && newThreadCount > 0)
{
cmdArgs.ThreadCount = newThreadCount;
}
else
{
cmdArgs.InvalidComandLineSwitch = hookCmd[0];
}
break;
case "fileinfo":
cmdArgs.WithFileInfo = true;
break;
default:
cmdArgs.UnknownCommandLineSwitch = curArg;
break;
}
}
return(cmdArgs);
}
public void AA_Enable_File()
{
TracerConfig.Reset("file");
}
public void AAZ_Disable()
{
TracerConfig.Reset(null);
}
public TraceReset(string newTraceCfg)
{
myOldTraceCfg = TracerConfig.Reset(newTraceCfg);
}
public void Dispose()
{
TracerConfig.Reset(myOldTraceCfg);
}
public void Demo_Show_Leaving_Trace_With_Exception()
{
TracerConfig.Reset("console");
SomeMethod();
}
