[InlineData("COTTON", 0, 500, 0.01, CurrencyType.USD, 71.40, 1, 500)] //High tick value and a high contract size
//Test to see all pipvalue calculations
public void PipValueCalcutionsCFD(string symbol, decimal tickvalue, decimal contractsize, decimal ticksize, CurrencyType basecurrency, decimal tick, decimal basevalue, decimal value)
{
//Arrange
SimAccount naccount = new SimAccount("testing", "test account", 1000, 100);
TickImpl ntick = new TickImpl(symbol);
ntick.Bid = tick;
ntick.Ask = tick;
ntick.BidSize = int.MaxValue;
ntick.AskSize = ntick.BidSize;
TickImpl ntickbase = new TickImpl("USD" + basecurrency.ToString());
ntickbase.Ask = basevalue;
ntickbase.Bid = basevalue;
ntickbase.BidSize = int.MaxValue;
ntickbase.AskSize = int.MaxValue;
CFDSecurity nsecurity = new CFDSecurity(symbol);
nsecurity.TickValue = tickvalue;
nsecurity.ContractSize = contractsize;
nsecurity.TickSize = ticksize;
nsecurity.Currency = basecurrency;
//add security
naccount.Securities.AddSecurity(nsecurity);
//Act
naccount.OnTick(ntickbase);
naccount.OnTick(ntick);
naccount.OnTick(ntick);
//Assert
naccount.Securities[symbol].PipValue.Should().BeApproximately(value, .00001M);
}
public void PositionAccountTest()
{
ForexSecurity ts = new ForexSecurity(s);
IAccount account = new SimAccount("ME");
account.Securities.AddSecurity(ts);
TradeImpl t = new TradeImpl("TST", 100, 100);
t.Account = account;
t.Security = ts;
TradeImpl t2 = new TradeImpl("TST", 200, 200);
Assert.True(t.IsValid);
Assert.True(t2.IsValid);
t2.AccountName = "HIM";
PositionImpl p = new PositionImpl(t);
p.Adjust(t);
bool failed = false;
try
{
p.Adjust(t2);
}
catch (Exception) { failed = true; }
Assert.True(failed);
}
public void InitAndAdjust()
{
string sym = "IBM";
ForexSecurity ts = new ForexSecurity(sym);
IAccount account = new SimAccount("TEST");
account.Securities.AddSecurity(ts);
// startup position tracker
PositionTracker pt = new PositionTracker(account);
PositionTracker pt2 = new PositionTracker(account);
// give pt our initial position
PositionImpl init = new PositionImpl(ts, 0, 0, 0, account);
pt.Adjust(init);
pt2.Adjust(init);
// fill a trade in both places
TradeImpl fill = new TradeImpl(ts.Name, 100, 100);
fill.Account = account;
fill.Security = ts;
pt.Adjust(fill);
pt2.Adjust(fill);
// make sure it's only 100 in both places
Assert.Equal(100, pt[sym].Size);
Assert.Equal(100, pt2[sym].Size);
}
public void Adjust()
{
string s = "IBM";
ForexSecurity ts = new ForexSecurity(s);
IAccount account = new SimAccount("TEST", "testing", 1000M, 100, "SIM");
account.Securities.AddSecurity(ts);
TradeImpl t1 = new TradeImpl(s, 100, 100);
t1.Account = account;
t1.Security = ts;
PositionTracker pt = new PositionTracker(account);
// make we have no position yet
Assert.True(pt[t1.Symbol].IsFlat);
// send some adjustments
decimal cpl = 0;
cpl += pt.Adjust(t1);
cpl += pt.Adjust(t1);
// verify that adjustments took hold
Assert.Equal(0, cpl);
Assert.Equal(200, pt[t1.Symbol].Size);
}
public void UsingTrades()
{
// long
string s = "IBM";
ForexSecurity ts = new ForexSecurity(s);
ts.LotSize = 1;
ts.PipValue = 1;
ts.PipSize = 1;
PortfolioManager portfolio = new TradingPortfolio();
IAccount account = new SimAccount("TEST");
portfolio.SetAccount(account);
portfolio.Securities.AddSecurity(ts);
TradeImpl t1 = new TradeImpl(s, 80, 100, dt);
t1.Account = account;
t1.Security = ts;
PositionImpl p = new PositionImpl(t1);
Assert.True(p.IsLong);
Assert.True(p.Size == 100);
TradeImpl t2 = new TradeImpl(s, 84, -100, dt);
t2.Account = account;
t2.Security = ts;
decimal pl = p.Adjust(t2);
Assert.True(p.IsFlat);
Assert.Equal((84 - 80) * 100, pl);
// short
TradeImpl t3 = new TradeImpl(s, 84, -100, dt);
t3.Account = account;
t3.Security = ts;
p = new PositionImpl(t3);
Assert.True(!p.IsLong);
Assert.True(p.Size == -100);
TradeImpl t4 = new TradeImpl(s, 80, 100, dt);
t4.Account = account;
t4.Security = ts;
pl = p.Adjust(new TradeImpl(t4));
Assert.True(pl == (84 - 80) * 100);
Assert.True(p.IsFlat);
}
public void NewPosition()
{
string s = "IBM";
ForexSecurity ts = new ForexSecurity(s);
IAccount account = new SimAccount("TEST");
account.Securities.AddSecurity(ts);
PositionImpl p = new PositionImpl(ts, 80, 500, 0, account);
PositionTracker pt = new PositionTracker(account);
Assert.True(pt[s].IsFlat);
pt.NewPosition(p);
Assert.Equal(500, pt[s].Size);
}
public void ClosedPL()
{
const string sym = "RYN";
ForexSecurity ts = new ForexSecurity(sym);
IAccount acc = new SimAccount("TST");
acc.Securities.AddSecurity(ts);
PositionTracker pt = new PositionTracker(acc);
Position p = new PositionImpl(ts, 44.39m, 800, 0, acc);
pt.Adjust(p);
Position p2 = new PositionImpl(ts, 44.39m, -800, 0, acc);
pt.Adjust(p2);
Assert.Equal(0, pt[sym].GrossPnL);
}
public void MultiAccount()
{
_broker.BrokerModel = _trans;
const string sym = "TST";
ForexSecurity tsec = new ForexSecurity(sym);
tsec.LotSize = 1;
tsec.OrderStepSize = 1;
const string me = "tester";
const string other = "anotherguy";
SimAccount a = new SimAccount(me);
SimAccount b = new SimAccount(other);
SimAccount c = new SimAccount("sleeper");
OrderImpl oa = new OrderImpl(tsec, Direction.Long, 100);
OrderImpl ob = new OrderImpl(tsec, Direction.Long, 100);
oa.AccountName = me;
ob.AccountName = other;
// send order to accounts
PendingOrderImpl poa = new PendingOrderImpl(oa, a);
PendingOrderImpl pob = new PendingOrderImpl(ob, b);
_broker.SendOrderStatus(poa);
_broker.SendOrderStatus(pob);
TickImpl t = new TickImpl(sym)
{
Trade = 100m,
Size = 200
};
Assert.Equal(2, _broker.Execute(t));
Position apos = _broker.GetOpenPosition(tsec, a);
Position bpos = _broker.GetOpenPosition(tsec, b);
Position cpos = _broker.GetOpenPosition(tsec, c);
Assert.True(apos.IsLong);
Assert.Equal(100, apos.Size);
Assert.True(bpos.IsLong);
Assert.Equal(100, bpos.Size);
Assert.True(cpos.IsFlat);
// make sure that default account doesn't register
// any trades
Assert.True(_broker.GetOpenPosition(tsec).IsFlat);
}
public void MaxDD()
{
const string sym = "TST";
SimAccount account = new SimAccount("TEST", "testing", 1000M, 100);
ForexSecurity sec = new ForexSecurity(sym);
sec.PipValue = 1;
sec.LotSize = 1;
sec.PipSize = 1;
account.Securities.AddSecurity(sec);
IPositionTracker pt = account.Positions;
System.Collections.Generic.List <Trade> fills = new System.Collections.Generic.List <Trade>();
TradeImpl t = new TradeImpl(sym, 10, 100);
t.Security = sec;
t.Account = account;
System.Collections.Generic.List <decimal> ret = new System.Collections.Generic.List <decimal>();
fills.Add(t);
pt.Adjust(t);
t = new TradeImpl(sym, 11, -100);
t.Security = sec;
t.Account = account;
fills.Add(t);
ret.Add(pt.Adjust(t));
t = new TradeImpl(sym, 11, -100);
t.Security = sec;
t.Account = account;
pt.Adjust(t);
fills.Add(t);
t = new TradeImpl(sym, 13, 100);
t.Account = account;
t.Security = sec;
fills.Add(t);
ret.Add(pt.Adjust(t));
decimal maxdd = Calc.MaxDdVal(ret.ToArray());
decimal maxddp = Calc.MaxDDPct(fills);
Assert.Equal(-300, maxdd);
Assert.Equal(-.18m, Math.Round(maxddp, 2));
}
public void BlankPositionReq()
{
string sym = "IBM";
ForexSecurity ts = new ForexSecurity(sym);
IAccount account = new SimAccount("TEST");
account.Securities.AddSecurity(ts);
PositionTracker pt = new PositionTracker(account);
bool except = false;
int s = 100;
try
{
s = pt[sym].Size;
}
catch { except = true; }
Assert.Equal(0, s);
Assert.False(except);
}
public void Basics()
{
SimAccount a = new SimAccount();
Assert.True(a.IsValid);
Assert.True(a.Id == "empty");
const string myid = "quantler";
a = new SimAccount(myid);
Assert.True(a.IsValid);
Assert.True(a.Id == myid);
a = new SimAccount("SIM1", "Menno's Account", initialbalance, leverage);
Assert.True(a.Balance == initialbalance);
Assert.True(a.Leverage == leverage);
Assert.True(a.Margin == 0);
Assert.True(a.FreeMargin == (a.Equity - a.Margin));
Assert.True(a.Equity == a.Balance);
Assert.True(a.Currency == CurrencyType.USD);
Assert.True(a.FloatingPnL == 0);
}
public void AdjustedDateTime()
{
// long
string s = "IBM";
ForexSecurity ts = new ForexSecurity(s);
ts.LotSize = 1;
ts.PipValue = 1;
ts.PipSize = 1;
IAccount account = new SimAccount("TEST");
account.Securities.AddSecurity(ts);
TradeImpl t1 = new TradeImpl(s, 80, 100, dt);
t1.Account = account;
t1.Security = ts;
PositionImpl p = new PositionImpl(t1);
p.LastModified.Should().BeAfter(DateTime.MinValue);
}
private static PortfolioManager Get(string symbol)
{
//Initialize
TradingPortfolio np = new TradingPortfolio();
//ADD INITIAL SECURITIES
ForexSecurity security = new ForexSecurity(symbol);
security.LotSize = 100000; //Lots
security.PipSize = 0.0001M; //PipSize in 4 decimal places
security.TickSize = 0.00001M; //Size of one tick
security.PipValue = 1M; //PipValue, if unable to calculate to base currency
security.Digits = 5;
var account = new SimAccount("SIMULATED", "Sim account for backtesting", 10000, 100, "SIM");
np.SetAccount(account);
np.Securities.AddSecurity(security);
//ADD AGENT AND INJECT TEMPLATES
np.InjectAgent <ExampleTradingAgent>();
//Set streams
TradingAgent agent = (TradingAgent)np.Agents[0];
agent.AgentId = 115230;
agent.TimeFrame = TimeSpan.FromSeconds(TimeFrameInSeconds);
OHLCBarStream ls = new OHLCBarStream(np.Securities[symbol], np.Agents[0].TimeFrame);
agent.SetDefaultStream(ls);
ls.Initialize();
agent.Initialize();
agent.Start();
SimpleBacktester.OnMessage += SimpleBacktester_OnMessage;
SimpleBacktester.OnProgress += SimpleBacktester_OnProgress;
return(np);
}
public void FlipSideInOneTrade()
{
// this is illegal on the exchanges, but supported by certain
// retail brokers so we're going to allow Quantler to support it
// BE CAREFUL WITH THIS FEATURE. make sure you won't be fined for doing this, before you do it.
string s = "IBM";
ForexSecurity ts = new ForexSecurity(s);
ts.LotSize = 1;
ts.PipValue = 1;
ts.PipSize = 1;
PortfolioManager portfolio = new TradingPortfolio();
IAccount account = new SimAccount("TEST");
portfolio.SetAccount(account);
portfolio.Securities.AddSecurity(ts);
// long position
var t = new TradeImpl(s, 100m, 200);
t.Account = account;
t.Security = ts;
decimal cpl = portfolio.Positions.Adjust(t);
Assert.Equal(cpl, 0);
// sell more than we've got to change sides
TradeImpl flip = new TradeImpl(s, 99, -400);
flip.Account = account;
flip.Security = ts;
cpl = portfolio.Positions.Adjust(flip);
// make sure we captured close of trade
Assert.Equal(-200, cpl);
// make sure we captured new side and price
Assert.Equal(-200, portfolio.Positions[s].Size);
Assert.Equal(99, portfolio.Positions[s].AvgPrice);
}
public void KeyRatios()
{
EquitySecurity ts = new EquitySecurity(sym);
ts.LotSize = 1;
ts.PipValue = 1;
ts.PipSize = 1;
IAccount account = new SimAccount("TEST");
account.Securities.AddSecurity(ts);
rt = new Results(.01m, account);
// get some trades
List <Trade> fills = new List <Trade>(new Trade[] {
// go long
new TradeImpl(sym, p, s)
{
Security = ts, Account = account, Commission = 1
}, // 100 @ $100
// increase bet
new TradeImpl(sym, p + inc, s * 2)
{
Security = ts, Account = account, Commission = 2
}, // 300 @ $100.066666
// take some profits
new TradeImpl(sym, p + inc * 2, s * -1)
{
Security = ts, Account = account, Commission = 1
}, // 200 @ 100.0666 (profit = 100 * (100.20 - 100.0666) = 13.34) / maxMIU(= 300*100.06666) = .04% ret
// go flat (round turn)
new TradeImpl(sym, p + inc * 2, s * -2)
{
Security = ts, Account = account, Commission = 2
}, // 0 @ 0
// go short
new TradeImpl(sym, p, s * -2)
{
Security = ts, Account = account, Commission = 2
}, // -200 @ 100
// decrease bet
new TradeImpl(sym, p, s)
{
Security = ts, Account = account, Commission = 1
}, // -100 @100
// exit (round turn)
new TradeImpl(sym, p + inc, s)
{
Security = ts, Account = account, Commission = 1
}, // 0 @ 0 (gross profit = -0.10*100 = -$10)
// do another entry
new TradeImpl(sym, p, s)
{
Security = ts, Account = account, Commission = 1
} // 100 @ 100
});
//fill all trades
foreach (var t in fills)
{
account.Positions.Adjust(t);
}
// check ratios
#if DEBUG
Console.WriteLine(rt.ToString());
#endif
Assert.Equal(0.0238M, Math.Round(rt.PortfolioPctReturns.Average() * 100, 4));
Assert.Equal(0.1028M, Math.Round(Calc.StdDev(rt.PortfolioPctReturns) * 100, 4));
Assert.Equal(-9.496M, rt.SharpeRatio);
Assert.Equal(-27.164M, rt.SortinoRatio);
Assert.Equal(2.060M, rt.ProfitFactor);
Assert.Equal(1100, rt.SharesTraded);
Assert.Equal(11, Math.Round(rt.Commissions));
Assert.Equal(19, Math.Round(rt.NetPL));
Assert.Equal(10000, rt.InitialCapital);
Assert.Equal(10019, Math.Round(rt.Balance));
Assert.Equal(0.0019M, Math.Round(rt.ROI, 4));
Assert.Equal(-0.0015M, Math.Round(rt.MaxDDPortfolio, 4));
}
public void RoundTurnStat()
{
ForexSecurity ts = new ForexSecurity(sym);
ts.LotSize = 1;
ts.PipSize = 1;
IAccount account = new SimAccount("TEST");
account.Securities.AddSecurity(ts);
rt = new Results(.01m, account);
// get some trades
List <Trade> fills = new List <Trade>(new Trade[] {
// go long
new TradeImpl(sym, p, s)
{
Security = ts, Account = account
},
// increase bet
new TradeImpl(sym, p + inc, s * 2)
{
Security = ts, Account = account
},
// take some profits
new TradeImpl(sym, p + inc * 2, s * -1)
{
Security = ts, Account = account
},
// go flat (round turn)
new TradeImpl(sym, p + inc * 2, s * -2)
{
Security = ts, Account = account
},
// go short
new TradeImpl(sym, p, s * -2)
{
Security = ts, Account = account
},
// decrease bet
new TradeImpl(sym, p, s)
{
Security = ts, Account = account
},
// exit (round turn)
new TradeImpl(sym, p + inc, s)
{
Security = ts, Account = account
},
// do another entry
new TradeImpl(sym, p, s)
{
Security = ts, Account = account
}
});
//fill all trades
foreach (var t in fills)
{
account.Positions.Adjust(t);
}
// check trade count
Assert.Equal(fills.Count, rt.Trades);
// check round turn count
Assert.Equal(2, rt.RoundTurns);
// verify trade winners
Assert.Equal(2, rt.Winners);
// verify round turn winners
Assert.Equal(1, rt.RoundWinners);
// verify round turn losers
Assert.Equal(1, rt.RoundLosers);
}
public void MultipleAccount()
{
// setup defaults for 1st and 2nd accounts and positions
string s = "TST";
ForexSecurity sym = new ForexSecurity(s);
IAccount a1 = new SimAccount("account1");
a1.Securities.AddSecurity(sym);
IAccount a2 = new SimAccount("account2");
a1.Securities.AddSecurity(sym);
int s1 = 300;
int s2 = 500;
decimal p = 100m;
// create position tracker
PositionTracker pt = new PositionTracker(a1);
// set initial position in 1st account
pt.Adjust(new PositionImpl(sym, p, s1, 0, a1));
// set initial position in 2nd account
pt.Adjust(new PositionImpl(sym, p, s2, 0, a2));
// verify I can query default account and it's correct
Assert.Equal(s1, pt[sym].Size);
// change default to 2nd account
pt.DefaultAccount = a2;
// verify I can query default and it's correct
Assert.Equal(s2, pt[sym].Size);
// verify I can query 1st account and correct
Assert.Equal(s1, pt[sym, a1].Size);
// verify I can query 2nd account and correct
Assert.Equal(s2, pt[sym, a2].Size);
// get fill in sym for 1st account
TradeImpl f = new TradeImpl(sym.Name, p, s1);
f.Account = a1;
f.Security = sym;
pt.Adjust(f);
// get fill in sym for 2nd account
TradeImpl f2 = new TradeImpl(sym.Name, p, s2);
f2.Account = a2;
f2.Security = sym;
pt.Adjust(f2);
// verify that I can querry 1st account and correct
Assert.Equal(s1 * 2, pt[sym, a1].Size);
// verify I can query 2nd account and correct
Assert.Equal(s2 * 2, pt[sym, a2].Size);
// reset
pt.Clear();
// ensure I can query first and second account and get flat symbols
Assert.Equal(0, pt[sym].Size);
Assert.Equal(0, pt[sym, a1].Size);
Assert.Equal(0, pt[sym, a2].Size);
Assert.True(pt[sym, a1].IsFlat);
Assert.True(pt[sym, a2].IsFlat);
Assert.True(pt[sym].IsFlat);
Assert.Equal(null, pt.DefaultAccount);
}
public void AccountBalanceUpdateForex()
{
//Arrange
SimAccount testaccount = new SimAccount("SIM1", "Menno's Account", initialbalance, leverage);
ForexSecurity ts = new ForexSecurity(sym);
ts.LotSize = 1000;
ts.ContractSize = ts.LotSize;
ts.PipSize = 0.0001M;
ts.TickSize = ts.PipSize / 10;
testaccount.Securities.AddSecurity(ts);
TickImpl tick = TickImpl.NewQuote(sym, p, p, int.MaxValue, int.MaxValue, ts.DestEx, ts.DestEx);
TickImpl secondtick = TickImpl.NewQuote(sym, p + inc, p + inc, int.MaxValue, int.MaxValue, ts.DestEx, ts.DestEx);
List <Trade> fills = new List <Trade>(new Trade[] {
// go long
new TradeImpl(sym, p, s)
{
Security = ts, Account = testaccount, Commission = 1
}, // 1000 @ $1
// increase bet
new TradeImpl(sym, p + inc, s * 2)
{
Security = ts, Account = testaccount, Commission = 2
}, // 2000 @ $1.1
// take some profits
new TradeImpl(sym, p + inc * 2, s * -1)
{
Security = ts, Account = testaccount, Commission = 1
}, // -1000 @ $1.2 (profit = 1000 * (1.2 - 1.0) = 200)
// go flat (round turn)
new TradeImpl(sym, p + inc * 2, s * -2)
{
Security = ts, Account = testaccount, Commission = 2
}, // -2000 @ $1.2 (profit = 2000 * (1.2 - 1.1) = 200)
// go short
new TradeImpl(sym, p, s * -2)
{
Security = ts, Account = testaccount, Commission = 2
}, // -2000 @ $1
// decrease bet
new TradeImpl(sym, p, s)
{
Security = ts, Account = testaccount, Commission = 1
}, // 1000 @ $1
// exit (round turn)
new TradeImpl(sym, p + inc, s)
{
Security = ts, Account = testaccount, Commission = 1
}, // 1000 @ $1 (loss = 1000 * (1.2 - 1.0) = 100)
// do another entry
new TradeImpl(sym, p, s)
{
Security = ts, Account = testaccount, Commission = 1
} // 100 @ 100
});
//Act, fill all trades
testaccount.OnTick(tick);
testaccount.OnTick(secondtick);
foreach (var t in fills)
{
testaccount.OnFill(t);
}
//Assert
Assert.True(testaccount.Balance == 10300);
Assert.True(testaccount.Margin == 11);
Assert.True(testaccount.MarginLevel == (testaccount.Equity / testaccount.Margin) * 100);
}
public void AccountBalanceUpdateCFD()
{
//Arrange
SimAccount testaccount = new SimAccount("SIM1", "Menno's Account", initialbalance, leverage);
CFDSecurity ts = new CFDSecurity(sym);
ts.LotSize = 100;
ts.ContractSize = 50;
ts.PipSize = 0.1M;
ts.TickSize = ts.PipSize;
ts.TickValue = 5;
ts.Currency = CurrencyType.USD;
int size = 100;
testaccount.Securities.AddSecurity(ts);
TickImpl tick = TickImpl.NewQuote(sym, p, p, int.MaxValue, int.MaxValue, ts.DestEx, ts.DestEx);
TickImpl secondtick = TickImpl.NewQuote(sym, p + inc, p + inc, int.MaxValue, int.MaxValue, ts.DestEx, ts.DestEx);
List <Trade> fills = new List <Trade>(new Trade[] {
// go long
new TradeImpl(sym, p, size)
{
Security = ts, Account = testaccount, Commission = 1
}, // 1 @ $1
// increase bet
new TradeImpl(sym, p + inc, size * 2)
{
Security = ts, Account = testaccount, Commission = 2
}, // 2 @ $1.1
// take some profits
new TradeImpl(sym, p + inc * 2, size * -1)
{
Security = ts, Account = testaccount, Commission = 1
}, // -1 @ $1.2 (profit = 1 * (1.2 - 1.0) * 50 = 100)
// go flat (round turn)
new TradeImpl(sym, p + inc * 2, size * -2)
{
Security = ts, Account = testaccount, Commission = 2
}, // -2 @ $1.2 (profit = 2 * (1.2 - 1.1) * 50 = 200)
// go short
new TradeImpl(sym, p, size * -2)
{
Security = ts, Account = testaccount, Commission = 2
}, // -2 @ $1
// decrease bet
new TradeImpl(sym, p, size)
{
Security = ts, Account = testaccount, Commission = 1
}, // 1 @ $1
// exit (round turn)
new TradeImpl(sym, p + inc, size)
{
Security = ts, Account = testaccount, Commission = 1
}, // 1 @ $1 (loss = 1000 * (1.2 - 1.0) * 50 = 100)
// do another entry
new TradeImpl(sym, p, size)
{
Security = ts, Account = testaccount, Commission = 1
} // 1 @ $1
});
//Act, fill all trades
testaccount.OnTick(tick);
testaccount.OnTick(secondtick);
foreach (var t in fills)
{
testaccount.OnFill(t);
}
//Assert
Assert.True(testaccount.Balance == 10015);
Assert.True(testaccount.Margin == 0);
Assert.True(testaccount.MarginLevel == 1001500);
}
public void LowMarginLevel()
{
//Arrange
SimAccount testaccount = new SimAccount("SIM1", "Menno's Account", initialbalance, leverage);
ForexSecurity ts = new ForexSecurity(sym);
ts.LotSize = 1000;
ts.PipSize = 0.0001M;
ts.TickSize = ts.PipSize / 10;
testaccount.Securities.AddSecurity(ts);
TickImpl tick = TickImpl.NewQuote(sym, p, p, int.MaxValue, int.MaxValue, ts.DestEx, ts.DestEx);
TickImpl secondtick = TickImpl.NewQuote(sym, p + inc, p + inc, int.MaxValue, int.MaxValue, ts.DestEx, ts.DestEx);
List <Trade> fills = new List <Trade>(new Trade[] {
// go long
new TradeImpl(sym, p, s)
{
Security = ts, Account = testaccount, Commission = 1
}, // 100 @ $100
// increase bet
new TradeImpl(sym, p + inc, s * 2)
{
Security = ts, Account = testaccount, Commission = 2
}, // 300 @ $100.066666
// take some profits
new TradeImpl(sym, p + inc * 2, s * -1)
{
Security = ts, Account = testaccount, Commission = 1
}, // 200 @ 100.0666 (profit = 100 * (100.20 - 100.0666) = 13.34) / maxMIU(= 300*100.06666) = .04% ret
// go flat (round turn)
new TradeImpl(sym, p + inc * 2, s * -2)
{
Security = ts, Account = testaccount, Commission = 2
}, // 0 @ 0
// go short
new TradeImpl(sym, p, s * -2)
{
Security = ts, Account = testaccount, Commission = 2
}, // -200 @ 100
// decrease bet
new TradeImpl(sym, p, s)
{
Security = ts, Account = testaccount, Commission = 1
}, // -100 @100
// exit (round turn)
new TradeImpl(sym, p + inc, s * 5000)
{
Security = ts, Account = testaccount, Commission = 1
}, // 0 @ 0 (gross profit = -0.10*100 = -$10)
// do another entry
new TradeImpl(sym, p, s)
{
Security = ts, Account = testaccount, Commission = 1
} // 100 @ 100
});
//Act, fill all trades
testaccount.OnTick(tick);
testaccount.OnTick(secondtick);
foreach (var t in fills)
{
testaccount.OnFill(t);
}
//Assert
Assert.True(testaccount.Balance == 10300);
Assert.True(testaccount.Margin == 55000);
//Lower than 20% (Margin Call)
Assert.True(testaccount.MarginLevel < 20M);
}
