@Test
 public void presentValueCurveSensitivity() {
   final InterestRateCurveSensitivity pvcsComputed =
       METHOD_SECURITY.presentValueCurveSensitivity(BILL_IAM_SEC, CURVE_BUNDLE);
   assertEquals(
       "Bill Security: present value curve sensitivity",
       1,
       pvcsComputed.getSensitivities().size());
   assertEquals(
       "Bill Security: present value curve sensitivity",
       1,
       pvcsComputed.getSensitivities().get(NAME_CURVES[1]).size());
   final double deltaTolerancePrice = 1.0E+2;
   // Testing note: Sensitivity is for a movement of 1. 1E+2 = 0.01 unit for a 1 bp move.
   final double deltaShift = 1.0E-6;
   // Credit curve sensitivity
   final String bumpedCurveName = "Bumped Curve";
   final BillSecurity billBumped =
       BILL_IAM_SEC_DEFINITION.toDerivative(REFERENCE_DATE, NAME_CURVES[0], bumpedCurveName);
   final double[] nodeTimes = new double[] {billBumped.getEndTime()};
   final double[] sensi =
       SensitivityFiniteDifference.curveSensitivity(
           billBumped,
           CURVE_BUNDLE,
           NAME_CURVES[1],
           bumpedCurveName,
           nodeTimes,
           deltaShift,
           METHOD_SECURITY);
   final List<DoublesPair> sensiPv = pvcsComputed.getSensitivities().get(NAME_CURVES[1]);
   for (int loopnode = 0; loopnode < sensi.length; loopnode++) {
     final DoublesPair pairPv = sensiPv.get(loopnode);
     assertEquals(
         "Bill Security: curve sensitivity - Node " + loopnode,
         nodeTimes[loopnode],
         pairPv.getFirst(),
         1E-8);
     AssertJUnit.assertEquals(
         "Bill Security: curve sensitivity", pairPv.second, sensi[loopnode], deltaTolerancePrice);
   }
 }
/**
 * Test related to the description of a bill total return swap with an underlying bill and a funding
 * leg.
 */
public class BillTotalReturnSwapTest {

  private static final Currency EUR = Currency.EUR;

  private static final ZonedDateTime EFFECTIVE_DATE = DateUtils.getUTCDate(2014, 6, 25);
  private static final ZonedDateTime TERMINATION_DATE = DateUtils.getUTCDate(2014, 12, 22);

  private static final ZonedDateTime REFERENCE_DATE_1 =
      DateUtils.getUTCDate(2014, 6, 23); // Before effective date.

  private static final double EFFECTIVE_TIME_1_1 =
      TimeCalculator.getTimeBetween(REFERENCE_DATE_1, EFFECTIVE_DATE);
  private static final double TERMINATION_TIME_1_1 =
      TimeCalculator.getTimeBetween(REFERENCE_DATE_1, TERMINATION_DATE);

  private static final BillSecurityDefinition BELDEC14_DEFINITION = BillDataSets.billBel_20141218();
  private static final BillSecurity BELDEC14 =
      BELDEC14_DEFINITION.toDerivative(REFERENCE_DATE_1, EFFECTIVE_DATE);
  // Funding: unique fixed coupon in EUR: pay TRS bill, receive funding
  private static final double NOTIONAL_TRS = 123456000;
  private static final double NOTIONAL_BILL = 100000000;

