public void BinarySerTest()
{
var dd = DataDir.Create(DataDirType.Temporary);
dd.CreateIfNotExists();
var data = new TestObject
{
SomeInt = 0xc0ffee,
SomeDouble = 12345.54321,
SomeString = "the quick brown fox jumps over the lazy dog",
SomeNumbers = new int[] { 1, 2, 3, 4, -10, -20, -30, -40 }
};
dd.SerializationFormats.Add(".custom", new MiffTheFox.DataDirs.Serialization.BinarySerializationFormat());
string filename = DateTime.UtcNow.Ticks.ToString("x") + ".custom";
dd.WriteObject(filename, data);
var data2 = dd.ReadObject <TestObject>(filename);
Assert.AreEqual(data, data2);
dd.DeleteFile(filename);
}
public void TestOpenFile()
{
var contents = BinString.FromTextString("Hello, world!\n", System.Text.Encoding.ASCII);
var dd = DataDir.Create(DataDirType.Temporary);
string filename = DateTime.Now.Ticks.ToString("x") + ".tmp";
string fullFilename = Path.Combine(dd.Path, filename);
Assert.IsFalse(File.Exists(fullFilename));
Assert.ThrowsException <FileNotFoundException>(() => dd.OpenFile(filename, FileMode.Open, FileAccess.Read));
using (var stream = dd.OpenFile(filename, FileMode.Create, FileAccess.ReadWrite))
{
stream.Write(contents);
stream.Close();
}
Assert.IsTrue(File.Exists(fullFilename));
Assert.AreEqual(contents, (BinString)File.ReadAllBytes(fullFilename));
using (var stream = dd.OpenFile(filename, FileMode.Open, FileAccess.Read))
{
var read = stream.ReadBinString(contents.Length);
Assert.AreEqual(contents, read);
}
File.Delete(fullFilename);
Assert.ThrowsException <ArgumentException>(() => dd.OpenFile(null, FileMode.Create, FileAccess.ReadWrite));
Assert.ThrowsException <ArgumentException>(() => dd.OpenFile(string.Empty, FileMode.Create, FileAccess.ReadWrite));
}
public void ReadObjectWithCreateTest()
{
var dd = DataDir.Create(DataDirType.Temporary);
dd.CreateIfNotExists();
string filename = dd.GetNewFileName(extension: "json");
Assert.IsFalse(dd.FileExists(filename));
var data = new TestObject
{
SomeInt = 12345,
SomeDouble = 54.321,
SomeString = "ABCD 1234567 abcd",
SomeNumbers = new int[] { -10, -20, 15, -8 }
};
var test1 = dd.ReadObject <TestObject>(filename, () => data);
Assert.AreEqual(test1, data);
test1.SomeInt = -117;
test1.SomeDouble = -42.5;
dd.WriteObject(filename, test1);
var test2 = dd.ReadObject <TestObject>(filename, () => data);
Assert.AreEqual(test1, test2);
Assert.AreNotEqual(data, test2);
}
public void TestSubdirectory()
{
var rng = new Random();
string basePath = Path.Combine(Path.GetTempPath(), "DataDirTests", "subdir");
string testPath;
do
{
testPath = $"{basePath}_{DateTime.Now.Ticks:x}_{rng.Next():x}";
} while (Directory.Exists(testPath));
var dd = new DataDir(testPath);
Assert.IsFalse(dd.DirectoryExists);
dd.CreateIfNotExists();
Assert.IsTrue(dd.DirectoryExists);
Assert.IsTrue(Directory.Exists(testPath));
var subdir = dd.Subdirectory("subdir");
Assert.IsFalse(subdir.DirectoryExists);
subdir.CreateIfNotExists();
Assert.IsTrue(subdir.DirectoryExists);
Directory.Delete(subdir.Path);
Directory.Delete(testPath);
Assert.IsFalse(dd.DirectoryExists);
}
protected ExecutorBase CreateExecutor()
{
try
{
#if NET40 || NET45
return(new AppDomainExecutor(
Assembly.Value(),
DataDir.Value(),
Config.Value(),
RootNamespace.Value(),
Language.Value()));
#elif NETCOREAPP
return(new ReflectionExecutor(
Assembly.Value(),
DataDir.Value(),
Config.Value(),
RootNamespace.Value(),
Language.Value()));
#else
#error Unexpected target framework
#endif
}
catch (FileNotFoundException ex)
when(new AssemblyName(ex.FileName).Name == "EntityFramework")
{
throw new CommandException(
string.Format(
MyResources.EntityFrameworkNotFound,
Path.GetFileNameWithoutExtension(Assembly.Value())),
ex);
}
}
public void AutomaticNameTest()
{
string title = Assembly.GetExecutingAssembly().GetCustomAttributes <AssemblyTitleAttribute>().Select(attr => attr.Title).FirstOrDefault();
var tempDirectory = DataDir.Create(DataDirType.Temporary);
Assert.AreEqual(title, Path.GetFileName(tempDirectory.Path));
}
public void TestDelete()
{
var dd = DataDir.Create(DataDirType.Temporary);
string filename = "DeleteMe-" + DateTime.Now.Ticks.ToString("x") + ".txt";
string stringData = "This file should be deleted.\n";
dd.WriteAllText(filename, stringData, Encoding.ASCII);
Assert.AreEqual(stringData, dd.ReadAllText(filename, Encoding.ASCII));
dd.DeleteFile(filename);
Assert.ThrowsException <FileNotFoundException>(() => dd.ReadAllText(filename, Encoding.ASCII));
}
public void TestSimpleReadWrite()
{
string stringData = "Hello, world! This is a string.\n";
var binData = BinString.FromBytes("09F911029D74E35BD84156C5635688C0");
var dd = DataDir.Create(DataDirType.Temporary);
dd.WriteAllText("test.txt", stringData, System.Text.Encoding.ASCII);
Assert.AreEqual(stringData, dd.ReadAllText("test.txt", Encoding.ASCII));
dd.WriteAllBytes("test.bin", binData);
Assert.AreEqual(binData, dd.ReadAllBytes("test.bin"));
}
public void FailedSerTest()
{
var dd = DataDir.Create(DataDirType.Temporary);
dd.CreateIfNotExists();
string filename = "notfound-" + DateTime.UtcNow.Ticks.ToString("x") + ".json";
Assert.ThrowsException <FileNotFoundException>(() => dd.ReadObject <TestObject>(filename));
Assert.ThrowsException <MiffTheFox.DataDirs.Serialization.UnknownSerializationFormatException>(() => dd.WriteObject("invalid.xyz", 42));
filename = "invalid-" + DateTime.UtcNow.Ticks.ToString("x") + ".json";
dd.WriteAllText(filename, "}{}!{$%{!%#()%(!@#%}!@#{$!}#%", System.Text.Encoding.Unicode);
Assert.ThrowsException <MiffTheFox.DataDirs.Serialization.SerializationFailException>(() => dd.ReadObject <TestObject>(filename));
}
public void TestGetNewFileName()
{
const string testHint = "Test Hint";
var dd = DataDir.Create(DataDirType.Temporary);
string f1 = dd.GetNewFileName(testHint, "tmp");
Assert.IsFalse(dd.FileExists(f1));
dd.WriteAllBytes(f1, BinString.Empty);
Assert.IsTrue(dd.FileExists(f1));
string f2 = dd.GetNewFileName(testHint, "tmp");
Assert.AreNotEqual(f1, f2);
Assert.IsFalse(dd.FileExists(f2));
}
private void _read()
{
_exportTable = new DataDir(m_io, this, m_root);
_importTable = new DataDir(m_io, this, m_root);
_resourceTable = new DataDir(m_io, this, m_root);
_exceptionTable = new DataDir(m_io, this, m_root);
_certificateTable = new DataDir(m_io, this, m_root);
_baseRelocationTable = new DataDir(m_io, this, m_root);
_debug = new DataDir(m_io, this, m_root);
_architecture = new DataDir(m_io, this, m_root);
_globalPtr = new DataDir(m_io, this, m_root);
_tlsTable = new DataDir(m_io, this, m_root);
_loadConfigTable = new DataDir(m_io, this, m_root);
_boundImport = new DataDir(m_io, this, m_root);
_iat = new DataDir(m_io, this, m_root);
_delayImportDescriptor = new DataDir(m_io, this, m_root);
_clrRuntimeHeader = new DataDir(m_io, this, m_root);
}
public void TestGetPath()
{
var data = BinString.FromBytes("C0FFEEC0FFEEC0FFEEC0FFEE");
var dd = DataDir.Create(DataDirType.Temporary);
string filename = DateTime.Now.Ticks.ToString("x") + ".tmp";
string fullPath = dd.GetFullPath(filename);
Assert.IsFalse(File.Exists(fullPath));
dd.WriteAllBytes(filename, data);
Assert.AreEqual(data, (BinString)File.ReadAllBytes(fullPath));
data = BinString.FromTextString("ABCDEFGHIJKLMNOPQRSTUVWXYZ", Encoding.ASCII);
File.WriteAllBytes(fullPath, data);
Assert.AreEqual(data, dd.ReadAllBytes(filename));
Assert.IsTrue(File.Exists(fullPath));
dd.DeleteFile(filename);
Assert.IsFalse(File.Exists(fullPath));
}
public void LocationCreateTests()
{
var l = new List <DataDir>();
string fakeApplicationName = $"DataDir/Test {DateTime.Now:F}";
l.Add(DataDir.Create(fakeApplicationName, type: DataDirType.RoamingUser));
l.Add(DataDir.Create(fakeApplicationName, type: DataDirType.LocalUser));
l.Add(DataDir.Create(fakeApplicationName, type: DataDirType.SystemWide));
l.Add(DataDir.Create(fakeApplicationName, type: DataDirType.Temporary));
l.Add(DataDir.Create(fakeApplicationName, type: DataDirType.SavedGameData));
foreach (var d in l)
{
// DataDir.Create should create the directory on disk
Assert.IsTrue(d.DirectoryExists);
// clean up
Directory.Delete(d.Path);
Assert.IsFalse(d.DirectoryExists);
}
}
public void TestCreation()
{
string testPath = Path.Combine(Path.GetTempPath(), "DataDirTests", "creation");
var d1 = new DataDir(testPath);
Assert.AreEqual(testPath, d1.Path);
Assert.AreEqual(testPath, d1.ToString());
var d2 = new DataDir(testPath);
Assert.IsTrue(d1.Equals(d2));
Assert.IsTrue(d2.Equals(d1));
var d3 = new DataDir(Path.Combine(Path.GetTempPath(), "DataDirTests", "other"));
Assert.IsFalse(d1.Equals(d3));
Assert.IsFalse(d3.Equals(d1));
Assert.ThrowsException <ArgumentException>(() => new DataDir(null));
Assert.ThrowsException <ArgumentException>(() => new DataDir(string.Empty));
Assert.ThrowsException <ArgumentException>(() => new DataDir(testPath + Path.GetInvalidPathChars()[0]));
}
static AuditManager()
{
ScanAssembly(Assembly.GetExecutingAssembly());
if (Assembly.GetEntryAssembly() != Assembly.GetExecutingAssembly())
{
ScanAssembly(Assembly.GetEntryAssembly());
}
FileInfo[] configs = DataDir.GetFiles("config.xml");
if (configs.Length == 1)
{
config = XmlUtils.LoadXml(configs[0]);
}
else
{
config = new XmlDocument();
XmlElement conf = config.CreateElement("config", AUDIT_NS);
config.AppendChild(conf);
conf.SetAttribute("version", "0");
conf.SetAttribute("id", Guid.NewGuid().ToString());
FlushConfig();
}
}
public Form1()
{
InitializeComponent();
_analysis = new Analysis(DataDir.AllPiecesFiles().Take(1).ToArray());
_view = new View
{
Mode = ViewMode.Batch,
BatchMode = BatchViewMode.Corner,
BatchIndex = 0,
ComparisonIndex = 0
};
_options = new Analysis.Options
{
ContourThreshold = 175,
};
cornerThresholdTextBox.Text = "0.012";
Recalculate();
}
public void XmlSerTest()
{
var dd = DataDir.Create(DataDirType.Temporary);
dd.CreateIfNotExists();
string filename = DateTime.UtcNow.Ticks.ToString("x") + ".xml";
var data = new TestObject
{
SomeInt = 123,
SomeDouble = 45.6,
SomeString = "Ξεσκεπάζω τὴν ψυχοφθόρα βδελυγμία",
SomeNumbers = new int[] { 12, 11, 10 }
};
dd.WriteObject(filename, data);
var data2 = dd.ReadObject <TestObject>(filename);
Assert.AreEqual(data, data2);
dd.DeleteFile(filename);
}
public void JsonSerTest()
{
var dd = DataDir.Create(DataDirType.Temporary);
dd.CreateIfNotExists();
string filename = DateTime.UtcNow.Ticks.ToString("x") + ".json";
var data = new TestObject
{
SomeInt = 42,
SomeDouble = 3.14,
SomeString = "asdfghjkl",
SomeNumbers = new int[] { 1, 2, 3, 4, 5 }
};
dd.WriteObject(filename, data);
var data2 = dd.ReadObject <TestObject>(filename);
Assert.AreEqual(data, data2);
dd.DeleteFile(filename);
}
private void _read()
{
_baseRelocationTable = new DataDir(m_io, this, m_root);
_debug = new DataDir(m_io, this, m_root);
}
private void button1_Click(object sender, EventArgs e)
{
imageBox1.Image.Save(DataDir.Contours("SavedFromForms.bmp"), ImageFormat.Bmp);
}
public Setup Statistics(bool opt, decimal share)
{
if (trades.Count == 0)
{
return(null);
}
var groupTrades = trades.GroupBy(t => t.ExitTime.Value.Date).ToDictionary(x => x.Key, y => y.ToList());
var countr = groupTrades.ToDictionary(x => x.Key, y => y.Value.Count);
var cumsum = new Dictionary <DateTime, decimal>();
if (trade == null)
{
trade = trades.LastOrDefault();
}
if (trade.AssetClass != "BMF.FUT")
{
trades.ForEach(t =>
{
t.GetNetResult(t.ExitValue);
t.Cost += t.BkrFixComm / countr[t.ExitTime.Value.Date];
t.NetResult = t.NetResult * share - 100 * t.BkrFixComm / t.EntryValue / t.Qnty / countr[t.ExitTime.Value.Date];
});
}
else
{
trades.ForEach(t =>
{
t.GetNetResult(t.ExitValue);
t.NetResult = t.Capital * t.Result * t.Unit - t.Cost;
});
}
trades[0].CumResult = trades[0].NetResult;
for (var i = 1; i < trades.Count; i++)
{
trades[i].CumResult = trades[i - 1].CumResult + trades[i].NetResult;
}
var dailyr = trades.GroupBy(t => t.ExitTime.Value.Date).ToDictionary(x => x.Key, y => y.Sum(z => z.NetResult.Value));
#region Calculate DrawnDown
var max = 0.0m;
var mdd = 0.0m;
var esum = 0.0m;
foreach (var pair in dailyr)
{
esum += pair.Value;
max = Math.Max(max, esum);
mdd = Math.Max(mdd, (max - esum));
cumsum.Add(pair.Key, esum);
}
#endregion
var months = (decimal)(trades.Last().ExitTime.Value - trades.First().EntryTime).TotalDays / 30.4368499m;
this.action = 0;
this.setup.MaxDrawndown = mdd;
this.setup.TotalNetProfit = esum;
this.setup.DailyNetProfit = esum / months;
this.setup.TradesCount = trades.Count();
this.setup.TotalCosts = trades.Sum(t => t.Cost) / months;
this.setup.SharpeRatio = GetSharpeRation(dailyr.Values);
this.setup.SharpeRatio = this.setup.SharpeRatio * GetRSquared(cumsum);
this.setup.PositiveTrades = 100 * trades.Count(t => t.NetResult > 0) / trades.Count;
this.setup.Description =
trades.First().EntryTime.ToShortDateString() + " " +
trades.Last().ExitTime.Value.ToShortDateString() + "\t";
var nonnulltrades = trades.FindAll(t => t.NetResult.HasValue);
this.setup.WinLossRatio = this.setup.PositiveTrades == 0 || this.setup.PositiveTrades == 100 ? 0 : -
nonnulltrades.Where(t => t.NetResult.Value > 0).Average(t => t.NetResult.Value) /
nonnulltrades.Where(t => t.NetResult.Value < 0).Average(t => t.NetResult.Value);
var resultsDic = new Dictionary <string, string>();
var firstofthismonth = trade.ExitTime.Value.AddDays(1 - trade.ExitTime.Value.Day);
var lastofthismonth = firstofthismonth.AddMonths(1).AddDays(-1);
resultsDic.Add("Mês", Return(firstofthismonth, lastofthismonth));
var firstofthisyear = new DateTime(trade.ExitTime.Value.Year, 1, 1);
resultsDic.Add("Ano", Return(firstofthisyear, lastofthismonth));
var startlast06months = trade.ExitTime.Value.AddMonths(-6);
resultsDic.Add("6 meses", Return(startlast06months, lastofthismonth));
var startlast12months = trade.ExitTime.Value.AddMonths(-12);
resultsDic.Add("12 meses", Return(startlast12months, lastofthismonth));
var startlast24months = trade.ExitTime.Value.AddMonths(-24);
resultsDic.Add("24 meses", Return(startlast24months, lastofthismonth));
for (var i = 1; i <= 12; i++)
{
resultsDic.Add(firstofthismonth.AddMonths(-i).ToString(@"MMM/yy"),
Return(firstofthismonth.AddMonths(-i), lastofthismonth.AddMonths(-i)));
}
this.setup.Description += string.Join(";", resultsDic.Keys) + "\r\n;" + string.Join(";", resultsDic.Values);
if (opt)
{
if (esum > mdd)
{
OnStatusChanged(setup.ToString());
}
var _file = String.Format(DataDir.Replace(@"\Data\", @"\Backtest\") + "{0:ID_000}_{1:yyMMddHHmm}.csv", setup.SetupId, DateTime.Now);
if (File.Exists(_file))
{
File.Delete(_file);
}
File.AppendAllText(_file, this.setup.ToString() + "\r\n", System.Text.Encoding.UTF8);
foreach (var pair in countr)
{
File.AppendAllText(_file, "\r\n" +
pair.Key.ToShortDateString() + ";" + pair.Value + ";" + dailyr[pair.Key] + ";" + cumsum[pair.Key]);
}
_file = _file.Replace(".csv", "_trades.csv");
if (File.Exists(_file))
{
File.Delete(_file);
}
for (var i = 0; i < trades.Count; i++)
{
File.AppendAllText(_file, trades[i].ToString() + "\r\n");
}
}
this.trades.RemoveAll(t => t.EntryTime.Date != trade.EntryTime.Date);
return(this.setup);
}
private static void RealMain(Options options)
{
try {
using var file = File.OpenRead(options.InputFile);
using var reader = new BinaryReader(file);
var header = reader.ReadStruct <DosHeader>();
var ntheader_address = header.AddressOfNewExeHeader;
file.Seek(ntheader_address, SeekOrigin.Begin);
var ntheader = reader.ReadStruct <NtHeader>();
if (ntheader.Signature != 0x4550)
{
Console.WriteLine("Failed to parse nt header");
return;
}
if (ntheader.FileHeader.Machine != 0x8664)
{
Console.WriteLine("Failed to parse nt header: only accept AMD64 architect: {0:X}", ntheader.FileHeader.Machine);
return;
}
if (ntheader.OptionalHeader.Magic != 0x20B)
{
Console.WriteLine("Failed to parse nt optional header: only accept AMD64 architect: magic {0:X}", ntheader.OptionalHeader.Magic);
return;
}
var imagesize = ntheader.OptionalHeader.SizeOfImage;
Console.WriteLine("Image Size: {0:X}", imagesize);
var dirs = new DataDir[16];
for (var i = 0; i < 16; i++)
{
var dir = reader.ReadStruct <DataDir>();
Console.WriteLine("Data dir: {0:X8} {1:X8} ({2})", dir.VirtualAddress, dir.Size, DataDirName[i]);
dirs[i] = dir;
}
var resolver = new AddressResolver(ntheader.FileHeader.NumberOfSections);
for (uint i = 0; i < ntheader.FileHeader.NumberOfSections; i++)
{
var secheader = reader.ReadStruct <SectionHeader>();
Console.WriteLine("{0, 8}\n\t{1:X8}(Virtual Size)\n\t{2:X8}(Virtual Address)\n\t{3:X8}(Raw Data Size)\n\t{4:X8}(Raw Data Offset)\n\t{5:X8}(Diff)\n\tBITMAP: {6:X8}",
secheader.GetName(),
secheader.Misc.VirtualSize,
secheader.VirtualAddress,
secheader.SizeOfRawData,
secheader.PointerToRawData,
secheader.VirtualAddress - secheader.PointerToRawData,
secheader.Characteristics);
resolver.Put(secheader);
}
// Export table
if (dirs[0].VirtualAddress != 0)
{
file.SeekRVA(resolver, dirs[0].VirtualAddress);
var exp = reader.ReadStruct <ExportDir>();
file.SeekRVA(resolver, exp.Name);
Console.WriteLine("Dll Name: {0}", reader.ReadByteString());
file.SeekRVA(resolver, exp.AddressOfFunctions);
var addrs = new uint[exp.NumberOfFunctions];
for (uint i = 0; i < exp.NumberOfFunctions; i++)
{
addrs[i] = reader.ReadStruct <RVA>().Value;
}
file.SeekRVA(resolver, exp.AddressOfOrdinals);
var ords = new ushort[exp.NumberOfNames];
for (uint i = 0; i < exp.NumberOfNames; i++)
{
ords[i] = reader.ReadStruct <Ordinal>().Value;
}
var names = new string[exp.NumberOfNames];
for (uint i = 0; i < exp.NumberOfNames; i++)
{
file.SeekRVA(resolver, exp.AddressOfNames + i * sizeof(uint));
file.SeekRVA(resolver, reader.ReadStruct <RVA>().Value);
names[i] = reader.ReadByteString();
Console.WriteLine("export: {2:X8} <- {1:X4}:{0}", names[i], ords[i], addrs[ords[i]]);
}
}
// Import table
if (dirs[1].VirtualAddress != 0)
{
var pos = resolver.Resolve(dirs[1].VirtualAddress);
for (uint i = 0; ; i++)
{
file.Seek(pos, SeekOrigin.Begin);
var imp = reader.ReadStruct <ImportDir>();
pos = (uint)file.Position;
if (imp.Name == 0)
{
break;
}
file.SeekRVA(resolver, imp.Name);
Console.WriteLine("import from {0}", reader.ReadByteString());
var pos2 = resolver.Resolve(imp.FirstThunk);
for (uint j = 0; ; j++)
{
file.Seek(pos2, SeekOrigin.Begin);
var thunk = reader.ReadStruct <ImportDirThunk>();
pos2 = (uint)file.Position;
if (thunk.IsEmpty())
{
break;
}
if (thunk.TryGetOrdinal(out var ord))
{
Console.WriteLine("#{0}", ord);
}
else
{
file.SeekRVA(resolver, (uint)thunk.Value);
var hint = reader.ReadStruct <ImportDirThunkHint>().Hint;
Console.WriteLine("\t{0:X4}:{1}", hint, reader.ReadByteString());
}
}
}
}
} catch (Exception e) {
Console.WriteLine(e.ToString());
}
}
