ComputationTargetTypeMapTest.java example

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

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;

import java.util.Iterator;
import java.util.Map;

import org.testng.annotations.Test;

import com.opengamma.util.function.BinaryOperator;
import com.opengamma.util.test.TestGroup;

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

  public void testEmpty() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    assertNull(map.getDirect(ComputationTargetType.NULL));
    assertNull(map.get(ComputationTargetType.NULL));
    assertNull(map.getDirect(ComputationTargetType.POSITION));
    assertNull(map.get(ComputationTargetType.POSITION));
    assertNull(map.getDirect(ComputationTargetType.SECURITY));
    assertNull(map.get(ComputationTargetType.SECURITY));
  }

  public void testSimple() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.POSITION, "Pos");
    map.put(ComputationTargetType.SECURITY, "Sec");
    assertNull(map.getDirect(ComputationTargetType.NULL));
    assertNull(map.get(ComputationTargetType.NULL));
    assertEquals(map.getDirect(ComputationTargetType.POSITION), "Pos");
    assertEquals(map.get(ComputationTargetType.POSITION), "Pos");
    assertEquals(map.getDirect(ComputationTargetType.SECURITY), "Sec");
    assertEquals(map.get(ComputationTargetType.SECURITY), "Sec");
    assertEquals(map.getDirect(ComputationTargetType.POSITION.containing(ComputationTargetType.SECURITY)), "Sec");
    assertEquals(map.get(ComputationTargetType.POSITION.containing(ComputationTargetType.SECURITY)), "Sec");
    assertEquals(map.getDirect(ComputationTargetType.TRADE.or(ComputationTargetType.POSITION)), "Pos");
    assertEquals(map.get(ComputationTargetType.TRADE.or(ComputationTargetType.POSITION)), "Pos");
    assertNull(map.getDirect(ComputationTargetType.of(MockSecurity.class)));
    assertEquals(map.get(ComputationTargetType.of(MockSecurity.class)), "Sec");
    assertEquals(map.getDirect(ComputationTargetType.of(MockSecurity.class)), "Sec");
  }

  public void testNull() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.NULL, "NULL");
    map.put(ComputationTargetType.SECURITY, "Sec");
    assertEquals(map.getDirect(ComputationTargetType.NULL), "NULL");
    assertEquals(map.get(ComputationTargetType.NULL), "NULL");
  }

  public void testNested() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.POSITION.containing(ComputationTargetType.SECURITY), "Sec");
    assertNull(map.getDirect(ComputationTargetType.NULL));
    assertNull(map.get(ComputationTargetType.NULL));
    assertNull(map.getDirect(ComputationTargetType.POSITION));
    assertNull(map.get(ComputationTargetType.POSITION));
    assertEquals(map.getDirect(ComputationTargetType.SECURITY), "Sec");
    assertEquals(map.get(ComputationTargetType.SECURITY), "Sec");
    assertEquals(map.getDirect(ComputationTargetType.POSITION.containing(ComputationTargetType.SECURITY)), "Sec");
    assertEquals(map.get(ComputationTargetType.POSITION.containing(ComputationTargetType.SECURITY)), "Sec");
    assertNull(map.getDirect(ComputationTargetType.TRADE.or(ComputationTargetType.POSITION)));
    assertNull(map.get(ComputationTargetType.TRADE.or(ComputationTargetType.POSITION)));
    assertEquals(map.getDirect(ComputationTargetType.PRIMITIVE.or(ComputationTargetType.SECURITY)), "Sec");
    assertEquals(map.get(ComputationTargetType.PRIMITIVE.or(ComputationTargetType.SECURITY)), "Sec");
    assertNull(map.getDirect(ComputationTargetType.of(MockSecurity.class)));
    assertEquals(map.get(ComputationTargetType.of(MockSecurity.class)), "Sec");
    assertEquals(map.getDirect(ComputationTargetType.of(MockSecurity.class)), "Sec");
  }

  public void testMultiple() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.POSITION.or(ComputationTargetType.TRADE), "Pos|Trade");
    assertNull(map.getDirect(ComputationTargetType.NULL));
    assertNull(map.get(ComputationTargetType.NULL));
    assertNull(map.getDirect(ComputationTargetType.SECURITY));
    assertNull(map.get(ComputationTargetType.SECURITY));
    assertEquals(map.getDirect(ComputationTargetType.POSITION), "Pos|Trade");
    assertEquals(map.get(ComputationTargetType.POSITION), "Pos|Trade");
    assertEquals(map.getDirect(ComputationTargetType.TRADE), "Pos|Trade");
    assertEquals(map.get(ComputationTargetType.TRADE), "Pos|Trade");
    assertEquals(map.getDirect(ComputationTargetType.PORTFOLIO_NODE.containing(ComputationTargetType.POSITION)), "Pos|Trade");
    assertEquals(map.get(ComputationTargetType.PORTFOLIO_NODE.containing(ComputationTargetType.POSITION)), "Pos|Trade");
    assertEquals(map.getDirect(ComputationTargetType.TRADE.or(ComputationTargetType.POSITION)), "Pos|Trade");
    assertEquals(map.get(ComputationTargetType.TRADE.or(ComputationTargetType.POSITION)), "Pos|Trade");
    assertNull(map.getDirect(ComputationTargetType.of(MockSecurity.class)));
    assertNull(map.get(ComputationTargetType.of(MockSecurity.class)));
  }

  public void testHierarchy() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.SECURITY, "SEC");
    map.put(ComputationTargetType.of(MockSecurity.class), "MOCK");
    final Class<? extends MockSecurity> c = new MockSecurity(0) {
      private static final long serialVersionUID = 1L;
    }.getClass();
    assertNull(map.getDirect(ComputationTargetType.of(c)));
    assertEquals(map.get(ComputationTargetType.of(c)), "MOCK");
  }

  @Test(expectedExceptions = {IllegalStateException.class })
  public void testCollision_direct() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.POSITION.or(ComputationTargetType.TRADE), "Pos|Trade");
    map.put(ComputationTargetType.PORTFOLIO_NODE.containing(ComputationTargetType.POSITION), "Pos");
  }

  @Test(expectedExceptions = {IllegalStateException.class })
  public void testCollision_cache() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.SECURITY, "Sec");
    assertNotNull(map.get(ComputationTargetType.of(MockSecurity.class)));
    map.put(ComputationTargetType.of(MockSecurity.class), "MSec");
  }

  public void testCollision_folding() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>(new BinaryOperator<String>() {
      @Override
      public String apply(final String a, final String b) {
        return a + b;
      }
    });
    map.put(ComputationTargetType.POSITION.or(ComputationTargetType.TRADE), "A");
    map.put(ComputationTargetType.PORTFOLIO_NODE.containing(ComputationTargetType.POSITION), "B");
    assertEquals(map.get(ComputationTargetType.TRADE), "A");
    assertEquals(map.get(ComputationTargetType.POSITION), "AB");
  }

  public void testChained() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.SECURITY, "A");
    map.put(ComputationTargetType.POSITION.containing(ComputationTargetType.TRADE.or(ComputationTargetType.of(MockSecurity.class))), "B",
        new BinaryOperator<String>() {
          @Override
          public String apply(final String a, final String b) {
            return a + b;
          }
        });
    assertEquals(map.get(ComputationTargetType.SECURITY), "A");
    assertEquals(map.get(ComputationTargetType.TRADE), "B");
    assertEquals(map.get(ComputationTargetType.of(MockSecurity.class)), "AB");
  }

  public void testValues_noNull() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.POSITION, "Pos");
    map.put(ComputationTargetType.SECURITY, "Sec");
    map.get(ComputationTargetType.SECURITY);
    map.get(ComputationTargetType.PORTFOLIO_NODE);
    int flags = 0;
    for (String str : map.values()) {
      if ("Pos".equals(str) && ((flags & 1) == 0)) {
        flags |= 1;
      } else if ("Sec".equals(str) && ((flags & 2) == 0)) {
        flags |= 2;
      } else {
        fail("str = " + str + ", flags = " + flags);
      }
    }
    assertEquals(flags, 3);
  }

  public void testValues_withNull() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.NULL, "Null");
    map.put(ComputationTargetType.POSITION, "Pos");
    map.get(ComputationTargetType.SECURITY);
    map.get(ComputationTargetType.PORTFOLIO_NODE);
    int flags = 0;
    for (String str : map.values()) {
      if ("Pos".equals(str) && ((flags & 1) == 0)) {
        flags |= 1;
      } else if ("Null".equals(str) && ((flags & 2) == 0)) {
        flags |= 2;
      } else {
        fail("str = " + str + ", flags = " + flags);
      }
    }
    assertEquals(flags, 3);
  }

  public void testValues_withRemove() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.NULL, "Null");
    map.put(ComputationTargetType.SECURITY, "Sec");
    map.get(ComputationTargetType.POSITION);
    map.get(ComputationTargetType.PORTFOLIO_NODE);
    int count = 0;
    final Iterator<String> itr = map.values().iterator();
    while (itr.hasNext()) {
      final String str = itr.next();
      assertTrue(str.equals("Null") || str.equals("Sec"));
      count++;
      itr.remove();
    }
    assertEquals(count, 2);
    assertEquals(map.get(ComputationTargetType.NULL), null);
    assertEquals(map.get(ComputationTargetType.SECURITY), null);
  }

  public void testEntries_noNull() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.POSITION, "Pos");
    map.put(ComputationTargetType.SECURITY, "Sec");
    map.get(ComputationTargetType.PORTFOLIO_NODE);
    int flags = 0;
    for (Map.Entry<ComputationTargetType, String> e : map.entries()) {
      if ("Pos".equals(e.getValue()) && ((flags & 1) == 0)) {
        assertEquals(e.getKey(), ComputationTargetType.POSITION);
        flags |= 1;
        e.setValue("Foo");
      } else if ("Sec".equals(e.getValue()) && ((flags & 2) == 0)) {
        assertEquals(e.getKey(), ComputationTargetType.SECURITY);
        flags |= 2;
        e.setValue("Bar");
      } else {
        fail("e = " + e + ", flags = " + flags);
      }
    }
    assertEquals(flags, 3);
    assertEquals(map.get(ComputationTargetType.POSITION), "Foo");
    assertEquals(map.get(ComputationTargetType.SECURITY), "Bar");
  }

  public void testEntries_withNull() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.NULL, "Null");
    map.put(ComputationTargetType.POSITION, "Pos");
    map.get(ComputationTargetType.SECURITY);
    map.get(ComputationTargetType.PORTFOLIO_NODE);
    int flags = 0;
    for (Map.Entry<ComputationTargetType, String> e : map.entries()) {
      if ("Pos".equals(e.getValue()) && ((flags & 1) == 0)) {
        assertEquals(e.getKey(), ComputationTargetType.POSITION);
        flags |= 1;
        e.setValue("Foo");
      } else if ("Null".equals(e.getValue()) && ((flags & 2) == 0)) {
        assertEquals(e.getKey(), ComputationTargetType.NULL);
        flags |= 2;
        e.setValue("Bar");
      } else {
        fail("e = " + e + ", flags = " + flags);
      }
    }
    assertEquals(flags, 3);
    assertEquals(map.get(ComputationTargetType.NULL), "Bar");
    assertEquals(map.get(ComputationTargetType.POSITION), "Foo");
  }

  public void testEntries_withRemove() {
    final ComputationTargetTypeMap<String> map = new ComputationTargetTypeMap<String>();
    map.put(ComputationTargetType.NULL, "Null");
    map.put(ComputationTargetType.SECURITY, "Sec");
    map.get(ComputationTargetType.POSITION);
    map.get(ComputationTargetType.PORTFOLIO_NODE);
    int count = 0;
    final Iterator<Map.Entry<ComputationTargetType, String>> itr = map.entries().iterator();
    while (itr.hasNext()) {
      final Map.Entry<ComputationTargetType, String> str = itr.next();
      assertTrue(str.getValue().equals("Null") || str.getValue().equals("Sec"));
      count++;
      itr.remove();
    }
    assertEquals(count, 2);
    assertEquals(map.get(ComputationTargetType.NULL), null);
    assertEquals(map.get(ComputationTargetType.SECURITY), null);
  }

}