PortfolioNodeEquivalenceMapperTest.java example

Explorer
OG-Platform-master
- projects
- sesame
/**
 * Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.core.position.impl;

import static org.testng.Assert.assertEquals;

import java.math.BigDecimal;
import java.util.Map;

import org.testng.annotations.Test;

import com.opengamma.core.position.PortfolioNode;
import com.opengamma.core.position.Position;
import com.opengamma.id.ExternalId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.UniqueIdSupplier;
import com.opengamma.util.test.TestGroup;

/**
 * Tests the {@link PortfolioNodeEquivalenceMapper} class.
 */
@Test(groups = TestGroup.UNIT)
public class PortfolioNodeEquivalenceMapperTest {

  private PortfolioNode createNodeA(final UniqueIdSupplier uidSupplier, final boolean swapBC, final boolean swapB, final int sizeB) {
    final SimplePortfolioNode node = new SimplePortfolioNode(uidSupplier.get(), "A");
    if (swapBC) {
      node.addChildNode(createNodeC(uidSupplier));
      node.addChildNode(createNodeB(uidSupplier, swapB, sizeB));
    } else {
      node.addChildNode(createNodeB(uidSupplier, swapB, sizeB));
      node.addChildNode(createNodeC(uidSupplier));
    }
    return node;
  }

  private PortfolioNode createNodeAUnbalanced(final UniqueIdSupplier uidSupplier, final boolean omitB, final boolean omitC) {
    final SimplePortfolioNode node = new SimplePortfolioNode(uidSupplier.get(), "A");
    if (!omitB) {
      node.addChildNode(createNodeB(uidSupplier, false, 2));
    }
    if (!omitC) {
      node.addChildNode(createNodeC(uidSupplier));
    }
    return node;
  }

  private PortfolioNode createNodeB(final UniqueIdSupplier uidSupplier, final boolean swap, final int size) {
    final SimplePortfolioNode node = new SimplePortfolioNode(uidSupplier.get(), "B");
    if (swap) {
      for (int i = size; i > 0; i--) {
        node.addPosition(createPosition(i));
      }
    } else {
      for (int i = 1; i <= size; i++) {
        node.addPosition(createPosition(i));
      }
    }
    return node;
  }

  private PortfolioNode createNodeC(final UniqueIdSupplier uidSupplier) {
    final SimplePortfolioNode node = new SimplePortfolioNode(uidSupplier.get(), "C");
    node.addChildNode(createNodeD(uidSupplier));
    node.addPosition(createPosition(3));
    return node;
  }

  private PortfolioNode createNodeD(final UniqueIdSupplier uidSupplier) {
    final SimplePortfolioNode node = new SimplePortfolioNode(uidSupplier.get(), "D");
    node.addPosition(createPosition(4));
    return node;
  }

  private Position createPosition(final int i) {
    return new SimplePosition(UniqueId.of("Test", Integer.toString(i)), BigDecimal.ONE, ExternalId.of("Test", Integer.toString(i)));
  }

  public void testIdentical() {
    final UniqueIdSupplier ids = new UniqueIdSupplier("Node");
    final PortfolioNodeEquivalenceMapper mapper = new PortfolioNodeEquivalenceMapper();
    final PortfolioNode a = createNodeA(ids, false, false, 2);
    final Map<UniqueId, UniqueId> map = mapper.getEquivalentNodes(a, a);
    assertEquals(map.size(), 4);
    assertEquals(map.get(UniqueId.of("Node", "1")), UniqueId.of("Node", "1"));
    assertEquals(map.get(UniqueId.of("Node", "2")), UniqueId.of("Node", "2"));
    assertEquals(map.get(UniqueId.of("Node", "3")), UniqueId.of("Node", "3"));
    assertEquals(map.get(UniqueId.of("Node", "4")), UniqueId.of("Node", "4"));
  }

  public void testEqualNodes() {
    final UniqueIdSupplier ids = new UniqueIdSupplier("Node");
    final PortfolioNodeEquivalenceMapper mapper = new PortfolioNodeEquivalenceMapper();
    final PortfolioNode a = createNodeA(ids, false, false, 2);
    final PortfolioNode b = createNodeA(ids, false, false, 2);
    final Map<UniqueId, UniqueId> map = mapper.getEquivalentNodes(a, b);
    assertEquals(map.size(), 4);
    assertEquals(map.get(UniqueId.of("Node", "1")), UniqueId.of("Node", "5"));
    assertEquals(map.get(UniqueId.of("Node", "2")), UniqueId.of("Node", "6"));
    assertEquals(map.get(UniqueId.of("Node", "3")), UniqueId.of("Node", "7"));
    assertEquals(map.get(UniqueId.of("Node", "4")), UniqueId.of("Node", "8"));
  }

