public void InnerMethodTest()
{
// checks time, amount, classnames and methodnames
tracer = new Tracer();
tracer.StartTrace();
Thread.Sleep(waitTime);
SingleThreadedMethod();
tracer.StopTrace();
TraceResult traceResult = tracer.GetTraceResult();
Assert.AreEqual(1, traceResult.ThreadResults.Count);
TimeTest(tracer.GetTraceResult().ThreadResults[0].Time, waitTime * 2);
Assert.AreEqual(1, traceResult.ThreadResults[0].MethodResults.Count);
MethodResult methodResult = traceResult.ThreadResults[0].MethodResults[0];
Assert.AreEqual(nameof(TracerUnitTest), methodResult.Class);
Assert.AreEqual(nameof(InnerMethodTest), methodResult.Name);
TimeTest(methodResult.Time, waitTime * 2);
Assert.AreEqual(1, methodResult.MethodsResults.Count);
MethodResult innerMethodResult = methodResult.MethodsResults[0];
Assert.AreEqual(nameof(TracerUnitTest), innerMethodResult.Class);
Assert.AreEqual(nameof(SingleThreadedMethod), innerMethodResult.Name);
TimeTest(innerMethodResult.Time, waitTime);
}
private static void Main()
{
Tracer.StartTrace();
TestMethod1(10);
TestMethod(10);
var threads = new List <Thread>();
for (var i = 0; i < 20; i++)
{
var thread = i % 3 == 0 ? new Thread(TestMethod) : new Thread(TestMethod1);
threads.Add(thread);
thread.Start(5);
}
TestMethod5();
foreach (var thread in threads)
{
thread.Join();
}
Tracer.StopTrace();
var xmlTraceResultFormatter = new XmlTraceResultFormatter();
var jsonTraceResultFormatter = new JsonTraceResultFormatter();
var fileWriter = new FileWriter(jsonTraceResultFormatter, "text.json");
var consoleWriter = new ConsoleWriter(xmlTraceResultFormatter);
consoleWriter.WriteTraceResult(Tracer.GetTraceResult());
fileWriter.WriteTraceResult(Tracer.GetTraceResult());
Console.ReadKey();
}
public void ComparingMethodName()
{
OneMethod.SimpleCall();
string expected = "SimpleCall";
string actual = tracer.GetTraceResult().ThreadResults[0].MethodList[0].MethodName;
Assert.AreEqual(expected, actual);
}
public void MethodNameTest()
{
tracer.GetTraceResult().TracedThreads.First();
foreach (KeyValuePair <int, TracedThread> thread in tracer.GetTraceResult().TracedThreads)
{
foreach (TracedMethod method in thread.Value.TracedMethods)
{
Assert.AreEqual(method.Name, "Setup");
}
}
}
public void ExecutionTimeMoreThreadTimeout()
{
Method();
TraceResult traceResult = Tracer.GetTraceResult();
double methodTime = traceResult.GetThreadTraces()[Thread.CurrentThread.ManagedThreadId].MethodInfo[0].GetTime();
double threadTime = traceResult.GetThreadTraces()[Thread.CurrentThread.ManagedThreadId].ThreadTime;
Assert.IsTrue(methodTime >= MillisecondsTimeout);
Assert.IsTrue(threadTime >= MillisecondsTimeout);
}
static private TraceResult DoCalculations()
{
tracer = new SomeTracer();
MakeThreads();
while (tracer.GetTraceResult() == null)
{
Thread.Sleep(50);
}
return(tracer.GetTraceResult());
}
public void InitTimeTest()
{
tracer.StartTrace();
Thread.Sleep(5);
tracer.StopTrace();
Assert.IsTrue(5 <= tracer.GetTraceResult().serializableThreads[0].time);
}
public static void Main(string[] args)
{
Thread newThread = new Thread(new ThreadStart(FooNestedCall));
newThread.Start();
Thread anotherThread = new Thread(new ThreadStart(FooRecursionCall));
anotherThread.Start();
foo.SecondFooMethod();
foo.ThirdFooMethod();
Console.Write("Tracing started. Results will be written to:\n" +
"1. 'Results/XMLResult.xml' - the result of xml serialization\n" +
"2. 'Results/JSONResult.json - the result of json serialization\n" +
"3. console\n\n");
Console.WriteLine("Serialization to XML:\n");
FileStream fileStream = new FileStream("Results/XMLResult.xml", FileMode.OpenOrCreate);
ISerializer serializer = new XmlSerializer();
MemoryStream memoryStream = (MemoryStream)serializer.Serialize(_tracer.GetTraceResult());
memoryStream.Position = 0;
memoryStream.CopyTo(fileStream);
memoryStream.Position = 0;
memoryStream.CopyTo(Console.OpenStandardOutput());
Console.WriteLine("\n\nSerialization to JSON:\n");
fileStream = new FileStream("Results/JSONResult.json", FileMode.OpenOrCreate);
serializer = new JsonSerializer();
memoryStream = (MemoryStream)serializer.Serialize(_tracer.GetTraceResult());
memoryStream.Position = 0;
memoryStream.CopyTo(fileStream);
memoryStream.Position = 0;
memoryStream.CopyTo(Console.OpenStandardOutput());
fileStream.Close();
memoryStream.Close();
Console.WriteLine("\n\nPress any key to exit...");
Console.Read();
}
public void TestSingleMethod()
{
SingleMethod();
TraceResult traceResult = tracer.GetTraceResult();
int threadId = Thread.CurrentThread.ManagedThreadId;
ThreadInfo threadInfo;
traceResult.threads.TryGetValue(threadId, out threadInfo);
long countedTime = threadInfo.methods[0].time;
Assert.AreEqual(nameof(SingleMethod), threadInfo.methods[0].name);
Assert.AreEqual(nameof(TracerTest), threadInfo.methods[0].className);
Assert.AreEqual(0, threadInfo.methods[0].methods.Count);
Assert.IsTrue(countedTime >= SLEEP_TIME);
}
static void Main(string[] args)
{
tracer = new ITracerImplementation();
while (serializer == null)
{
Console.WriteLine("Hello! please, selecct serialization method:\n J) json\nX) xml");
//input = Console.ReadLine();
pressedKey = Console.ReadKey(true);
switch (pressedKey.Key)
{
case ConsoleKey.J:
serializer = new jsonSer();
break;
case ConsoleKey.X:
serializer = new xmlSer();
break;
default:
Console.Clear();
Console.WriteLine("ONLY J AND X ALLOWED!!!");
pressedKey = Console.ReadKey(true);
break;
}
Console.Clear();
}
tracer.StartTrace();
tr1 = new Thread(threadProc1);
tr2 = new Thread(threadProc2);
tr1.Start();
tr2.Start();
new cl2(tracer).m1();
tr1.Join();
tr2.Join();
tracer.StopTrace();
TraceResult tr = tracer.GetTraceResult();
writer = new consoleWriter();
writer.save(serializer.serialize(tr));
writer = new fileWriter("myfile.txt");
writer.save(serializer.serialize(tracer.GetTraceResult()));
}
public void TestTracerResultHaveNestedMethods()
{
Tracer.StartTrace();
ActionClass.Job1();
ActionClass.Job2();
Tracer.StopTrace();
Assert.Less(
1, Tracer.GetTraceResult()
.GetThreadLogs()[Thread.CurrentThread.ManagedThreadId]
.AllMethods[0]
.NestedMethods.Count,
"Total amount of Nested method should be greater than 1");
}
static void Main(string[] args)
{
InitializeFormattersDictionary();
ITraceResultFormatter formatter;
try
{
formatter = formatters[args[0]];
}
catch (Exception)
{
formatter = new ConsoleTraceResultFormatter();
}
InitializeMethods();
tracer.StartTrace();
StartThreads();
SomeTestMethod5();
Thread.Sleep(GetRandomTimeInMilliseconds());
StopThreads();
tracer.StopTrace();
TraceResult traceResult = tracer.GetTraceResult();
formatter.Format(traceResult);
SayGoodBye();
}
public void TestSingleMethod()
{
SingleMethod();
TraceResult traceResult = tracer.GetTraceResult();
int threadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
ThreadInfo threadInfo;
traceResult.threads.TryGetValue(threadId.ToString(), out threadInfo);
string time = threadInfo.methods[0].time;
int countedTime = Int32.Parse(time.Substring(0, time.Length - 2));
Assert.AreEqual(nameof(SingleMethod), threadInfo.methods[0].name);
Assert.AreEqual(nameof(TracerTest), threadInfo.methods[0].className);
Assert.AreEqual(0, threadInfo.methods[0].methods.Count);
Assert.IsTrue(countedTime >= SLEEP_TIME);
}
static void Main(string[] args)
{
Func4();
Func1();
Func6();
Func6();
Thread thread1 = new Thread(Func5);
thread1.Start();
thread1.Join();
Thread thread2 = new Thread(Func3);
thread2.Start();
thread2.Join();
Thread.Sleep(rnd.Next(sleepTimeCeiling));
TotalTraceResult totalTraceResult = tracer.GetTraceResult();
ITraceResultFormatter consoleFormatter = new ConsoleTraceResultFormatter();
consoleFormatter.Format(totalTraceResult);
ITraceResultFormatter xmlFormatter = new XmlTraceResultFormatter(pathToXml);
xmlFormatter.Format(totalTraceResult);
Console.Read();
}
public void MultiThreadTest()
{
// only checks time
tracer = new Tracer();
var threads = new List <Thread>();
long expected = 0;
Thread newThread;
for (int i = 0; i < threadsCount; i++)
{
newThread = new Thread(SingleThreadedMethod);
threads.Add(newThread);
newThread.Start();
expected += waitTime;
}
foreach (Thread thread in threads)
{
thread.Join();
}
long actual = 0;
foreach (ThreadResult threadResult in tracer.GetTraceResult().ThreadResults)
{
actual += threadResult.Time;
}
TimeTest(actual, expected);
}
public static void ClassInitilize(TestContext context)
{
tracer = new Tracer();
TestMethod_1();
traceResult = tracer.GetTraceResult();
resultWriter = new ResultWriter();
}
public void CalculatesTraceResult()
{
_tracer = new Tracer();
time1 = new Random().Next(50);
time2 = new Random().Next(50);
time3 = new Random().Next(50);
var thread1 = new Thread(() =>
{
tracingMethod1(time1);
tracingMethod2(time2);
});
thread1.Start();
var thread2 = new Thread(() =>
{
tracingMethod2(time3);
});
thread2.Start();
thread1Id = thread1.ManagedThreadId;
thread2Id = thread2.ManagedThreadId;
thread1.Join();
thread2.Join();
var traceResult = _tracer.GetTraceResult();
Assert.IsType <TraceResult>(traceResult);
assertThreads(traceResult);
}
public string Serialize(ITracer tracer)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(ThreadsResult));
using (StringWriter textWriter = new StringWriter())
{
xmlSerializer.Serialize(textWriter, tracer.GetTraceResult());
return(textWriter.ToString());
}
}
static void Main(string[] args)
{
_threads = new List <Thread>();
_tracer = new Tracer();
CreateThreads();
var list = _tracer.GetTraceResult().ThreadsDictionary.Values.ToList();
new ConsoleWriter().WriteFile(new XmlFileSerializer(), list);
new ConsoleWriter().WriteFile(new JSonFileSerializer(), list);
}
public void SingleThreadTest()
{
// only checks time
tracer = new Tracer();
tracer.StartTrace();
Thread.Sleep(waitTime);
tracer.StopTrace();
long actual = tracer.GetTraceResult().ThreadResults[0].Time;
TimeTest(actual, waitTime);
}
public static void Main(string[] args)
{
_tracer.StartTrace();
Thread thread1 = new Thread(M2);
Thread thread2 = new Thread(M2);
_A = new A(_tracer);
_B = new B(_tracer);
_A.MethodA();
_B.MethodB();
thread1.Start();
thread2.Start();
_tracer.StopTrace();
thread1.Join();
thread2.Join();
_tracer.GetTraceResult();
DisplayResult();
Console.ReadKey();
}
public void TracerTest()
{
int await = rnd.Next(100, 1000);
Stopwatch st3 = System.Diagnostics.Stopwatch.StartNew();
tracer.StartTrace();
Thread.Sleep(await);
tracer.StopTrace();
st3.Stop();
Assert.AreEqual(await, tracer.GetTraceResult().threadz[0].methods[0].avgTimeMilis, _DELTA);
// Assert.Fail("WIP");
}
static void WriteResult()
{
ResultWriter resultWriter = new ResultWriter();
XmlSerializer xmlSerializer = new XmlSerializer();
JsonSerializer jsonSerializer = new JsonSerializer();
TxtWriter txtWriter = new TxtWriter();
TraceResult result = tracer.GetTraceResult();
resultWriter.ResultInConsole(txtWriter, result);
resultWriter.ResultInFile(txtWriter, result, "result");
resultWriter.ResultInFile(jsonSerializer, result, "result");
resultWriter.ResultInFile(xmlSerializer, result, "result");
}
public void Setup()
{
_tracer.StartTrace();
Thread thread1 = new Thread(M2);
Thread thread2 = new Thread(M2);
_A = new A(_tracer);
_B = new B(_tracer);
_A.MethodA();
_B.MethodB();
thread1.Start();
thread2.Start();
_tracer.StopTrace();
thread1.Join();
thread2.Join();
_tracer.GetTraceResult();
ids = _tracer.GetTraceResult()._threadList.Keys.ToArray <int>();
}
public void TwoLevelMultiThreadTest()
{
// checks time, amount, classnames and methodnames
tracer = new Tracer();
var threads = new List <Thread>();
long expected = 0;
Thread newThread;
for (int i = 0; i < threadsCount; i++)
{
newThread = new Thread(MultiThreadedMethod);
threads.Add(newThread);
newThread.Start();
expected += waitTime * (threadsCount + 1);
}
foreach (Thread thread in threads)
{
thread.Join();
}
long actual = 0;
TraceResult result = tracer.GetTraceResult();
foreach (ThreadResult threadResult in result.ThreadResults)
{
actual += threadResult.Time;
}
TimeTest(actual, expected);
Assert.AreEqual(threadsCount * threadsCount + threadsCount, result.ThreadResults.Count);
int multiThreadedMethodCounter = 0, singleThreadedMethodCounter = 0;
MethodResult methodResult;
foreach (ThreadResult threadResult in result.ThreadResults)
{
Assert.AreEqual(threadResult.MethodResults.Count, 1);
methodResult = threadResult.MethodResults[0];
Assert.AreEqual(0, methodResult.MethodsResults.Count);
Assert.AreEqual(nameof(TracerUnitTest), methodResult.Class);
TimeTest(methodResult.Time, waitTime);
if (methodResult.Name == nameof(MultiThreadedMethod))
{
multiThreadedMethodCounter++;
}
if (methodResult.Name == nameof(SingleThreadedMethod))
{
singleThreadedMethodCounter++;
}
}
Assert.AreEqual(threadsCount, multiThreadedMethodCounter);
Assert.AreEqual(threadsCount * threadsCount, singleThreadedMethodCounter);
}
public void TestTreeStructure()
{
_tracer.StartTrace();
_method1();
_method2();
_method3();
_tracer.StopTrace();
var methodInfoArr = _tracer.GetTraceResult().GetThreadTraces()[Thread.CurrentThread.ManagedThreadId].MethodInfo[0];
Assert.AreEqual("_method1", methodInfoArr.ChildMethods[0].MethodName);
Assert.AreEqual("_method2", methodInfoArr.ChildMethods[1].MethodName);
Assert.AreEqual("_method4", methodInfoArr.ChildMethods[1].ChildMethods[0].MethodName);
Assert.AreEqual("_method3", methodInfoArr.ChildMethods[2].MethodName);
}
public static void Main(string[] args)
{
tracer = new StackTracer();
Thread thread = new Thread(StartFastMethods);
thread.Start();
SlowClass slow = new SlowClass(tracer);
slow.SuperSlow();
thread.Join();
Printer printer = new Printer();
printer.AddSerializer(new JSONSerializerAdapter());
printer.AddSerializer(new XMLSerializerAdapter());
printer.AddStream(Console.OpenStandardOutput());
printer.AddStream("output.txt");
printer.Print(tracer.GetTraceResult());
}
static void Main(string[] args)
{
tracer = new SimpleTracer();
clazz = new SimpleClass(tracer);
Thread thread = new Thread(new ThreadStart(Start));
thread.Start();
tracer.StartTrace();
OtherMethod();
tracer.StopTrace();
while (thread.IsAlive)
{
}
var res = tracer.GetTraceResult();
var ser = new JsonTraceResultSerializer();
var str = ser.Serialize(res);
Console.WriteLine(str);
}
static void Main(string[] args)
{
tracer = new Tracer.Tracer();
SimpleMethod();
TraceResult traceResult = tracer.GetTraceResult();
XMLSerializer xml = new XMLSerializer();
ConsoleWriter cw = new ConsoleWriter();
cw.Write(traceResult, xml);
FileWriter fw = new FileWriter("./xml.xml");
fw.Write(traceResult, xml);
JSONSerializer json = new JSONSerializer();
cw.Write(traceResult, json);
fw.FileName = "./json.json";
fw.Write(traceResult, json);
Console.ReadKey();
}
private static void PrintTraceResult()
{
var stream = new MemoryStream();
ITraceResultSerializer traceResultSerializer;
traceResultSerializer = new JSONTraceResultSerializer();
traceResultSerializer.Serialize(stream, tracer.GetTraceResult());
var traceResultWriter = new ConsoleTraceResultWriter();
try
{
traceResultWriter.Write(stream);
}
catch (Exception e)
{
Console.Write(e.Data);
}
finally
{
stream.Close();
Console.ReadLine();
}
}