static SecurityPosition sut2() {
return SecurityPosition.builder()
.info(PositionInfo.empty())
.securityId(SECURITY_ID2)
.longQuantity(LONG_QUANTITY2)
.shortQuantity(SHORT_QUANTITY2)
.build();
}
// -------------------------------------------------------------------------
static SecurityPosition sut() {
return SecurityPosition.builder()
.info(POSITION_INFO)
.securityId(SECURITY_ID)
.longQuantity(LONG_QUANTITY)
.shortQuantity(SHORT_QUANTITY)
.build();
}
public void test_ofNet_withInfo_negative() {
SecurityPosition test = SecurityPosition.ofNet(POSITION_INFO, SECURITY_ID, -100d);
assertEquals(test.getInfo(), POSITION_INFO);
assertEquals(test.getSecurityId(), SECURITY_ID);
assertEquals(test.getLongQuantity(), 0d);
assertEquals(test.getShortQuantity(), 100d);
assertEquals(test.getQuantity(), -100d);
}
// -------------------------------------------------------------------------
public void test_ofNet_noInfo() {
SecurityPosition test = SecurityPosition.ofNet(SECURITY_ID, QUANTITY);
assertEquals(test.getInfo(), PositionInfo.empty());
assertEquals(test.getSecurityId(), SECURITY_ID);
assertEquals(test.getLongQuantity(), QUANTITY);
assertEquals(test.getShortQuantity(), 0d);
assertEquals(test.getQuantity(), QUANTITY);
}
public void test_ofLongShort_withInfo() {
SecurityPosition test =
SecurityPosition.ofLongShort(POSITION_INFO, SECURITY_ID, LONG_QUANTITY, SHORT_QUANTITY);
assertEquals(test.getInfo(), POSITION_INFO);
assertEquals(test.getSecurityId(), SECURITY_ID);
assertEquals(test.getLongQuantity(), LONG_QUANTITY);
assertEquals(test.getShortQuantity(), SHORT_QUANTITY);
assertEquals(test.getQuantity(), QUANTITY);
}
public void test_builder() {
SecurityPosition test = sut();
assertEquals(test.getInfo(), POSITION_INFO);
assertEquals(test.getSecurityId(), SECURITY_ID);
assertEquals(test.getLongQuantity(), LONG_QUANTITY);
assertEquals(test.getShortQuantity(), SHORT_QUANTITY);
assertEquals(test.getQuantity(), QUANTITY);
}
public static PortfolioSnapshot merge(List<PortfolioSnapshot> snapshots) {
if (snapshots.isEmpty())
throw new RuntimeException(
"Error: PortfolioSnapshots to be merged must not be empty"); //$NON-NLS-1$
Portfolio portfolio = new Portfolio();
portfolio.setName(Messages.LabelJointPortfolio);
Map<Security, SecurityPosition> securities = new HashMap<Security, SecurityPosition>();
for (PortfolioSnapshot s : snapshots) {
portfolio.addAllTransaction(s.getSource().getTransactions());
for (SecurityPosition p : s.getPositions()) {
SecurityPosition pos = securities.get(p.getSecurity());
if (pos == null) securities.put(p.getSecurity(), p);
else securities.put(p.getSecurity(), SecurityPosition.merge(pos, p));
}
}
return new PortfolioSnapshot(
portfolio,
snapshots.get(0).getTime(),
new ArrayList<SecurityPosition>(securities.values()));
}
public static PortfolioSnapshot create(Portfolio portfolio, Date time) {
Map<Security, SecurityPosition> positions = new HashMap<Security, SecurityPosition>();
for (PortfolioTransaction t : portfolio.getTransactions()) {
if (t.getDate().getTime() <= time.getTime()) {
switch (t.getType()) {
case TRANSFER_IN:
case BUY:
case DELIVERY_INBOUND:
{
SecurityPosition p = positions.get(t.getSecurity());
if (p == null)
positions.put(t.getSecurity(), p = new SecurityPosition(t.getSecurity()));
p.addTransaction(t);
break;
}
case TRANSFER_OUT:
case SELL:
case DELIVERY_OUTBOUND:
{
SecurityPosition p = positions.get(t.getSecurity());
if (p == null)
positions.put(t.getSecurity(), p = new SecurityPosition(t.getSecurity()));
p.addTransaction(t);
break;
}
default:
throw new UnsupportedOperationException(
"Unsupported operation: " + t.getType()); // $NON-NLS-1$
}
}
}
ArrayList<SecurityPosition> collection = new ArrayList<SecurityPosition>(positions.values());
for (Iterator<SecurityPosition> iter = collection.iterator(); iter.hasNext(); ) {
SecurityPosition p = iter.next();
if (p.getShares() == 0) {
iter.remove();
} else {
SecurityPrice price = p.getSecurity().getSecurityPrice(time);
p.setPrice(price);
}
}
return new PortfolioSnapshot(portfolio, time, collection);
}
public Map<InvestmentVehicle, AssetPosition> getPositionsByVehicle() {
Map<InvestmentVehicle, AssetPosition> answer = new HashMap<InvestmentVehicle, AssetPosition>();
long assets = getAssets();
for (SecurityPosition p : jointPortfolio.getPositions())
answer.put(p.getSecurity(), new AssetPosition(p.getSecurity(), p, assets));
for (AccountSnapshot a : accounts) {
SecurityPosition sp = new SecurityPosition(null);
sp.setShares(Values.Share.factor());
sp.setPrice(new SecurityPrice(getTime(), a.getFunds()));
answer.put(a.getAccount(), new AssetPosition(a.getAccount(), sp, assets));
}
return answer;
}
public long getValue() {
long value = 0;
for (SecurityPosition p : positions) value += p.calculateValue();
return value;
}
public Map<Security, SecurityPosition> getPositionsBySecurity() {
Map<Security, SecurityPosition> map = new HashMap<Security, SecurityPosition>();
for (SecurityPosition p : positions) map.put(p.getSecurity(), p);
return map;
}
