How to use

getFactor

method

in

javax.money.convert.ExchangeRate

private ExchangeRate reverse(ExchangeRate rate) {
  if (Objects.isNull(rate)) {
    throw new IllegalArgumentException("Rate null is not reversible.");
  }
  return new ExchangeRateBuilder(rate).setRate(rate).setBase(rate.getCurrency()).setTerm(rate.getBaseCurrency())
      .setFactor(divide(DefaultNumberValue.ONE, rate.getFactor(), MathContext.DECIMAL64)).build();
}

/**
 * Test correct rate evaluation for different provider chains, providers defined by the TCK.<p>
 * Hint do not use non TCK provider for this test, it will make results undeterministic.
 */
@Test(description = "4.3.4 Test correct rate evaluation for different conversion provider chains, " +
    "with duplicate provider entries.")
@SpecAssertion(id = "434-A1", section = "4.3.4")
public void testCorrectRateEvaluationInChain_sameProviders() {
  ExchangeRateProvider prov1 = MonetaryConversions
      .getExchangeRateProvider("TestRateProvider1", "TestRateProvider1", "TestRateProvider1");
  ExchangeRate rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1", "TestRateProvider1");
  rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1");
  rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
}

/**
 * Test correct rate evaluation for different provider chains, providers defined by the TCK,
 * with historic rates.<p>
 * Hint do not use non TCK provider for this test, it will make results undeterministic.
 */
@Test(description = "4.3.4 Test correct rate evaluation for different conversion provider chains, " +
    "with historic rates.")
@SpecAssertion(id = "434-A2", section = "4.3.4")
public void testCorrectRateEvaluationInChainHistoric() {
  ExchangeRateProvider prov1 = MonetaryConversions
      .getExchangeRateProvider("TestRateProvider1", "TestRateProvider2", "TestRateProvider3");
  ExchangeRate rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  rate = prov1.getExchangeRate("EUR", "USD");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
  Calendar cal = GregorianCalendar.getInstance();
  cal.setTimeInMillis(0L);
  rate = prov1.getExchangeRate(
      ConversionQueryBuilder.of()
          .set(cal)
          .setBaseCurrency("EUR")
          .setTermCurrency("USD")
          .build());
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", 2, rate.getFactor().intValueExact());
}

/**
 * Initialize the {@link ExchangeRateBuilder} with an {@link javax.money.convert.ExchangeRate}. This is
 * useful for creating a new rate, reusing some properties from an
 * existing one.
 *
 * @param rate the base rate
 * @return the Builder, for chaining.
 */
public ExchangeRateBuilder setRate(ExchangeRate rate) {
  this.base = rate.getBaseCurrency();
  this.term = rate.getCurrency();
  this.conversionContext = rate.getContext();
  this.factor = rate.getFactor();
  this.rateChain = rate.getExchangeRateChain();
  this.term = rate.getCurrency();
  return this;
}

  /**
   * Initialize the {@link Builder} with an {@link javax.money.convert.ExchangeRate}. This is
   * useful for creating a new rate, reusing some properties from an
   * existing one.
   *
   * @param rate the base rate
   * @return the Builder, for chaining.
   */
  public Builder setRate(ExchangeRate rate) {
    this.base = rate.getBaseCurrency();
    this.term = rate.getCurrency();
    this.conversionContext = rate.getContext();
    this.factor = rate.getFactor();
    this.rateChain = rate.getExchangeRateChain();
    this.term = rate.getCurrency();
    return this;
  }
}

    .getExchangeRateProvider("TestRateProvider1", "TestRateProvider2", "TestRateProvider3");
