public void Open__AddsToActive_SubsCash(PositionDir dir, float price, float vol, StockDataRange range, int intradayInterval)
{
_testObj.Open(_stock, dir, CurrentTS, price, vol, Commission, range, intradayInterval, EntrySignal);
_testObj.Cash.ShouldBe(CashValue - _testObj.PositionsActive[0].DirectionMultiplier() * (price * vol) - Commission);
_testObj.PositionsActive.Count.ShouldBe(1);
CheckOpenedPosition(_testObj.PositionsActive[0], _stock, dir, price, vol, Commission, CurrentTS, range, intradayInterval);
}
private Position CreatePosition(PositionDir dir, float open, float vol) => new Position()
{
Stock = _stock,
Direction = dir,
Open = open,
Volume = vol
};
private void CheckClosedPosition(int index, PositionDir dir, float open, float close, float vol, float commission, DateTime ts, float prevValueOnPosition)
{
_testObj.PositionsClosed[index].Close.ShouldBe(close);
_testObj.PositionsClosed[index].CloseCommission.ShouldBe(commission);
_testObj.PositionsClosed[index].TSClose.ShouldBe(ts);
_testObj.ClosedPositionsEquity[index].Value.ShouldBe(prevValueOnPosition + (close - open) * vol * (dir == PositionDir.Long ? 1 : -1) - commission);
_testObj.ClosedPositionsEquity[index].TS.ShouldBe(ts);
}
public void OnPrice(PositionDir positionDir, float price, bool expected)
{
SignalSelector.OnPrice(
new Signal()
{
Type = SignalType.EnterOnPrice, Direction = positionDir, Price = price
},
StockPricesDataUtils.CreatePricesData(0, 100, 50, 0),
0).ShouldBe(expected);
}
public void OnStopHit(PositionDir positionDir, float price, float expected)
{
ClosePriceSelector.OnStopHit(
new Position()
{
Direction = positionDir, CloseModePrice = price
},
StockPricesDataUtils.CreatePricesData(10, 100, 5, 20),
0).ShouldBe(expected);
}
public void OnPrice(PositionDir positionDir, float price, float expected)
{
OpenPriceSelector.OnPrice(
new Signal()
{
Direction = positionDir, Price = price
},
StockPricesDataUtils.CreatePricesData(10, 100, 5, 20),
0).ShouldBe(expected);
}
public void Calc_WithActivePosition__ReturnsCashAndPositionValue(PositionDir dir)
{
_testSys.PositionsActive.Add(new Position()
{
Stock = new StockDefinition(),
Direction = dir,
Volume = Vol
});
_testObj.Calc(_testSys, CurrentTS, _dataLoader).ShouldBe(CashValue + dir.DirectionMultiplier() * PriceL * Vol);
}
public void OnStopHit(PositionDir positionDir, float closeModePrice, bool expected)
{
ClosingPositionSelector.OnStopHit(
new Position()
{
Direction = positionDir, CloseMode = PositionCloseMode.OnStopHit, CloseModePrice = closeModePrice
},
StockPricesDataUtils.CreatePricesData(0, 100, 50, 0),
0).ShouldBe(expected);
}
private Signal CreateSignal(PositionDir dir, SystemState systemState, float currentClosePrice) =>
new Signal()
{
Stock = _stock,
DataRange = _dataRange,
IntradayInterval = 0,
Type = SignalType.EnterOnOpen,
Direction = dir,
ReversePosition = false,
Volume = _signalVolumeCalculator.Calculate(systemState, _stock.Type, currentClosePrice)
};
public void Close__MovesToClosed_AddsCash_AddsValueOnPosition(PositionDir dir, float open, float close, float vol)
{
Position pos = CreatePosition(dir, open, vol);
_testObj.PositionsActive.Add(pos);
_testObj.Close(0, CurrentTS, close, Commission);
_testObj.Cash.ShouldBe(CashValue + pos.DirectionMultiplier() * (close * vol) - Commission);
_testObj.PositionsActive.Count.ShouldBe(0);
_testObj.PositionsClosed.Count.ShouldBe(1);
_testObj.ClosedPositionsEquity.Count.ShouldBe(1);
CheckClosedPosition(0, dir, open, close, vol, Commission, CurrentTS, 0);
}
public void AddToPosition_NewVolNegative__ClosesCurrent(PositionDir dir, float open, float vol, float addPrice, float addVol)
{
Position pos = CreatePosition(dir, open, vol);
_testObj.PositionsActive.Add(pos);
_testObj.AddToPosition(0, CurrentTS, addPrice, addVol, EntrySignal, _slippage, _commission);
_testObj.Cash.ShouldBe(CashValue + pos.DirectionMultiplier() * (addPrice * vol) - Commission);
_testObj.PositionsClosed.Count.ShouldBe(1);
_testObj.ClosedPositionsEquity.Count.ShouldBe(1);
CheckClosedPosition(0, dir, open, addPrice, vol, Commission, CurrentTS, 0);
_testObj.PositionsActive.Count.ShouldBe(0);
}
private void CheckOpenedPosition(Position pos, StockDefinition stock, PositionDir dir, float open, float vol, float commission, DateTime ts, StockDataRange range, int interval)
{
pos.Stock.ShouldBe(stock);
pos.Direction.ShouldBe(dir);
pos.TSOpen.ShouldBe(ts);
pos.Open.ShouldBe(open);
pos.OpenCommission.ShouldBe(commission);
pos.Volume.ShouldBe(vol);
pos.DataRange.ShouldBe(range);
pos.IntradayInterval.ShouldBe(interval);
pos.EntrySignal.ShouldBe(EntrySignal);
}
private void ReversePosition(Signal signal, DateTime ts, SystemState systemState, float openPrice)
{
PositionDir newPosDir = signal.Direction;
int currPos = FindActivePositionIndex(systemState, signal.Stock);
if (currPos > -1)
{
newPosDir = systemState.PositionsActive[currPos].ReversedDirection();
systemState.Close(currPos, ts, openPrice, _slippage, _commission);
}
systemState.Open(ts, newPosDir, openPrice, signal, _slippage, _commission);
}
public void ReducePosition__ClosesCurrent_CreatesNewWithReducedVolume(PositionDir dir, float open, float vol, float reducePrice, float reduceVol)
{
Position pos = CreatePosition(dir, open, vol);
_testObj.PositionsActive.Add(pos);
_testObj.ReducePosition(0, CurrentTS, reducePrice, reduceVol, EntrySignal, _slippage, _commission);
_testObj.Cash.ShouldBe(CashValue + pos.DirectionMultiplier() * (reducePrice * reduceVol) - 2 * Commission);
_testObj.PositionsClosed.Count.ShouldBe(1);
_testObj.ClosedPositionsEquity.Count.ShouldBe(1);
CheckClosedPosition(0, dir, open, reducePrice, vol, Commission, CurrentTS, 0);
_testObj.PositionsActive.Count.ShouldBe(1);
CheckOpenedPosition(_testObj.PositionsActive[0], _stock, dir, reducePrice, vol - reduceVol, Commission, CurrentTS, StockDataRange.Daily, 0);
}
public void Calc_WithTwoActivePositions__ReturnsCashAndPositionsValue(PositionDir dir)
{
const int posCount = 2;
for (int i = 0; i < posCount; i++)
{
_testSys.PositionsActive.Add(new Position()
{
Stock = new StockDefinition(),
Direction = dir,
Volume = Vol
});
}
_testObj.Calc(_testSys, CurrentTS, _dataLoader).ShouldBe(CashValue + dir.DirectionMultiplier() * PriceL * Vol * posCount);
}
public static void Open(this SystemState systemState, StockDefinition stock, PositionDir dir, DateTime ts, float price, float volume, float commission, StockDataRange dataRange, int intradayInterval, Signal entrySignal)
{
Position pos = new Position
{
Stock = stock,
DataRange = dataRange,
IntradayInterval = intradayInterval,
Direction = dir,
Open = price,
OpenCommission = commission,
TSOpen = ts,
Volume = volume,
EntrySignal = entrySignal,
TicksActive = 1
};
systemState.PositionsActive.Add(pos);
systemState.Cash -= pos.DirectionMultiplier() * pos.OpenValue();
systemState.Cash -= pos.OpenCommission;
}
private static void AddAnnotation(PriceVolumeChart chart, int imageIndex, PositionDir dir, DateTime ts)
{
DataPoint dataPoint = chart.PricesCandles.Points.FindByValue(ts.ToOADate(), "X");
if (dataPoint == null)
{
return;
}
ImageAnnotation annotation = new ImageAnnotation()
{
AnchorDataPoint = dataPoint,
AnchorY = dataPoint.YValues[PositionOpenCloseImages.AnnotationAnchorYValueIndex[dir][imageIndex]],
AnchorAlignment = PositionOpenCloseImages.AnnotationContentAlignment[dir][imageIndex],
Image = PositionOpenCloseImages.ImageName[dir][imageIndex],
AnchorOffsetY = 2
};
chart.PVChartControl.Annotations.Add(annotation);
}
public static float DirectionMultiplier(this PositionDir postionDir)
{
return(postionDir == PositionDir.Long ? 1 : -1);
}
public void CalculateOpen__ValueNotChanged(PositionDir dir, float value)
{
_testObj.CalculateOpen(StockType.Stock, DateTime.Now, dir, value).ShouldBe(value);
}
public float CalculateOpen(StockType stockType, DateTime ts, PositionDir dir, float value)
{
return(value);
}
public void ReverseDirection(PositionDir dir, PositionDir expected)
{
dir.ReverseDirection().ShouldBe(expected);
}
public void DirectionMultiplier(PositionDir dir, float expected)
{
dir.DirectionMultiplier().ShouldBe(expected);
}
public float CalculateOpen(StockType stockType, DateTime ts, PositionDir dir, float value)
{
return(_tickAdder.AddTicks(stockType, ts, value, (dir == PositionDir.Long ? 1 : -1) * _ticks));
}
public void DirectionMultiplier(PositionDir dir, float expected)
{
_testObj.Direction = dir;
_testObj.DirectionMultiplier().ShouldBe(expected);
}
public void ReversedDirection(PositionDir dir, PositionDir expected)
{
_testObj.Direction = dir;
_testObj.ReversedDirection().ShouldBe(expected);
}
public void CalculateOpen__ValueChanged(PositionDir dir, float value, int ticks, float expected)
{
SlippageTicks testObj = new SlippageTicks(_tickAdder, ticks);
testObj.CalculateOpen(StockType.Stock, _dt, dir, value).ShouldBe(expected);
}
public static float CalculateSlippageClose(this SystemState systemState, ISlippage slippage, StockType stockType, DateTime ts, PositionDir dir, float price)
{
return(slippage.CalculateClose(stockType, ts, dir, price));
}
public static void Open(this SystemState systemState, DateTime ts, PositionDir dir, float price, Signal signal, ISlippage slippage, ICommission commission)
{
systemState.Open(ts, dir, price, signal.Volume, signal, slippage, commission);
}
public static void Open(this SystemState systemState, DateTime ts, PositionDir dir, float price, float volume, StockDefinition stock, Signal signal, ISlippage slippage, ICommission commission)
{
float openPrice = systemState.CalculateSlippageOpen(slippage, stock.Type, ts, signal.Direction, price);
systemState.Open(stock, dir, ts, openPrice, volume, systemState.CalculateCommission(commission, stock.Type, signal.Volume, openPrice), signal.DataRange, signal.IntradayInterval, signal);
}
public static PositionDir ReverseDirection(this PositionDir postionDir)
{
return(postionDir == PositionDir.Long ? PositionDir.Short : PositionDir.Long);
}
