// -------------------------------------------------------------------------------------------------
// Gets dissasembly source
//
// \param [in,out] tf
// The tf.
// \param maxlines
// The maxlines.
//
// \return The dissasembly source.
// -------------------------------------------------------------------------------------------------
public string GetDissasemblySource(ref TraceFile tf, int maxlines, int currentline)
{
string textfile = "";
tf.lines.Clear();
int lineNumber = 0;
for (int i = 0; i < maxlines - 1; i++)
{
textfile = textfile + DissasemblyLines[currentline].line + "\n";
if (DissasemblyLines[currentline].addr >= 0)
{
LineData ld = new LineData();
ld.lineNumber = lineNumber;
ld.nextAddress = new NextAddress(DissasemblyLines[currentline].addr, NextAddress.GetBankFromAddress(ref MainForm.banks, DissasemblyLines[currentline].addr));
ld.tf = tf;
tf.lines.Add(ld);
}
lineNumber++;
currentline++;
}
return(textfile);
}
static void Main()
{
const string traceFile = "trace.trc";
var reader = new TraceFile();
reader.InitializeAsReader(traceFile);
var unitTestModels = new List <UnitTestModel>();
while (reader.Read())
{
var unitTest = new UnitTestModel()
{
SqlCommand = HttpUtility.HtmlEncode(reader.SafeValue("TextData", "")),
UnitTestName = reader.SafeValue("ObjectName", ""),
Duration = GetDuration(reader)
};
if (!string.IsNullOrEmpty(unitTest.SqlCommand) && (unitTest.SqlCommand != "exec sp_reset_connection") && (unitTest.UnitTestName != "sp_executesql"))
{
unitTestModels.Add(unitTest);
}
}
foreach (var unitTestModel in unitTestModels)
{
if (unitTestModel.UnitTestName == "usp_CORE_GetRevenueStreamList")
{
Console.WriteLine("Crap");
}
CreateUnitTest(unitTestModel);
}
}
protected override void DisposeTraces()
{
TraceFile.Close();
TraceFile = null;
OnLogLine = null;
Tracable.DefaultOnLogLine = null;
}
public static bool SafeBool(this TraceFile dr, string columnName, bool defaultValue)
{
var dbValue = dr[columnName];
if (dbValue == DBNull.Value || dbValue == null)
{
return(defaultValue);
}
bool bValue;
if (dbValue is bool)
{
bValue = (bool)dbValue;
}
else
{
switch ((int)dbValue)
{
case 1:
bValue = true;
break;
case 0:
bValue = false;
break;
default:
bValue = defaultValue;
break;
}
}
return(bValue);
}
public void Prepare(ref Log returnLog)
{
try
{
TraceFile source = new TraceFile();
source.InitializeAsReader(TraceSource);
while (source.Read())
{
foreach (SQLEvent sqlEvent in EventList)
{
if (source.GetString(source.GetOrdinal("EventClass")) == sqlEvent.EventName)
{
SQLStatement newStatement = new SQLStatement();
newStatement.Statement = source.GetString(source.GetOrdinal("TextData"));
newStatement.ConnectionString = ConnectionString == "{PARENT}" ? _config.SourceConnectionString : ConnectionString;
QueryList.Add(newStatement);
}
}
}
returnLog.EndTime = DateTime.Now;
returnLog.Message = "Prepare successful.";
}
catch (Exception ex)
{
returnLog.EndTime = DateTime.Now;
returnLog.Successful = false;
returnLog.Message = "Prepare failed - " + ex.Message;
}
}
protected override void CreateTraces()
{
base.CreateTraces();
TraceFile = new TraceFile();
OnLogLine = (line) => TraceFile.OutLine(line);
Tracable.DefaultOnLogLine = OnLogLine;
}
public void CompareGetHandles()
{
TraceFile.SetName("CompareGetHandles");
var list1 = new List <IntPtr>();
var list2 = new List <IntPtr>();
var intPtrComparer = new IntPtrComparer();
list1.AddRange(Win32Window.GetHandles());
list2.AddRange(Win32Window.GetHandles2());
list1.Sort(intPtrComparer);
list2.Sort(intPtrComparer);
TraceFile
.Get("CompareGetHandles-List1")
.Each(list1, (trace, handle) => trace.OutLine(handle.ToRepr()))
.Close()
;
TraceFile
.Get("CompareGetHandles-List2")
.Each(list2, (trace, handle) => trace.OutLine(handle.ToRepr()))
.Close()
;
CollectionAssert.AreEqual(list1, list2);
}
public static Exception Send(MessageSmtp messagesmtp, bool Trace = false)
{
Exception Result = null;
SmtpClient client = (SmtpClient)_ServeurInfo;
MailMessage message = (MailMessage)messagesmtp;
if (Trace)
{
TraceFile.WriteLine("<----------");
TraceFile.WriteLine($" Subjet {message.Subject}");
TraceFile.WriteLine($" To {messagesmtp.To.Aggregate((a, b) => a + ";" + b)}");
}
try
{
client.Send(message);
}
catch (Exception ex)
{
Result = new Exception($"Echec du message {message.Subject}", ex);;
}
#if NET45
client.Dispose();
#endif
if (Trace)
{
TraceFile.WriteLine("---------->");
}
return(Result);
}
public void RegisterShortcutTest()
{
TraceFile.SetName(string.Format("{0}-RegisterShortcutTest", GetType().Name));
RunServiceWin.AddFuncMessageProcessor((message) =>
{
this.LogLine(" Message : {0} - {1} - {2} - {3}", message.handle.ToRepr(), message.message.ToRepr(), message.wParam.ToString(), message.lParam.ToString());
return(IntPtr.Zero);
});
int count = 0;
var shortcut = Service.GetShortcut(GetKey("N"), KeyModifier.Alt);
var operation = new Operation("Test", () =>
{
this.LogLine(string.Format(" Shortcut called"));
count++;
});
this.LogLine("Start main call");
var registeredShortcut = Service.RegisterShortcut(shortcut, operation);
this.LogLine("Stop main call");
Win32.PostMessage(RunServiceWin.Handle, WM.USER + 2, 0, 0);
Win32.PostMessage(RunServiceWin.Handle, WM.USER + 5, 0, 0);
Win32.PostMessage(RunServiceWin.Handle, WM.USER + 7, 0, 0);
RunService.RunFor(new TimeSpan(0, 0, 10));
Assert.AreEqual(1, count);
}
private void ProcessTraceFile(TraceFile trace, Archive archive, Config config, LineCoverageMerger coverageMerger)
{
if (trace.IsEmpty())
{
logger.Info("Archiving {trace} because it does not contain any coverage", trace.FilePath);
archive.ArchiveEmptyFile(trace.FilePath);
return;
}
string processPath = trace.FindProcessPath();
if (processPath == null)
{
logger.Info("Archiving {trace} because it does not contain a Process= line", trace.FilePath);
archive.ArchiveFileWithoutProcess(trace.FilePath);
return;
}
Config.ConfigForProcess processConfig = config.CreateConfigForProcess(processPath);
IUpload upload = uploadFactory.CreateUpload(processConfig, fileSystem);
if (processConfig.PdbDirectory == null)
{
ProcessMethodCoverage(trace, archive, processConfig, upload);
}
else
{
ProcessLineCoverage(trace, archive, config, processConfig, upload, coverageMerger);
}
}
private static void ProcessMethodCoverage(TraceFile trace, Archive archive, Config.ConfigForProcess processConfig, IUpload upload)
{
string version = trace.FindVersion(processConfig.VersionAssembly);
if (version == null)
{
logger.Info("Archiving {trace} because it does not contain the version assembly {versionAssembly}",
trace.FilePath, processConfig.VersionAssembly);
archive.ArchiveFileWithoutVersionAssembly(trace.FilePath);
return;
}
string prefixedVersion = processConfig.VersionPrefix + version;
logger.Info("Uploading {trace} to {upload} with version {version}", trace.FilePath, upload.Describe(), prefixedVersion);
if (RunSync(upload.UploadAsync(trace.FilePath, prefixedVersion)))
{
archive.ArchiveUploadedFile(trace.FilePath);
}
else
{
logger.Error("Upload of {trace} to {upload} failed. Will retry later", trace.FilePath, upload.Describe());
}
}
public void CloseDataFile()
{
if (TraceFile != null)
{
TraceFile.Close();
TraceFile = null;
}
}
static TimeSpan GetDuration(TraceFile reader)
{
DateTime startTime = reader.SafeValue("StartTime", DateTime.Now);
DateTime endTime = reader.SafeValue("EndTime", DateTime.Now);
TimeSpan duration = endTime - startTime;
return(duration);
}
private void FunctionComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (FunctionComboBox.SelectedIndex < 0)
{
return;
}
TraceFile.GotoLabel(Labels.labels[FunctionComboBox.SelectedIndex]);
}
public void ShowSyncTest()
{
TraceFile.SetName("ShowSyncTest");
var window = GetTestForms().First();
Assert.IsNotNull(Service.ShowSync(window));
Service.UnmanageSync(window);
}
private static void FindDifferences(TraceFile traceFileA, TraceFile traceFileB)
{
if (traceFileA != null && traceFileB != null)
{
traceFileA.LoadTraceFile();
traceFileB.LoadTraceFile();
AnalysisEngine.FindDifferences(traceFileA, traceFileB);
AnalysisEngine.FindDifferences(traceFileB, traceFileA);
}
}
public void GetScreensTest()
{
TraceFile.SetName("GetScreensTest");
var screens = Service.GetScreens();
foreach (var screen in screens.Cast <IScreen>())
{
this.LogLine("{0} {1}", screen.Name, screen.Rectangle.ToRepr());
}
}
public static void CloseTraceFile()
{
if (TraceStream != null)
{
TraceLine("*** END ***");
TraceStream.Close();
TraceFile.Close();
TraceStream = null;
TraceFile = null;
}
}
public void GetMonitorsTest()
{
TraceFile.SetName("GetMonitorsTest");
var screens = Win32Monitor.GetMonitors();
foreach (var screen in screens)
{
this.LogLine("Monitor[{0}][{1}]", screen.Id, screen.Rectangle.Canonical);
}
Assert.IsTrue(true);
}
public void MoveSyncTest()
{
TraceFile.SetName("MoveSyncTest");
var window = GetTestForms().First();
Assert.IsNotNull(Service.MoveSync(window, new Rectangle(800, 600, 2000, 200)));
Service.FocusWindowSync(window);
Thread.Sleep(5000);
Service.UnmanageSync(window);
}
public void FocusPC()
{
if (myNewRegisters == null)
{
return;
}
int pc = myNewRegisters.GetRegisterValueint(Registers.Z80Register.pc);
int bank = MainForm.banks[TraceFile.GetBankIndex(pc)];
TraceFile.SetPC(pc, bank, true);
}
// -------------------------------------------------------------------------------------------------
// Event handler. Called by SourceTab for selected index changed events
//
// \param sender
// Source of the event.
// \param e
// Event information.
// -------------------------------------------------------------------------------------------------
private void SourceTab_SelectedIndexChanged(object sender, EventArgs e)
{
TabPage current = (sender as TabControl).SelectedTab;
TraceFile tf = TraceFile.GetByTabPage(current);
if (tf == null)
{
return;
}
MainForm.sourceCodeView.UpdateMarginAddress(tf);
}
/// <summary>
/// Tries to read the revision file based on the config. Logs and returns null if this fails.
/// </summary>
private RevisionFileUtils.RevisionOrTimestamp ParseRevisionFile(TraceFile trace, Config.ConfigForProcess processConfig)
{
try
{
return(RevisionFileUtils.Parse(fileSystem.File.ReadAllLines(processConfig.RevisionFile), processConfig.RevisionFile));
}
catch (Exception e)
{
logger.Error(e, "Failed to read revision file {revisionFile} while processing {traceFile}. Will retry later",
processConfig.RevisionFile, trace.FilePath);
return(null);
}
}
/// -------------------------------------------------------------------------------------------------
/// <summary> Request update. </summary>
///
/// <remarks> 12/09/2018. </remarks>
///
/// <param name="address"> The address. </param>
/// -------------------------------------------------------------------------------------------------
public void RequestUpdate(int pc)
{
int addr = TraceFile.GetCloestValidCodeAddress(pc - 10);
if (addr < 0)
{
Program.telnetConnection.SendCommand("d " + pc.ToString() + " 30", Callback, pc);
}
else
{
Program.telnetConnection.SendCommand("d " + addr.ToString() + " 30", Callback, pc);
}
}
private static void FindAddressFrequency(TraceFile traceFile)
{
if (traceFile == null)
{
foreach (var currentTraceFile in traceFiles)
{
AnalysisEngine.FindAddressFrequency(currentTraceFile);
}
}
else
{
AnalysisEngine.FindAddressFrequency(traceFile);
}
}
public TraceApplicationEngine(string traceFilePath, IEnumerable <NefFile> contracts)
{
this.contracts = contracts.ToDictionary(c => Neo.SmartContract.Helper.ToScriptHash(c.Script), c => (Script)c.Script);
traceFile = new TraceFile(traceFilePath, this.contracts);
while (traceFile.TryGetNext(out var record))
{
ProcessRecord(record);
if (record is TraceRecord trace)
{
currentTraceRecord = trace;
break;
}
}
}
// -------------------------------------------------------------------------------------------------
// Event handler. Called by parseTraceDataToolStripMenuItem for click events
//
// \param sender
// Source of the event.
// \param e
// Event information.
// -------------------------------------------------------------------------------------------------
private void parseTraceDataToolStripMenuItem_Click(object sender, EventArgs e)
{
openFileDialog1.Filter = "Trace Files|tracedata.txt";
openFileDialog1.Title = "Select a Trace File";
openFileDialog1.CheckFileExists = true;
if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
TraceDataPath = openFileDialog1.FileName;
TraceFile.ParseTraceData(openFileDialog1.FileName);
if (mySourceWindow != null)
{
mySourceWindow.InitSourceWindow(Path.GetDirectoryName(openFileDialog1.FileName));
}
}
}
public void ChangeWindow()
{
TraceFile.SetName("ChangeWindow");
ChangeWindow
(
(handle) =>
{
Win32Window.ChangeWindowStyles(handle, 0, WS.MINIMIZEBOX | WS.MAXIMIZEBOX | WS.THICKFRAME, 0, 0);
},
(handle, window) =>
{
Win32Window.MoveWindowAndRedraw(handle, window.RectangleCurrent);
Win32Window.FocusWindow(handle);
}
);
}
public void WriteHeader(ToolConfigReportVid[] vids)
{
string headerString = "TimeStamp";
for (int index = 0; index < vids.Length; index++)
{
headerString = headerString + "," + vids[index].name;
}
headerString = headerString + "\n";
Byte[] byteArr = Encoding.UTF8.GetBytes(headerString);
int len = Encoding.UTF8.GetByteCount(headerString);
TraceFile.Write(byteArr, 0, len);
HeaderWritten = true;
}
public void IntersectTest(IRectangle rectangle1, IRectangle rectangle2, IRectangle rectangleExpected)
{
TraceFile.SetName("IntersectTest");
var result = Service.Intersect(rectangle1, rectangle2);
if (rectangleExpected == null)
{
Assert.IsNull(result);
}
else
{
Assert.AreEqual(rectangleExpected.Left(), result.Left(), 0, "Left");
Assert.AreEqual(rectangleExpected.Top(), result.Top(), 0, "Top");
Assert.AreEqual(rectangleExpected.Width(), result.Width(), 0, "Width");
Assert.AreEqual(rectangleExpected.Height(), result.Height(), 0, "Height");
}
}
public IObservable<IEventBase> GetEvents()
{
if (null != connectionInfo)
{
return GetEvents(() =>
{
var trace = new TraceServer();
trace.InitializeAsReader(this.connectionInfo, this.filename);
return trace;
});
}
else
{
return GetEvents(() =>
{
var trace = new TraceFile();
trace.InitializeAsReader(filename);
return trace;
});
}
}
private void ReadTraceFile(string filename)
{
var traceFile = new TraceFile();
traceFile.InitializeAsReader(filename);
var eventClassOrdinal = traceFile.GetOrdinal("EventClass");
var textDataOrdinal = traceFile.GetOrdinal("TextData");
//var databaseNameOrdinal = traceFile.GetOrdinal("DatabaseName");
var startTimeOrdinal = traceFile.GetOrdinal("StartTime");
var durationOrdinal = traceFile.GetOrdinal("Duration");
while (traceFile.Read())
{
var eventClass = traceFile.GetString(eventClassOrdinal);
// skip on start, end on stop
if (eventClass.Equals("trace start", StringComparison.InvariantCultureIgnoreCase)) continue;
if (eventClass.Equals("trace stop", StringComparison.InvariantCultureIgnoreCase)) break;
var textData = traceFile.GetString(textDataOrdinal);
//var databaseName = traceFile.GetString(databaseNameOrdinal);
var startTime = traceFile.GetDateTime(startTimeOrdinal);
var duration = traceFile.GetInt64(durationOrdinal)/1000; // duration is in microseconds
// send the canonical query to the agent
_agentConnect.Store(new Sample
{
//Method = databaseName,
Uri = _parser.Rewrite(textData),
ResponseTime = duration,
Timestamp = startTime.Ticks
}, Logger);
DebugHelper.LogEntry(_eventLog, string.Format("Data sent: '{0}'", textData), EventLogEntryType.SuccessAudit);
}
traceFile.Close();
}
//public event WriteNotifyEventHandler WriteNotifyEventHandler;
// Optional Notify handler
//void writer_WriteNotify(object sender, TraceEventArgs args)
//{
// this.toolStripStatusLabel1.Text = string.Format("Writing: {0}", args.CurrentRecord[0]);
// args.SkipRecord = false;
//}
public void Save(string filename)
{
TraceFile writer = new TraceFile();
writer.InitializeAsWriter(this.trace, filename);
//if (WriteNotifyEventHandler != null) writer.WriteNotify += WriteNotifyEventHandler;
while (writer.Write()) ;
writer.Close();
}