  // Funding: unique fixed coupon in GBP: receive TRS bond, pay funding
  private static final double RATE = 0.0043;
  private static final CouponFixedDefinition FUNDING_FIXED_CPN_REC_DEFINITION =
      new CouponFixedDefinition(
          EUR, TERMINATION_DATE, EFFECTIVE_DATE, TERMINATION_DATE, 0.50, NOTIONAL_TRS, RATE);
  private static final AnnuityDefinition<? extends PaymentDefinition>
      FUNDING_LEG_FIXED_REC_DEFINITION =
          new AnnuityDefinition<>(
              new CouponFixedDefinition[] {FUNDING_FIXED_CPN_REC_DEFINITION},
              BELDEC14_DEFINITION.getCalendar());
  private static final Annuity<? extends Payment> FUNDING_LEG_FIXED_REC_1 =
      FUNDING_LEG_FIXED_REC_DEFINITION.toDerivative(REFERENCE_DATE_1);
  private static final BillTotalReturnSwap TRS_PAY_FIXED_REC_1 =
      new BillTotalReturnSwap(
          EFFECTIVE_TIME_1_1,
          TERMINATION_TIME_1_1,
          FUNDING_LEG_FIXED_REC_1,
          BELDEC14,
          -NOTIONAL_BILL);

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void nullFundingLeg() {
    new BillTotalReturnSwap(
        EFFECTIVE_TIME_1_1, TERMINATION_TIME_1_1, null, BELDEC14, -NOTIONAL_BILL);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void nullBond() {
    new BillTotalReturnSwap(
        EFFECTIVE_TIME_1_1, TERMINATION_TIME_1_1, FUNDING_LEG_FIXED_REC_1, null, -NOTIONAL_BILL);
  }

  @Test
  public void getter() {
    assertEquals(
        "BondTotalReturnSwap: getter", EFFECTIVE_TIME_1_1, TRS_PAY_FIXED_REC_1.getEffectiveTime());
    assertEquals(
        "BondTotalReturnSwap: getter",
        TERMINATION_TIME_1_1,
        TRS_PAY_FIXED_REC_1.getTerminationTime());
    assertEquals(
        "BondTotalReturnSwap: getter",
        FUNDING_LEG_FIXED_REC_1,
        TRS_PAY_FIXED_REC_1.getFundingLeg());
    assertEquals("BondTotalReturnSwap: getter", BELDEC14, TRS_PAY_FIXED_REC_1.getAsset());
    assertEquals("BondTotalReturnSwap: getter", -NOTIONAL_BILL, TRS_PAY_FIXED_REC_1.getQuantity());
  }
}
/**
 * Tests related to the pricing of bills security by discounting.
 *
 * @deprecated This class tests deprecated functionality
 */
@Deprecated
public class BillSecurityDiscountingMethodTest {

  private static final Currency EUR = Currency.EUR;
  private static final Calendar CALENDAR = new MondayToFridayCalendar("TARGET");
  private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2012, 1, 17);

  private static final DayCount ACT360 = DayCountFactory.INSTANCE.getDayCount("Actual/360");
  private static final int SETTLEMENT_DAYS = 2;
  private static final YieldConvention YIELD_IAM =
      YieldConventionFactory.INSTANCE.getYieldConvention("INTEREST@MTY");
  private static final YieldConvention YIELD_DSC =
      YieldConventionFactory.INSTANCE.getYieldConvention("DISCOUNT");

  // ISIN: BE0312677462
  private static final String ISSUER_BEL = "BELGIUM GOVT";
  private static final String ISSUER_US = "US GOVT";
  private static final ZonedDateTime END_DATE = DateUtils.getUTCDate(2012, 3, 15);
  private static final double NOTIONAL = 1000;
  private static final double YIELD = 0.00185; // External source
  private static final double PRICE = 0.99971; // External source

  private static final ZonedDateTime SETTLE_DATE =
      ScheduleCalculator.getAdjustedDate(REFERENCE_DATE, SETTLEMENT_DAYS, CALENDAR);
  private static final String[] NAME_CURVES = TestsDataSetsSABR.nameCurvesBond3();
  private static final BillSecurityDefinition BILL_IAM_SEC_DEFINITION =
      new BillSecurityDefinition(
          EUR, END_DATE, NOTIONAL, SETTLEMENT_DAYS, CALENDAR, YIELD_IAM, ACT360, ISSUER_BEL);
  private static final BillSecurityDefinition BILL_DSC_SEC_DEFINITION =
      new BillSecurityDefinition(
          EUR, END_DATE, NOTIONAL, SETTLEMENT_DAYS, CALENDAR, YIELD_DSC, ACT360, ISSUER_US);
  // Should not be in EUR, but this is only a test
  private static final BillSecurity BILL_IAM_SEC =
      BILL_IAM_SEC_DEFINITION.toDerivative(REFERENCE_DATE, SETTLE_DATE, NAME_CURVES);
  private static final BillSecurity BILL_DSC_SEC =
      BILL_DSC_SEC_DEFINITION.toDerivative(REFERENCE_DATE, SETTLE_DATE, NAME_CURVES);
  private static final YieldCurveBundle CURVE_BUNDLE = TestsDataSetsSABR.createCurvesBond3();

