FunctionBlacklistRuleListenerSlowTest.java

/**
 * Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.engine.function.blacklist;

import static org.testng.Assert.assertEquals;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.testng.annotations.Test;

import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.id.UniqueId;
import com.opengamma.util.test.TestGroup;
import com.opengamma.util.test.Timeout;

/**
 * Tests the {@link AbstractFunctionBlacklistRuleListener} class.
 */
@Test(groups = TestGroup.UNIT_SLOW)
public class FunctionBlacklistRuleListenerSlowTest {

  private final FunctionBlacklistRule RULE_1 = new FunctionBlacklistRule();
  private final FunctionBlacklistRule RULE_2 = new FunctionBlacklistRule(ComputationTargetSpecification.of(UniqueId.of("test", "foo")));
  private final FunctionBlacklistRule RULE_3 = new FunctionBlacklistRule(ComputationTargetSpecification.of(UniqueId.of("test", "bar")));

  private class MockBlacklist extends HashSet<FunctionBlacklistRule> implements FunctionBlacklist {

    private static final long serialVersionUID = 1L;

    private int _modificationCount;

    public MockBlacklist() {
      add(RULE_1);
    }

    @Override
    public String getName() {
      throw new UnsupportedOperationException();
    }

    @Override
    public Set<FunctionBlacklistRule> getRules() {
      return this;
    }

    @Override
    public int getModificationCount() {
      return _modificationCount;
    }

    @Override
    public void addRuleListener(final FunctionBlacklistRuleListener listener) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void removeRuleListener(final FunctionBlacklistRuleListener listener) {
      throw new UnsupportedOperationException();
    }
  }

  private class Listener extends AbstractFunctionBlacklistRuleListener {

    private int _replaceRules;
    private int _addRule;
    private int _removeRule;

    protected Listener(final FunctionBlacklist blacklist) {
      super(blacklist);
    }

    @Override
    protected void replaceRules(final Collection<FunctionBlacklistRule> rules) {
      _replaceRules++;
    }

    @Override
    protected void addRule(final FunctionBlacklistRule rule) {
      _addRule++;
    }

    @Override
    protected void removeRule(final FunctionBlacklistRule rule) {
      _removeRule++;
    }
  }

  //-------------------------------------------------------------------------
  public void testAdd_badSequence() throws Exception {
    final ExecutorService executor = Executors.newSingleThreadExecutor();
    try {
      final MockBlacklist blacklist = new MockBlacklist();
      final Listener listener = new Listener(blacklist);
      listener.init();
      assertEquals(listener._replaceRules, 1);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
      final CountDownLatch latch = new CountDownLatch(2);
      blacklist._modificationCount = 5;
      blacklist.add(RULE_2);
      listener.ruleAdded(5, RULE_2, executor);
      executor.submit(new Runnable() {
        @Override
        public void run() {
          latch.countDown();
        }
      });
      latch.await(Timeout.standardTimeoutMillis(), TimeUnit.MILLISECONDS);
      assertEquals(listener._replaceRules, 2);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
    } finally {
      executor.shutdown();
    }
  }

  public void testAddMultiple_badSequence() throws Exception {
    final ExecutorService executor = Executors.newSingleThreadExecutor();
    try {
      final MockBlacklist blacklist = new MockBlacklist();
      final Listener listener = new Listener(blacklist);
      listener.init();
      assertEquals(listener._replaceRules, 1);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
      final CountDownLatch latch = new CountDownLatch(2);
      blacklist._modificationCount = 5;
      blacklist.add(RULE_2);
      blacklist.add(RULE_3);
      listener.rulesAdded(5, Arrays.asList(RULE_2, RULE_3), executor);
      executor.submit(new Runnable() {
        @Override
        public void run() {
          latch.countDown();
        }
      });
      latch.await(Timeout.standardTimeoutMillis(), TimeUnit.MILLISECONDS);
      assertEquals(listener._replaceRules, 2);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
    } finally {
      executor.shutdown();
    }
  }

  public void testRemove_badSequence() throws Exception {
    final ExecutorService executor = Executors.newSingleThreadExecutor();
    try {
      final MockBlacklist blacklist = new MockBlacklist();
      final Listener listener = new Listener(blacklist);
      listener.init();
      assertEquals(listener._replaceRules, 1);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
      final CountDownLatch latch = new CountDownLatch(2);
      blacklist._modificationCount = 5;
      listener.ruleRemoved(5, RULE_2, executor);
      executor.submit(new Runnable() {
        @Override
        public void run() {
          latch.countDown();
        }
      });
      latch.await(Timeout.standardTimeoutMillis(), TimeUnit.MILLISECONDS);
      assertEquals(listener._replaceRules, 2);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
    } finally {
      executor.shutdown();
    }
  }

  public void testRemoveMultiple_badSequence() throws Exception {
    final ExecutorService executor = Executors.newSingleThreadExecutor();
    try {
      final MockBlacklist blacklist = new MockBlacklist();
      final Listener listener = new Listener(blacklist);
      listener.init();
      assertEquals(listener._replaceRules, 1);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
      final CountDownLatch latch = new CountDownLatch(2);
      blacklist._modificationCount = 5;
      listener.rulesRemoved(5, Arrays.asList(RULE_2, RULE_3), executor);
      executor.submit(new Runnable() {
        @Override
        public void run() {
          latch.countDown();
        }
      });
      latch.await(Timeout.standardTimeoutMillis(), TimeUnit.MILLISECONDS);
      assertEquals(listener._replaceRules, 2);
      assertEquals(listener._addRule, 0);
      assertEquals(listener._removeRule, 0);
    } finally {
      executor.shutdown();
    }
  }

}