ExchangeRate rate = prov1.getExchangeRate("CHF", "EUR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1", "TestRateProvider2");
rate = prov1.getExchangeRate("EUR", "USD");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider3");
rate = prov1.getExchangeRate("USD", "INR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 3);
prov1 = MonetaryConversions
    .getExchangeRateProvider("TestRateProvider1", "TestRateProvider3", "TestRateProvider2");
rate = prov1.getExchangeRate("CHF", "EUR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
rate = prov1.getExchangeRate("EUR", "USD");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
rate = prov1.getExchangeRate("USD", "INR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 3);
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
prov1 = MonetaryConversions
    .getExchangeRateProvider("TestRateProvider2", "TestRateProvider1", "TestRateProvider3");
rate = prov1.getExchangeRate("EUR", "USD");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 2);
rate = prov1.getExchangeRate("USD", "INR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 3);
        "TestRateProvider02");
rate = prov1.getExchangeRate("CHF", "EUR");
AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);

/**
 * Sets the exchange rate type
 *
 * @param rate the {@link javax.money.convert.ExchangeRate} to be applied
 */
public ExchangeRateBuilder(ExchangeRate rate) {
  setContext(rate.getContext());
  setFactor(rate.getFactor());
  setTerm(rate.getCurrency());
  setBase(rate.getBaseCurrency());
  setRateChain(rate.getExchangeRateChain());
}

/**
 * Method that converts the source {@link MonetaryAmount} to an
 * {@link MonetaryAmount} based on the {@link ExchangeRate} of this
 * conversion.
 * @param amount The source amount
 * @return The converted amount, never null.
 * @throws CurrencyConversionException if conversion failed, or the required data is not available.
 * @see #getExchangeRate(MonetaryAmount)
 */
@Override
public MonetaryAmount apply(MonetaryAmount amount) {
  if (termCurrency.equals(Objects.requireNonNull(amount).getCurrency())) {
    return amount;
  }
  ExchangeRate rate = getExchangeRate(amount);
  if (Objects.isNull(rate) || !amount.getCurrency().equals(rate.getBaseCurrency())) {
    throw new CurrencyConversionException(amount.getCurrency(),
        this.termCurrency, null);
  }
  NumberValue factor = rate.getFactor();
  factor = roundFactor(amount, factor);
  Integer scale = rate.getContext().get(KEY_SCALE, Integer.class);
  if(Objects.isNull(scale) || scale < 0) {
    return amount.multiply(factor).getFactory().setCurrency(rate.getCurrency()).create();
  } else {
    return amount.multiply(factor).getFactory().setCurrency(rate.getCurrency()).create().with(MonetaryOperators.rounding(scale));
  }
}

/**
 * Sets the exchange rate type
 *
 * @param rate the {@link javax.money.convert.ExchangeRate} to be applied
 */
public Builder(ExchangeRate rate) {
  setContext(rate.getContext());
  setFactor(rate.getFactor());
  setTerm(rate.getCurrency());
  setBase(rate.getBaseCurrency());
  setRateChain(rate.getExchangeRateChain());
}

private ExchangeRate createExchangeRate(ConversionQuery query,
                    ExchangeRateBuilder builder, ExchangeRate sourceRate,
                    ExchangeRate target) {
  if (areBothBaseCurrencies(query)) {
    builder.setFactor(DefaultNumberValue.ONE);
    return builder.build();
  } else if (BASE_CURRENCY_CODE.equals(query.getCurrency().getCurrencyCode())) {
    if (Objects.isNull(sourceRate)) {
      return null;
    }
    return reverse(sourceRate);
  } else if (BASE_CURRENCY_CODE.equals(query.getBaseCurrency()
      .getCurrencyCode())) {
    return target;
  } else {
    ExchangeRate rate1 = getExchangeRate(
        query.toBuilder().setTermCurrency(Monetary.getCurrency(BASE_CURRENCY_CODE)).build());
    ExchangeRate rate2 = getExchangeRate(
        query.toBuilder().setBaseCurrency(Monetary.getCurrency(BASE_CURRENCY_CODE))
            .setTermCurrency(query.getCurrency()).build());
    if (Objects.nonNull(rate1) && Objects.nonNull(rate2)) {
      builder.setFactor(multiply(rate1.getFactor(), rate2.getFactor()));
      builder.setRateChain(rate1, rate2);
      return builder.build();
    }
    throw new CurrencyConversionException(query.getBaseCurrency(),
        query.getCurrency(), sourceRate.getContext());
  }
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access to exchange rates from TestRateProvider, using target currency code.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRatesWithCodes() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    if (base.equals(FOO_UNIT)) {
      continue;
    }
    ExchangeRate rate = prov.getExchangeRate(base.getCurrencyCode(), "XXX");
    AssertJUnit
        .assertNotNull("Identity rate, accessed by getExchangeRate(String, String), is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode(), rate);
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), "FOO");
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access to exchange rates from TestRateProvider, using target CUrrencyUnit.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRatesAndContext() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    if (base.equals(FOO_UNIT)) {
      continue;
    }
    ExchangeRate rate = prov.getExchangeRate(base, FOO_UNIT);
    AssertJUnit.assertNotNull(
        "Identity rate, accessed by getExchangeRate(CurrencyUnit, CurrencyUnit, ConversionContext), " +
            "is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access of Conversion Rates, using TCK provided rate provider.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRates() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    if (base.equals(FOO_UNIT)) {
      continue;
    }
    ExchangeRate rate = prov.getExchangeRate(base, FOO_UNIT);
    AssertJUnit.assertNotNull(
        "Identity rate, accessed by getExchangeRate(CurrencyUnit, CurrencyUnit), is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}

/**
 * Compare conversions done with exchange rates provided for same currency pair.
 */
@Test(description = "4.3.2 Test correct ExchangeRate is returned for CHF -> FOO, using TestRateProvider.")
@SpecAssertion(id = "432-A2", section = "4.3.2")
public void testConversionComparedWithRate() {
  final CurrencyUnit FOO = new TestCurrencyUnit("FOO");
  ExchangeRate rate = MonetaryConversions.getExchangeRateProvider("TestRateProvider")
      .getExchangeRate(Monetary.getCurrency("CHF"), FOO);
  AssertJUnit.assertEquals(rate.getBaseCurrency(), Monetary.getCurrency("CHF"));
  AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO.getCurrencyCode());
  AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  AssertJUnit.assertEquals("TestRateProvider", rate.getContext().getProviderName());
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3  Test access to conversion rates, including known factor, using TestRateProvider.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRatesWithCodesAndContext() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    ExchangeRate rate = prov.getExchangeRate(base, FOO_UNIT);
    AssertJUnit
        .assertNotNull("Identity rate, accessed by getExchangeRate(String, String, ConversionContext), " +
            "is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode(), rate);
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}