  private static final BillSecurityDiscountingMethod METHOD_SECURITY =
      BillSecurityDiscountingMethod.getInstance();
  private static final PresentValueCalculator PVC = PresentValueCalculator.getInstance();
  private static final PresentValueCurveSensitivityCalculator PVCSC =
      PresentValueCurveSensitivityCalculator.getInstance();
  private static final YieldFromCurvesCalculator YFCC = YieldFromCurvesCalculator.getInstance();
  private static final YieldFromPriceCalculator YFPC = YieldFromPriceCalculator.getInstance();

  private static final double TOLERANCE_PV = 1.0E-2;
  private static final double TOLERANCE_PRICE = 1.0E-8;
  private static final double TOLERANCE_PRICE_EXTERNAL = 1.0E-5;
  private static final double TOLERANCE_YIELD = 1.0E-8;
  private static final double TOLERANCE_YIELD_EXTERNAL = 1.0E-4;
  private static final double TOLERANCE_YIELD_DERIVATIVE = 1.0E-6;

  @Test
  /** Tests the present value against explicit computation. */
  public void presentValue() {
    final CurrencyAmount pvComputed = METHOD_SECURITY.presentValue(BILL_IAM_SEC, CURVE_BUNDLE);
    final double pvExpected =
        NOTIONAL
            * CURVE_BUNDLE.getCurve(NAME_CURVES[1]).getDiscountFactor(BILL_IAM_SEC.getEndTime());
    assertEquals(
        "Bill Security: discounting method - present value",
        pvExpected,
        pvComputed.getAmount(),
        TOLERANCE_PV);
  }

  @Test
  /** Tests the present value: Method vs Calculator */
  public void presentValueMethodVsCalculator() {
    final CurrencyAmount pvMethod = METHOD_SECURITY.presentValue(BILL_IAM_SEC, CURVE_BUNDLE);
    final double pvCalculator = BILL_IAM_SEC.accept(PVC, CURVE_BUNDLE);
    assertEquals(
        "Bill Security: discounting method - present value",
        pvMethod.getAmount(),
        pvCalculator,
        TOLERANCE_PV);
  }

  @Test
  public void priceFromYield() {
    final double[] yields = new double[] {0.0010, 0.0, -0.0010};
    for (final double yield2 : yields) {
      final double priceComputed = METHOD_SECURITY.priceFromYield(BILL_IAM_SEC, yield2);
      final double priceExpected = 1.0 / (1 + BILL_IAM_SEC.getAccrualFactor() * yield2);
      assertEquals(
          "Bill Security: discounting method - price",
          priceExpected,
          priceComputed,
          TOLERANCE_PRICE);
    }
  }

  @Test
  public void priceFromYieldExternal() {
    final double priceComputed = METHOD_SECURITY.priceFromYield(BILL_IAM_SEC, YIELD);
    assertEquals(
        "Bill Security: discounting method - price",
        PRICE,
        priceComputed,
        TOLERANCE_PRICE_EXTERNAL);
  }

