/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.financial.fudgemsg;
import static org.testng.AssertJUnit.assertEquals;
import java.util.Collection;
import java.util.Random;
import org.testng.annotations.Test;
import com.opengamma.core.id.ExternalSchemes;
import com.opengamma.core.value.MarketDataRequirementNames;
import com.opengamma.engine.target.ComputationTargetType;
import com.opengamma.engine.value.ValueRequirement;
import com.opengamma.financial.currency.AbstractCurrencyMatrix;
import com.opengamma.financial.currency.CurrencyMatrix;
import com.opengamma.financial.currency.CurrencyMatrixValue;
import com.opengamma.financial.currency.SimpleCurrencyMatrix;
import com.opengamma.id.ExternalId;
import com.opengamma.util.money.Currency;
import com.opengamma.util.test.TestGroup;
/**
* Test.
*/
@Test(groups = TestGroup.UNIT)
public class CurrencyMatrixTest extends FinancialTestBase {
private static void assertMatrixEqual(final CurrencyMatrix expected, final CurrencyMatrix actual) {
final Collection<Currency> expectedSourceCurrencies = expected.getSourceCurrencies();
final Collection<Currency> expectedTargetCurrencies = expected.getTargetCurrencies();
final Collection<Currency> actualSourceCurrencies = actual.getSourceCurrencies();
final Collection<Currency> actualTargetCurrencies = actual.getTargetCurrencies();
assertEquals(expectedSourceCurrencies.size(), actualSourceCurrencies.size());
for (Currency source : actualSourceCurrencies) {
assertEquals(true, expectedSourceCurrencies.contains(source));
}
assertEquals(expectedTargetCurrencies.size(), actualTargetCurrencies.size());
for (Currency target : actualTargetCurrencies) {
assertEquals(true, expectedTargetCurrencies.contains(target));
}
for (Currency source : expectedSourceCurrencies) {
for (Currency target : expectedTargetCurrencies) {
assertEquals(expected.getConversion(source, target), actual.getConversion(source, target));
}
}
}
@Test
public void testEmptyMatrix() {
final SimpleCurrencyMatrix empty = new SimpleCurrencyMatrix ();
assertMatrixEqual(empty, cycleGenericObject(CurrencyMatrix.class, empty));
}
@Test
public void testSymmetricalMatrix() {
final SimpleCurrencyMatrix simple = new SimpleCurrencyMatrix();
simple.setLiveData(Currency.USD, Currency.GBP,
new ValueRequirement(MarketDataRequirementNames.MARKET_VALUE, ComputationTargetType.PRIMITIVE, ExternalId.of(ExternalSchemes.BLOOMBERG_TICKER.getName(), "GBP Curncy")));
simple.setFixedConversion(Currency.GBP, Currency.EUR, 0.9);
simple.setCrossConversion(Currency.USD, Currency.EUR, Currency.GBP);
simple.setFixedConversion(Currency.EUR, Currency.CHF, 10.0);
assertMatrixEqual(simple, cycleGenericObject(CurrencyMatrix.class, simple));
}
private static class RandomMatrix extends AbstractCurrencyMatrix {
private static CurrencyMatrixValue randomValue(final Random r) {
switch (r.nextInt(4)) {
case 1:
return CurrencyMatrixValue.of(r.nextDouble());
case 2:
return CurrencyMatrixValue.of(Currency.of("AA" + (char) ('A' + r.nextInt(('Z' - 'A') + 1))));
case 3:
return CurrencyMatrixValue.of(new ValueRequirement(MarketDataRequirementNames.MARKET_VALUE, ComputationTargetType.PRIMITIVE, ExternalId.of("Test", "" + r.nextLong())));
}
return null;
}
public RandomMatrix() {
final Random r = new Random();
for (char source = 'A'; source < 'Z'; source++) {
final Currency sourceCurrency = Currency.of("AA" + source);
for (char target = (char) (source + 1); target <= 'Z'; target++) {
final Currency targetCurrency = Currency.of("AA" + target);
CurrencyMatrixValue value = randomValue(r);
if (value != null) {
addConversion(sourceCurrency, targetCurrency, value);
if (r.nextBoolean()) {
addConversion(targetCurrency, sourceCurrency, value.getReciprocal());
} else {
value = randomValue(r);
if (value != null) {
addConversion(targetCurrency, sourceCurrency, value);
}
}
} else {
value = randomValue(r);
if (value != null) {
addConversion(targetCurrency, sourceCurrency, value);
}
}
}
}
}
}
@Test
public void testRandomMatrix() {
final RandomMatrix random = new RandomMatrix();
assertMatrixEqual(random, cycleGenericObject(CurrencyMatrix.class, random));
}
}