  public void testEqualNodesSubset() {
    final UniqueIdSupplier ids = new UniqueIdSupplier("Node");
    final PortfolioNodeEquivalenceMapper mapper = new PortfolioNodeEquivalenceMapper();
    final PortfolioNode a = createNodeAUnbalanced(ids, false, false); // 1-4
    final PortfolioNode b = createNodeAUnbalanced(ids, false, true); // 5-6
    final PortfolioNode c = createNodeAUnbalanced(ids, true, false); // 7-9
    Map<UniqueId, UniqueId> map = mapper.getEquivalentNodes(a, b);
    assertEquals(map.size(), 1);
    assertEquals(map.get(UniqueId.of("Node", "2")), UniqueId.of("Node", "6"));
    map = mapper.getEquivalentNodes(b, a);
    assertEquals(map.size(), 1);
    assertEquals(map.get(UniqueId.of("Node", "6")), UniqueId.of("Node", "2"));
    map = mapper.getEquivalentNodes(a, c);
    assertEquals(map.size(), 2);
    assertEquals(map.get(UniqueId.of("Node", "3")), UniqueId.of("Node", "8"));
    assertEquals(map.get(UniqueId.of("Node", "4")), UniqueId.of("Node", "9"));
    map = mapper.getEquivalentNodes(c, a);
    assertEquals(map.size(), 2);
    assertEquals(map.get(UniqueId.of("Node", "8")), UniqueId.of("Node", "3"));
    assertEquals(map.get(UniqueId.of("Node", "9")), UniqueId.of("Node", "4"));
  }

  public void testEqualNodesReordered() {
    final UniqueIdSupplier ids = new UniqueIdSupplier("Node");
    final PortfolioNodeEquivalenceMapper mapper = new PortfolioNodeEquivalenceMapper();
    final PortfolioNode a = createNodeA(ids, false, false, 2);
    final PortfolioNode b = createNodeA(ids, true, false, 2);
    final Map<UniqueId, UniqueId> map = mapper.getEquivalentNodes(a, b);
    assertEquals(map.size(), 4);
    assertEquals(map.get(UniqueId.of("Node", "1")), UniqueId.of("Node", "5"));
    assertEquals(map.get(UniqueId.of("Node", "2")), UniqueId.of("Node", "8"));
    assertEquals(map.get(UniqueId.of("Node", "3")), UniqueId.of("Node", "6"));
    assertEquals(map.get(UniqueId.of("Node", "4")), UniqueId.of("Node", "7"));
  }

  public void testPositionsReordered() {
    final UniqueIdSupplier ids = new UniqueIdSupplier("Node");
    final PortfolioNodeEquivalenceMapper mapper = new PortfolioNodeEquivalenceMapper();
    final PortfolioNode a = createNodeA(ids, false, false, 2);
    final PortfolioNode b = createNodeA(ids, false, true, 2);
    final Map<UniqueId, UniqueId> map = mapper.getEquivalentNodes(a, b);
    assertEquals(map.size(), 2);
    assertEquals(map.get(UniqueId.of("Node", "3")), UniqueId.of("Node", "7"));
    assertEquals(map.get(UniqueId.of("Node", "4")), UniqueId.of("Node", "8"));
  }

  public void testPositionsChanged() {
    final UniqueIdSupplier ids = new UniqueIdSupplier("Node");
    final PortfolioNodeEquivalenceMapper mapper = new PortfolioNodeEquivalenceMapper();
    final SimplePortfolioNode x = new SimplePortfolioNode(UniqueId.of("Test", "X"), "X");
    x.addChildNode(createNodeA(ids, false, false, 2));
    final SimplePortfolioNode y = new SimplePortfolioNode(UniqueId.of("Test", "Y"), "Y");
    y.addChildNode(createNodeA(ids, false, false, 3));
    final Map<UniqueId, UniqueId> map = mapper.getEquivalentNodes(x, y);
    assertEquals(map.size(), 2);
    assertEquals(map.get(UniqueId.of("Node", "3")), UniqueId.of("Node", "7"));
    assertEquals(map.get(UniqueId.of("Node", "4")), UniqueId.of("Node", "8"));
  }

  public void testNoMatch() {
    final UniqueIdSupplier ids = new UniqueIdSupplier("Node");
    final PortfolioNodeEquivalenceMapper mapper = new PortfolioNodeEquivalenceMapper();
    PortfolioNode a = createNodeB(ids, false, 2);
    PortfolioNode b = createNodeC(ids);
    assertEquals(mapper.getEquivalentNodes(a, b).size(), 0);
    a = createNodeB(ids, false, 2);
    b = createNodeB(ids, false, 3);
    assertEquals(mapper.getEquivalentNodes(a, b).size(), 0);
  }

}