  @Test
  public void yieldFromPrice() {
    final double yieldComputedIAM = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, PRICE);
    final double yieldExpectedIAM = (1.0 / PRICE - 1.0) / BILL_IAM_SEC.getAccrualFactor();
    assertEquals(
        "Bill Security: discounting method - yield",
        yieldExpectedIAM,
        yieldComputedIAM,
        TOLERANCE_YIELD);
    final double yieldComputedDSC = METHOD_SECURITY.yieldFromPrice(BILL_DSC_SEC, PRICE);
    final double yieldExpectedDSC = (1.0 - PRICE) / BILL_DSC_SEC.getAccrualFactor();
    assertEquals(
        "Bill Security: discounting method - yield",
        yieldExpectedDSC,
        yieldComputedDSC,
        TOLERANCE_YIELD);
  }

  @Test
  public void yieldFromPriceDerivative() {
    final double shift = 1.0E-8;
    final double yieldIAM = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, PRICE);
    final double yieldPIAM = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, PRICE + shift);
    final double yieldDerivativeExpectedIAM = (yieldPIAM - yieldIAM) / shift;
    final double yieldDerivativeComputedIAM =
        METHOD_SECURITY.yieldFromPriceDerivative(BILL_IAM_SEC, PRICE);
    assertEquals(
        "Bill Security: discounting method - yield",
        yieldDerivativeExpectedIAM,
        yieldDerivativeComputedIAM,
        TOLERANCE_YIELD_DERIVATIVE);
    final double yieldDSC = METHOD_SECURITY.yieldFromPrice(BILL_DSC_SEC, PRICE);
    final double yieldPDSC = METHOD_SECURITY.yieldFromPrice(BILL_DSC_SEC, PRICE + shift);
    final double yieldDerivativeExpectedDSC = (yieldPDSC - yieldDSC) / shift;
    final double yieldDerivativeComputedDSC =
        METHOD_SECURITY.yieldFromPriceDerivative(BILL_DSC_SEC, PRICE);
    assertEquals(
        "Bill Security: discounting method - yield",
        yieldDerivativeExpectedDSC,
        yieldDerivativeComputedDSC,
        TOLERANCE_YIELD_DERIVATIVE);
  }

  @Test
  public void yieldFromPriceExternal() {
    final double yieldComputed = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, PRICE);
    assertEquals(
        "Bill Security: discounting method - yield",
        YIELD,
        yieldComputed,
        TOLERANCE_YIELD_EXTERNAL);
  }

  @Test
  public void yieldFromPriceCoherence() {
    final double priceComputed = METHOD_SECURITY.priceFromYield(BILL_IAM_SEC, YIELD);
    final double yieldComputed = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, priceComputed);
    assertEquals(
        "Bill Security: discounting method - yield", YIELD, yieldComputed, TOLERANCE_YIELD);
  }

  @Test
  public void priceFromYieldCoherence() {
    final double yieldComputed = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, PRICE);
    final double priceComputed = METHOD_SECURITY.priceFromYield(BILL_IAM_SEC, yieldComputed);
    assertEquals(
        "Bill Security: discounting method - price", PRICE, priceComputed, TOLERANCE_PRICE);
  }

  @Test
  public void presentValueFromPrice() {
    final CurrencyAmount pvComputed =
        METHOD_SECURITY.presentValueFromPrice(BILL_IAM_SEC, PRICE, CURVE_BUNDLE);
    final double pvExpected =
        NOTIONAL
            * PRICE
            * CURVE_BUNDLE
                .getCurve(NAME_CURVES[0])
                .getDiscountFactor(BILL_IAM_SEC.getSettlementTime());
    assertEquals(
        "Bill Security: discounting method - present value",
        pvExpected,
        pvComputed.getAmount(),
        TOLERANCE_PV);
  }

  @Test
  public void presentValueFromYield() {
    final CurrencyAmount pvComputed =
        METHOD_SECURITY.presentValueFromYield(BILL_IAM_SEC, YIELD, CURVE_BUNDLE);
    final double price = METHOD_SECURITY.priceFromYield(BILL_IAM_SEC, YIELD);
    final double pvExpected =
        NOTIONAL
            * price
            * CURVE_BUNDLE
                .getCurve(NAME_CURVES[0])
                .getDiscountFactor(BILL_IAM_SEC.getSettlementTime());
    assertEquals(
        "Bill Security: discounting method - present value",
        pvExpected,
        pvComputed.getAmount(),
        TOLERANCE_PV);
  }

  @Test
  public void priceFromCurves() {
    final double priceComputed = METHOD_SECURITY.priceFromCurves(BILL_IAM_SEC, CURVE_BUNDLE);
    final CurrencyAmount pvComputed = METHOD_SECURITY.presentValue(BILL_IAM_SEC, CURVE_BUNDLE);
    final double priceExpected =
        pvComputed.getAmount()
            / (NOTIONAL
                * CURVE_BUNDLE
                    .getCurve(NAME_CURVES[0])
                    .getDiscountFactor(BILL_IAM_SEC.getSettlementTime()));
    assertEquals(
        "Bill Security: discounting method - price", priceExpected, priceComputed, TOLERANCE_PRICE);
  }

  @Test
  public void yieldFromCurves() {
    final double yieldComputed = METHOD_SECURITY.yieldFromCurves(BILL_IAM_SEC, CURVE_BUNDLE);
    final double priceComputed = METHOD_SECURITY.priceFromCurves(BILL_IAM_SEC, CURVE_BUNDLE);
    final double yieldExpected = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, priceComputed);
    assertEquals(
        "Bill Security: discounting method - yield", yieldExpected, yieldComputed, TOLERANCE_YIELD);
  }

  @Test
  public void presentValueCurveSensitivity() {
    final InterestRateCurveSensitivity pvcsComputed =
        METHOD_SECURITY.presentValueCurveSensitivity(BILL_IAM_SEC, CURVE_BUNDLE);
    assertEquals(
        "Bill Security: present value curve sensitivity",
        1,
        pvcsComputed.getSensitivities().size());
    assertEquals(
        "Bill Security: present value curve sensitivity",
        1,
        pvcsComputed.getSensitivities().get(NAME_CURVES[1]).size());
    final double deltaTolerancePrice = 1.0E+2;
    // Testing note: Sensitivity is for a movement of 1. 1E+2 = 0.01 unit for a 1 bp move.
    final double deltaShift = 1.0E-6;
    // Credit curve sensitivity
    final String bumpedCurveName = "Bumped Curve";
    final BillSecurity billBumped =
        BILL_IAM_SEC_DEFINITION.toDerivative(REFERENCE_DATE, NAME_CURVES[0], bumpedCurveName);
    final double[] nodeTimes = new double[] {billBumped.getEndTime()};
    final double[] sensi =
        SensitivityFiniteDifference.curveSensitivity(
            billBumped,
            CURVE_BUNDLE,
            NAME_CURVES[1],
            bumpedCurveName,
            nodeTimes,
            deltaShift,
            METHOD_SECURITY);
    final List<DoublesPair> sensiPv = pvcsComputed.getSensitivities().get(NAME_CURVES[1]);
    for (int loopnode = 0; loopnode < sensi.length; loopnode++) {
      final DoublesPair pairPv = sensiPv.get(loopnode);
      assertEquals(
          "Bill Security: curve sensitivity - Node " + loopnode,
          nodeTimes[loopnode],
          pairPv.getFirst(),
          1E-8);
      AssertJUnit.assertEquals(
          "Bill Security: curve sensitivity", pairPv.second, sensi[loopnode], deltaTolerancePrice);
    }
  }

  @Test
  public void presentValueCurveSensitivityMethodVsCalculator() {
    final InterestRateCurveSensitivity pvcsMethod =
        METHOD_SECURITY.presentValueCurveSensitivity(BILL_IAM_SEC, CURVE_BUNDLE);
    final InterestRateCurveSensitivity pvcsCalculator =
        new InterestRateCurveSensitivity(BILL_IAM_SEC.accept(PVCSC, CURVE_BUNDLE));
    AssertSensivityObjects.assertEquals(
        "Bill Security: discounting method - curve sensitivity",
        pvcsMethod,
        pvcsCalculator,
        TOLERANCE_PV);
  }

  @Test
  public void methodVsCalculator() {
    double yield1 = METHOD_SECURITY.yieldFromCurves(BILL_IAM_SEC, CURVE_BUNDLE);
    double yield2 = BILL_IAM_SEC.accept(YFCC, CURVE_BUNDLE);
    assertEquals(
        "Bill Security: discounting method - yield from curves", yield1, yield2, TOLERANCE_YIELD);
    yield1 = METHOD_SECURITY.yieldFromPrice(BILL_IAM_SEC, PRICE);
    yield2 = BILL_IAM_SEC.accept(YFPC, PRICE);
    assertEquals(
        "Bill Security: discounting method - yield from price", yield1, yield2, TOLERANCE_YIELD);
  }
}
Ejemplo n.º 4
0
/** Tests related to the construction of bills transaction. */
public class BillTransactionTest {

