@Override public MonetaryAmount subtract(MonetaryAmount amount) { return money.subtract(amount); }
@Override public MonetaryAmount subtract(MonetaryAmount amount) { return of(money.subtract(amount)); }
@Override public MonetaryAmount subtract(MonetaryAmount amount) { return of(money.subtract(amount)); }
/** * Calculates the taxes applied to the pricing. * @param taxedPrice the taxed price * @return the monetary amount representing the taxes */ public static MonetaryAmount calculateAppliedTaxes(final TaxedItemPrice taxedPrice) { return taxedPrice.getTotalGross().subtract(taxedPrice.getTotalNet()); }
public static Optional<MonetaryAmount> calculateSalesTax(final CartLike<?> cartLike) { return Optional.ofNullable(cartLike.getTaxedPrice()) .map(taxedPrice -> taxedPrice.getTotalGross().subtract(taxedPrice.getTotalNet())); }
/** * Calculates the taxes applied to the pricing. * @param taxedPrice the taxed price * @return the monetary amount representing the taxes */ public static MonetaryAmount calculateAppliedTaxes(final TaxedItemPrice taxedPrice) { return taxedPrice.getTotalGross().subtract(taxedPrice.getTotalNet()); }
protected boolean isFreeShipping(final Cart cart, final ShippingRate shippingRate) { if (shippingRate.getFreeAbove() != null) { final MonetaryAmount totalCartPriceWithoutShipping = Optional.ofNullable(cart.getShippingInfo()) .map(shippingInfo -> cart.getTotalPrice().subtract(shippingInfo.getPrice())) .orElseGet(cart::getTotalPrice); return totalCartPriceWithoutShipping.isGreaterThan(shippingRate.getFreeAbove()); } else { return false; } }
/** * Creates a new {@link ProductPaymentEntry} that rolls back the payment for the given {@link Order}. * * @param order must not be {@literal null}. * @param description must not be {@literal null}. * @return * @since 7.1 */ public static ProductPaymentEntry rollback(Order order, String description) { Assert.notNull(order, "Order must not be null!"); Assert.notNull(description, "Description must not be null!"); MonetaryAmount amount = Currencies.ZERO_EURO.subtract(order.getTotal()); return new ProductPaymentEntry(order.getId(), order.getUserAccount(), amount, description, order.getPaymentMethod()); }
public static void main(String[] args) { CurrencyUnit dollar = Monetary.getCurrency(Locale.US); MonetaryAmount money = Money.of(120, dollar); MonetaryAmount money2 = Money.of(50, dollar); System.out.println(money.add(money2)); System.out.println(money.subtract(money2)); System.out.println(money.multiply(2)); System.out.println(money.divide(2)); System.out.println(money.isEqualTo(money2)); System.out.println(money.isGreaterThan(money2)); System.out.println(money.isGreaterThanOrEqualTo(money2)); System.out.println(money.isGreaterThanOrEqualTo(money2)); System.out.println(money.isLessThan(money2)); System.out.println(money.isLessThanOrEqualTo(money2)); System.out.println(money.isNegative()); System.out.println(money.isNegativeOrZero()); } }
/** * Gets the minor part of a {@code MonetaryAmount} with the same scale. * <p> * This returns the monetary amount in terms of the minor units of the * currency, truncating the whole part if necessary. For example, 'EUR 2.35' * will return 'EUR 0.35', and 'BHD -1.345' will return 'BHD -0.345'. * <p> * This is returned as a {@code MonetaryAmount} rather than a * {@code BigDecimal} . This is to allow further calculations to be * performed on the result. Should you need a {@code BigDecimal}, simply * call {@code asType(BigDecimal.class)}. * * @return the minor units part of the amount, never {@code null} */ @Override public MonetaryAmount apply(MonetaryAmount amount){ Objects.requireNonNull(amount, "Amount required."); BigDecimal number = amount.getNumber().numberValue(BigDecimal.class); BigDecimal wholes = number.setScale(0, RoundingMode.DOWN); return amount.subtract(amount.getFactory().setNumber(wholes).create()); }
/** * Tests that subtract(), which results in an amount exceeding the max MonetaryContext throws * a MonetaryException. */ @SpecAssertion(section = "4.2.2", id = "422-D10") @Test(description = "4.2.2 For each amount class, ensure subtraction with null throws NullPointerException.") public void testSubtract_Null() { for (Class type : Monetary.getAmountTypes()) { if (type.equals(TestAmount.class)) { continue; } MonetaryAmount mAmount1 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(10).create(); try { mAmount1.subtract(null); AssertJUnit.fail("Section 4.2.2: MonetaryAmount.subtract(null): NullPointerException expected"); } catch (NullPointerException ex) { // Expected } } }
/** * Tests that subtract(0) should return itself. */ @SpecAssertion(section = "4.2.2", id = "422-D7") @Test(description = "4.2.2 For each amount class, ensure subtraction of 0 returns same instance.") public void testSubtract_Zero() { for (Class type : Monetary.getAmountTypes()) { if (type.equals(TestAmount.class)) { continue; } MonetaryAmount mAmount1 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(10).create(); MonetaryAmount mAmount2 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(0).create(); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); AssertJUnit.assertEquals("Section 4.2.2: Subtract zero", mAmount1, mActualResult); } }
/** * Tests that subtract() with non matching currencies throws a * MonetaryException. */ @SpecAssertion(section = "4.2.2", id = "422-D8") @Test(description = "4.2.2 For each amount class, ensure subtraction with invalid currency throws " + "MonetaryException.") public void testSubtract_IncompatibleCurrencies() { for (Class type : Monetary.getAmountTypes()) { if (type.equals(TestAmount.class)) { continue; } MonetaryAmount mAmount1 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(10).create(); MonetaryAmount mAmount2 = Monetary.getAmountFactory(type).setCurrency(ADDITIONAL_CURRENCY).setNumber(20).create(); try { MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); AssertJUnit.fail("Section 4.2.2: Exception expected"); } catch (MonetaryException ex) { // Expected } } }
mAmount1 = f.setNumber(f.getMinNumber()).create().negate(); m = TestUtils.createAmountWithPrecision(maxCtx.getPrecision() + 1); mAmount1 = mAmount1.subtract(m); AssertJUnit.fail("Section 4.2.2: ArithmeticException expected on subtraction that exceeds " + "capabilities for " + mAmount1.subtract(m); AssertJUnit.fail("Section 4.2.2: ArithmeticException expected on subtraction that exceeds " + "capabilities for " +
/** * Tests that subtract() correctly adds two values, using positive integers. */ @SpecAssertion(section = "4.2.2", id = "422-D6") @Test(description = "4.2.2 For each amount class, ensure correct subtraction of positive ints.") public void testSubtractPositiveIntegers() { for (Class type : Monetary.getAmountTypes()) { if (type.equals(TestAmount.class)) { continue; } MonetaryAmount mAmount1 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(10).create(); MonetaryAmount mAmount2 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(20).create(); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(-10).create(); AssertJUnit.assertEquals("Section 4.2.2: Subtracting two simple ammounts", mExpectedResult, mActualResult); } }
/** * Tests that subtract() correctly adds two values, using negative integers. */ @SpecAssertion(section = "4.2.2", id = "422-D6") @Test(description = "4.2.2 For each amount class, ensure correct subtraction of negative ints.") public void testSubtractNegativeIntegers() { for (Class type : Monetary.getAmountTypes()) { if (type.equals(TestAmount.class)) { continue; } MonetaryAmount mAmount1 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(-10).create(); MonetaryAmount mAmount2 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(-20).create(); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(10).create(); AssertJUnit.assertEquals("Section 4.2.2: Subtracting two simple ammounts", mExpectedResult, mActualResult); } }
/** * Tests that subtract() correctly adds two values, using fractions. */ @SpecAssertion(section = "4.2.2", id = "422-D6") @Test(description = "4.2.2 For each amount class, ensure correct subtraction of positive fractions.") public void testSubtractPositiveFractions() { for (Class type : Monetary.getAmountTypes()) { if (type.equals(TestAmount.class)) { continue; } MonetaryAmount mAmount1 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(1.5).create(); MonetaryAmount mAmount2 = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(2.85).create(); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(-1.35).create(); AssertJUnit.assertEquals("Section 4.2.2: Adding two simple ammounts", mExpectedResult, mActualResult); } }
MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(4.35).create(); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(-4.35).create(); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(0).create(); AssertJUnit.assertEquals("Section 4.2.2: Adding two simple ammounts", mExpectedResult, mActualResult);
MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(10).create(); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(0).create(); AssertJUnit.assertEquals("Section 4.2.2: Adding two simple ammounts", mExpectedResult, mActualResult); MonetaryAmount mActualResult = mAmount1.subtract(mAmount2); MonetaryAmount mExpectedResult = Monetary.getAmountFactory(type).setCurrency(DEFAULT_CURRENCY).setNumber(-20).create();
isEqualTo(cart.getTotalPrice().subtract(discountAmount)); assertThat(discountedLineItemPrice2.getIncludedDiscounts().get(0).getDiscount()).isEqualTo(cartDiscount.toReference()); assertThat(discountedLineItemPrice2.getIncludedDiscounts().get(0).getDiscountedAmount()).isEqualTo(MoneyImpl.ofCents(33, EUR)); assertThat(lineItemWithDiscount.getTotalPrice()).isEqualTo(oldLineItemTotalPrice.subtract(discountAmount)); assertThat(lineItemWithDiscount.getQuantity()).as("lineItem quantity").isEqualTo(3);