  private static final Currency EUR = Currency.EUR;
  private static final Calendar CALENDAR = new MondayToFridayCalendar("TARGET");
  private static final ZonedDateTime REFERENCE_DATE = DateUtils.getUTCDate(2012, 1, 16);

  private static final DayCount ACT360 = DayCountFactory.INSTANCE.getDayCount("Actual/360");
  private static final int SETTLEMENT_DAYS = 2;
  private static final YieldConvention YIELD_CONVENTION =
      YieldConventionFactory.INSTANCE.getYieldConvention("INTEREST@MTY");

  private static final String ISSUER_BEL = "BELGIUM GOVT";
  private static final ZonedDateTime END_DATE = DateUtils.getUTCDate(2012, 2, 29);
  private static final double NOTIONAL = 1000;
  private static final BillSecurityDefinition BILL_SEC_DEFINITION =
      new BillSecurityDefinition(
          EUR, END_DATE, NOTIONAL, SETTLEMENT_DAYS, CALENDAR, YIELD_CONVENTION, ACT360, ISSUER_BEL);

  private static final double QUANTITY = 123456;
  private static final ZonedDateTime SETTLE_DATE =
      ScheduleCalculator.getAdjustedDate(REFERENCE_DATE, 3, CALENDAR);
  private static final double SETTLE_AMOUT = -NOTIONAL * QUANTITY * 99.95;

  private static final String DSC_NAME = "EUR Discounting";
  private static final String CREDIT_NAME = "EUR BELGIUM GOVT";

  private static final BillSecurity BILL_PURCHASE =
      BILL_SEC_DEFINITION.toDerivative(REFERENCE_DATE, SETTLE_DATE, DSC_NAME, CREDIT_NAME);
  private static final BillSecurity BILL_STANDARD =
      BILL_SEC_DEFINITION.toDerivative(REFERENCE_DATE, DSC_NAME, CREDIT_NAME);
  private static final BillTransaction BILL_TRA =
      new BillTransaction(BILL_PURCHASE, QUANTITY, SETTLE_AMOUT, BILL_STANDARD);

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void nullPurchase() {
    new BillTransaction(null, QUANTITY, SETTLE_AMOUT, BILL_STANDARD);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void nullStandard() {
    new BillTransaction(BILL_PURCHASE, QUANTITY, SETTLE_AMOUT, null);
  }

  @Test
  /** Tests the bill getters. */
  public void getters() {
    assertEquals("Bill transation: getter", BILL_PURCHASE, BILL_TRA.getBillPurchased());
    assertEquals("Bill transation: getter", QUANTITY, BILL_TRA.getQuantity());
    assertEquals("Bill transation: getter", SETTLE_AMOUT, BILL_TRA.getSettlementAmount());
    assertEquals("Bill transation: getter", BILL_STANDARD, BILL_TRA.getBillStandard());
  }

  @Test
  /** Tests the equal and hash-code methods. */
  public void equalHash() {
    assertEquals("Bill transaction: equal-hash code", BILL_TRA, BILL_TRA);
    BillTransaction other =
        new BillTransaction(BILL_PURCHASE, QUANTITY, SETTLE_AMOUT, BILL_STANDARD);
    assertEquals("Bill transaction: equal-hash code", BILL_TRA, other);
    assertEquals("Bill transaction: equal-hash code", BILL_TRA.hashCode(), other.hashCode());
    BillTransaction modified;
    modified = new BillTransaction(BILL_STANDARD, QUANTITY, SETTLE_AMOUT, BILL_STANDARD);
    assertFalse("Bill transaction: equal-hash code", BILL_TRA.equals(modified));
    modified = new BillTransaction(BILL_PURCHASE, QUANTITY + 1.0, SETTLE_AMOUT, BILL_STANDARD);
    assertFalse("Bill transaction: equal-hash code", BILL_TRA.equals(modified));
    modified = new BillTransaction(BILL_PURCHASE, QUANTITY, SETTLE_AMOUT + 1.0, BILL_STANDARD);
    assertFalse("Bill transaction: equal-hash code", BILL_TRA.equals(modified));
    modified = new BillTransaction(BILL_PURCHASE, QUANTITY, SETTLE_AMOUT, BILL_PURCHASE);
    assertFalse("Bill transaction: equal-hash code", BILL_TRA.equals(modified));
  }
}