Example usage for java.math BigDecimal valueOf

Introduction

In this page you can find the example usage for java.math BigDecimal valueOf.

Prototype

public static BigDecimal valueOf(double val) 

Source Link

Document

Translates a double into a BigDecimal , using the double 's canonical string representation provided by the Double#toString(double) method.

Usage

From source file:net.ceos.project.poi.annotated.core.CellHandler.java

/**
 * Read a big decimal value from the Cell.
 * /*w ww .java2s .  co m*/
 * @param object
 *            the object
 * @param field
 *            the {@link Field} to set
 * @param cell
 *            the {@link Cell} to read
 * @param xlsAnnotation
 *            the {@link XlsElement} element
 * @throws ConverterException
 *             the conversion exception type
 */
protected static void bigDecimalReader(final Object object, final Field field, final Cell cell,
        final XlsElement xlsAnnotation) throws ConverterException {
    if (StringUtils.isNotBlank(readCell(cell))) {
        try {
            if (StringUtils.isNotBlank(xlsAnnotation.transformMask())) {
                field.set(object, BigDecimal
                        .valueOf(Double.valueOf(readCell(cell).replace(Constants.COMMA, Constants.DOT))));
            } else {
                field.set(object, BigDecimal.valueOf(Double.valueOf(readCell(cell))));
            }
        } catch (IllegalArgumentException | IllegalAccessException e) {
            throw new ConverterException(ExceptionMessage.CONVERTER_BIGDECIMAL.getMessage(), e);
        }
    }
}

---

From source file:org.impotch.calcul.impot.cantonal.ge.pp.avant2010.BaremeRevenuSeul1995Test.java

@Test
public void seul() {
    TypeArrondi arrond = TypeArrondi.CINQ_CTS;
    assertThat(bareme.calcul(BigDecimal.valueOf(1000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("12.488")));
    assertThat(bareme.calcul(BigDecimal.valueOf(2000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("43.422")));
    assertThat(bareme.calcul(BigDecimal.valueOf(3000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("89.986")));
    assertThat(bareme.calcul(BigDecimal.valueOf(4000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("149.804")));
    assertThat(bareme.calcul(BigDecimal.valueOf(5000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("220.867")));
    assertThat(bareme.calcul(BigDecimal.valueOf(6000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("301.482")));
    assertThat(bareme.calcul(BigDecimal.valueOf(7000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("390.217")));
    assertThat(bareme.calcul(BigDecimal.valueOf(8000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("485.865")));
    assertThat(bareme.calcul(BigDecimal.valueOf(9000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("587.405")));
    assertThat(bareme.calcul(BigDecimal.valueOf(10000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("693.977")));
    assertThat(bareme.calcul(BigDecimal.valueOf(11000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("804.852")));
    assertThat(bareme.calcul(BigDecimal.valueOf(12000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("919.417")));
    assertThat(bareme.calcul(BigDecimal.valueOf(13000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1037.152")));
    assertThat(bareme.calcul(BigDecimal.valueOf(14000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1157.619")));
    assertThat(bareme.calcul(BigDecimal.valueOf(15000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1280.448")));
    assertThat(bareme.calcul(BigDecimal.valueOf(16000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1405.325")));
    assertThat(bareme.calcul(BigDecimal.valueOf(17000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1531.987")));
    assertThat(bareme.calcul(BigDecimal.valueOf(18000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1660.208")));
    assertThat(bareme.calcul(BigDecimal.valueOf(19000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1789.801")));
    assertThat(bareme.calcul(BigDecimal.valueOf(20000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("1920.605")));
    assertThat(bareme.calcul(BigDecimal.valueOf(21000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("2052.484")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(22000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("2185.325")));
    assertThat(bareme.calcul(BigDecimal.valueOf(23000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("2319.029")));
    assertThat(bareme.calcul(BigDecimal.valueOf(24000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("2453.514")));
    assertThat(bareme.calcul(BigDecimal.valueOf(25000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("2588.712")));
    assertThat(bareme.calcul(BigDecimal.valueOf(26000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("2724.561")));
    assertThat(bareme.calcul(BigDecimal.valueOf(27000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("2861.013")));
    assertThat(bareme.calcul(BigDecimal.valueOf(28000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("2998.023")));
    assertThat(bareme.calcul(BigDecimal.valueOf(29000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("3135.556")));
    assertThat(bareme.calcul(BigDecimal.valueOf(30000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("3273.581")));
    assertThat(bareme.calcul(BigDecimal.valueOf(31000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("3412.070")));
    assertThat(bareme.calcul(BigDecimal.valueOf(32000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("3551.001")));
    assertThat(bareme.calcul(BigDecimal.valueOf(33000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("3690.355")));
    assertThat(bareme.calcul(BigDecimal.valueOf(34000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("3830.114")));
    assertThat(bareme.calcul(BigDecimal.valueOf(35000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("3970.264")));
    assertThat(bareme.calcul(BigDecimal.valueOf(36000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("4110.792")));
    assertThat(bareme.calcul(BigDecimal.valueOf(37000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("4251.688")));
    assertThat(bareme.calcul(BigDecimal.valueOf(38000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("4392.942")));
    assertThat(bareme.calcul(BigDecimal.valueOf(39000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("4534.545")));
    assertThat(bareme.calcul(BigDecimal.valueOf(40000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("4676.491")));
    assertThat(bareme.calcul(BigDecimal.valueOf(41000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("4818.772")));
    assertThat(bareme.calcul(BigDecimal.valueOf(42000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("4961.382")));
    assertThat(bareme.calcul(BigDecimal.valueOf(43000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("5104.318")));
    assertThat(bareme.calcul(BigDecimal.valueOf(44000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("5247.573")));
    assertThat(bareme.calcul(BigDecimal.valueOf(45000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("5391.144")));
    assertThat(bareme.calcul(BigDecimal.valueOf(46000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("5535.027")));
    assertThat(bareme.calcul(BigDecimal.valueOf(47000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("5679.217")));
    assertThat(bareme.calcul(BigDecimal.valueOf(48000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("5823.713")));
    assertThat(bareme.calcul(BigDecimal.valueOf(49000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("5968.510")));
    assertThat(bareme.calcul(BigDecimal.valueOf(50000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("6113.606")));
    assertThat(bareme.calcul(BigDecimal.valueOf(51000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("6258.998")));
    assertThat(bareme.calcul(BigDecimal.valueOf(52000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("6404.684")));
    assertThat(bareme.calcul(BigDecimal.valueOf(53000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("6550.660")));
    assertThat(bareme.calcul(BigDecimal.valueOf(54000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("6696.925")));
    assertThat(bareme.calcul(BigDecimal.valueOf(55000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("6843.477")));
    assertThat(bareme.calcul(BigDecimal.valueOf(56000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("6990.312")));
    assertThat(bareme.calcul(BigDecimal.valueOf(57000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("7137.430")));
    assertThat(bareme.calcul(BigDecimal.valueOf(58000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("7284.827")));
    assertThat(bareme.calcul(BigDecimal.valueOf(59000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("7432.502")));
    assertThat(bareme.calcul(BigDecimal.valueOf(60000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("7580.454")));
    assertThat(bareme.calcul(BigDecimal.valueOf(61000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("7728.679")));
    assertThat(bareme.calcul(BigDecimal.valueOf(62000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("7877.176")));
    assertThat(bareme.calcul(BigDecimal.valueOf(63000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("8025.943")));
    assertThat(bareme.calcul(BigDecimal.valueOf(64000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("8174.979")));
    assertThat(bareme.calcul(BigDecimal.valueOf(65000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("8324.281")));
    assertThat(bareme.calcul(BigDecimal.valueOf(66000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("8473.848")));
    assertThat(bareme.calcul(BigDecimal.valueOf(67000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("8623.678")));
    assertThat(bareme.calcul(BigDecimal.valueOf(68000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("8773.769")));
    assertThat(bareme.calcul(BigDecimal.valueOf(69000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("8924.119")));
    assertThat(bareme.calcul(BigDecimal.valueOf(70000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("9074.727")));
    assertThat(bareme.calcul(BigDecimal.valueOf(71000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("9225.592")));
    assertThat(bareme.calcul(BigDecimal.valueOf(72000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("9376.710")));
    assertThat(bareme.calcul(BigDecimal.valueOf(73000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("9528.081")));
    assertThat(bareme.calcul(BigDecimal.valueOf(74000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("9679.703")));
    assertThat(bareme.calcul(BigDecimal.valueOf(75000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("9831.574")));
    assertThat(bareme.calcul(BigDecimal.valueOf(76000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("9983.693")));
    assertThat(bareme.calcul(BigDecimal.valueOf(77000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("10136.059")));
    assertThat(bareme.calcul(BigDecimal.valueOf(78000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("10288.668")));
    assertThat(bareme.calcul(BigDecimal.valueOf(79000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("10441.521")));
    assertThat(bareme.calcul(BigDecimal.valueOf(80000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("10594.614")));
    assertThat(bareme.calcul(BigDecimal.valueOf(81000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("10747.948")));
    assertThat(bareme.calcul(BigDecimal.valueOf(82000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("10901.519")));
    assertThat(bareme.calcul(BigDecimal.valueOf(83000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("11055.327")));
    assertThat(bareme.calcul(BigDecimal.valueOf(84000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("11209.370")));
    assertThat(bareme.calcul(BigDecimal.valueOf(85000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("11363.647")));
    assertThat(bareme.calcul(BigDecimal.valueOf(86000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("11518.156")));
    assertThat(bareme.calcul(BigDecimal.valueOf(87000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("11672.895")));
    assertThat(bareme.calcul(BigDecimal.valueOf(88000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("11827.863")));
    assertThat(bareme.calcul(BigDecimal.valueOf(89000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("11983.058")));
    assertThat(bareme.calcul(BigDecimal.valueOf(90000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("12138.480")));
    assertThat(bareme.calcul(BigDecimal.valueOf(91000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("12294.126")));
    assertThat(bareme.calcul(BigDecimal.valueOf(92000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("12449.995")));
    assertThat(bareme.calcul(BigDecimal.valueOf(93000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("12606.085")));
    assertThat(bareme.calcul(BigDecimal.valueOf(94000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("12762.396")));
    assertThat(bareme.calcul(BigDecimal.valueOf(95000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("12918.926")));
    assertThat(bareme.calcul(BigDecimal.valueOf(96000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("13075.672")));
    assertThat(bareme.calcul(BigDecimal.valueOf(97000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("13232.635")));
    assertThat(bareme.calcul(BigDecimal.valueOf(98000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("13389.812")));
    assertThat(bareme.calcul(BigDecimal.valueOf(99000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("13547.203")));
    assertThat(bareme.calcul(BigDecimal.valueOf(100000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("13704.804")));
    assertThat(bareme.calcul(BigDecimal.valueOf(101000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("13862.617")));
    assertThat(bareme.calcul(BigDecimal.valueOf(102000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("14020.638")));
    assertThat(bareme.calcul(BigDecimal.valueOf(103000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("14178.867")));
    assertThat(bareme.calcul(BigDecimal.valueOf(104000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("14337.302")));
    assertThat(bareme.calcul(BigDecimal.valueOf(105000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("14495.942")));
    assertThat(bareme.calcul(BigDecimal.valueOf(106000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("14654.785")));
    assertThat(bareme.calcul(BigDecimal.valueOf(107000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("14813.831")));
    assertThat(bareme.calcul(BigDecimal.valueOf(108000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("14973.077")));
    assertThat(bareme.calcul(BigDecimal.valueOf(109000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("15132.524")));
    assertThat(bareme.calcul(BigDecimal.valueOf(110000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("15292.168")));
    assertThat(bareme.calcul(BigDecimal.valueOf(111000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("15452.010")));
    assertThat(bareme.calcul(BigDecimal.valueOf(112000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("15612.047")));
    assertThat(bareme.calcul(BigDecimal.valueOf(113000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("15772.279")));
    assertThat(bareme.calcul(BigDecimal.valueOf(114000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("15932.704")));
    assertThat(bareme.calcul(BigDecimal.valueOf(115000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("16093.321")));
    assertThat(bareme.calcul(BigDecimal.valueOf(116000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("16254.128")));
    assertThat(bareme.calcul(BigDecimal.valueOf(117000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("16415.125")));
    assertThat(bareme.calcul(BigDecimal.valueOf(118000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("16576.310")));
    assertThat(bareme.calcul(BigDecimal.valueOf(119000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("16737.683")));
    assertThat(bareme.calcul(BigDecimal.valueOf(120000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("16899.240")));
    assertThat(bareme.calcul(BigDecimal.valueOf(121000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("17060.983")));
    assertThat(bareme.calcul(BigDecimal.valueOf(122000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("17222.909")));
    assertThat(bareme.calcul(BigDecimal.valueOf(123000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("17385.017")));
    assertThat(bareme.calcul(BigDecimal.valueOf(124000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("17547.306")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(125000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("17709.775")));
    assertThat(bareme.calcul(BigDecimal.valueOf(126000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("17872.422")));
    assertThat(bareme.calcul(BigDecimal.valueOf(127000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("18035.247")));
    assertThat(bareme.calcul(BigDecimal.valueOf(128000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("18198.249")));
    assertThat(bareme.calcul(BigDecimal.valueOf(129000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("18361.425")));
    assertThat(bareme.calcul(BigDecimal.valueOf(130000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("18524.776")));
    assertThat(bareme.calcul(BigDecimal.valueOf(131000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("18688.299")));
    assertThat(bareme.calcul(BigDecimal.valueOf(132000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("18851.994")));
    assertThat(bareme.calcul(BigDecimal.valueOf(133000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("19015.860")));
    assertThat(bareme.calcul(BigDecimal.valueOf(134000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("19179.896")));
    assertThat(bareme.calcul(BigDecimal.valueOf(135000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("19344.099")));
    assertThat(bareme.calcul(BigDecimal.valueOf(136000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("19508.471")));
    assertThat(bareme.calcul(BigDecimal.valueOf(137000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("19673.008")));
    assertThat(bareme.calcul(BigDecimal.valueOf(138000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("19837.711")));
    assertThat(bareme.calcul(BigDecimal.valueOf(139000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("20002.577")));
    assertThat(bareme.calcul(BigDecimal.valueOf(140000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("20167.607")));
    assertThat(bareme.calcul(BigDecimal.valueOf(141000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("20332.799")));
    assertThat(bareme.calcul(BigDecimal.valueOf(142000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("20498.151")));
    assertThat(bareme.calcul(BigDecimal.valueOf(143000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("20663.664")));
    assertThat(bareme.calcul(BigDecimal.valueOf(144000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("20829.335")));
    assertThat(bareme.calcul(BigDecimal.valueOf(145000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("20995.165")));
    assertThat(bareme.calcul(BigDecimal.valueOf(146000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("21161.150")));
    assertThat(bareme.calcul(BigDecimal.valueOf(147000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("21327.292")));
    assertThat(bareme.calcul(BigDecimal.valueOf(148000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("21493.589")));
    assertThat(bareme.calcul(BigDecimal.valueOf(149000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("21660.039")));
    assertThat(bareme.calcul(BigDecimal.valueOf(150000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("21826.642")));
    assertThat(bareme.calcul(BigDecimal.valueOf(151000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("21993.396")));
    assertThat(bareme.calcul(BigDecimal.valueOf(152000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("22160.302")));
    assertThat(bareme.calcul(BigDecimal.valueOf(153000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("22327.357")));
    assertThat(bareme.calcul(BigDecimal.valueOf(154000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("22494.561")));
    assertThat(bareme.calcul(BigDecimal.valueOf(155000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("22661.913")));
    assertThat(bareme.calcul(BigDecimal.valueOf(156000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("22829.411")));
    assertThat(bareme.calcul(BigDecimal.valueOf(157000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("22997.056")));
    assertThat(bareme.calcul(BigDecimal.valueOf(158000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("23164.846")));
    assertThat(bareme.calcul(BigDecimal.valueOf(159000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("23332.779")));
    assertThat(bareme.calcul(BigDecimal.valueOf(160000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("23500.856")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(161000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("23669.075")));
    assertThat(bareme.calcul(BigDecimal.valueOf(162000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("23837.435")));
    assertThat(bareme.calcul(BigDecimal.valueOf(163000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("24005.935")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(164000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("24174.575")));
    assertThat(bareme.calcul(BigDecimal.valueOf(165000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("24343.353")));
    assertThat(bareme.calcul(BigDecimal.valueOf(166000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("24512.269")));
    assertThat(bareme.calcul(BigDecimal.valueOf(167000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("24681.322")));
    assertThat(bareme.calcul(BigDecimal.valueOf(168000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("24850.510")));
    assertThat(bareme.calcul(BigDecimal.valueOf(169000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("25019.833")));
    assertThat(bareme.calcul(BigDecimal.valueOf(170000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("25189.291")));
    assertThat(bareme.calcul(BigDecimal.valueOf(171000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("25358.881")));
    assertThat(bareme.calcul(BigDecimal.valueOf(172000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("25528.604")));
    assertThat(bareme.calcul(BigDecimal.valueOf(173000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("25698.459")));
    assertThat(bareme.calcul(BigDecimal.valueOf(174000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("25868.444")));
    assertThat(bareme.calcul(BigDecimal.valueOf(175000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("26038.558")));
    assertThat(bareme.calcul(BigDecimal.valueOf(176000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("26208.802")));
    assertThat(bareme.calcul(BigDecimal.valueOf(177000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("26379.173")));
    assertThat(bareme.calcul(BigDecimal.valueOf(178000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("26549.672")));
    assertThat(bareme.calcul(BigDecimal.valueOf(179000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("26720.298")));
    assertThat(bareme.calcul(BigDecimal.valueOf(180000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("26891.049")));
    assertThat(bareme.calcul(BigDecimal.valueOf(181000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("27061.924")));
    assertThat(bareme.calcul(BigDecimal.valueOf(182000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("27232.924")));
    assertThat(bareme.calcul(BigDecimal.valueOf(183000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("27404.047")));
    assertThat(bareme.calcul(BigDecimal.valueOf(184000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("27575.292")));
    assertThat(bareme.calcul(BigDecimal.valueOf(185000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("27746.658")));
    assertThat(bareme.calcul(BigDecimal.valueOf(186000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("27918.146")));
    assertThat(bareme.calcul(BigDecimal.valueOf(187000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("28089.753")));
    assertThat(bareme.calcul(BigDecimal.valueOf(188000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("28261.480")));
    assertThat(bareme.calcul(BigDecimal.valueOf(189000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("28433.325")));
    assertThat(bareme.calcul(BigDecimal.valueOf(190000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("28605.288")));
    assertThat(bareme.calcul(BigDecimal.valueOf(191000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("28777.367")));
    assertThat(bareme.calcul(BigDecimal.valueOf(192000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("28949.563")));
    assertThat(bareme.calcul(BigDecimal.valueOf(193000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("29121.874")));
    assertThat(bareme.calcul(BigDecimal.valueOf(194000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("29294.300")));
    assertThat(bareme.calcul(BigDecimal.valueOf(195000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("29466.840")));
    assertThat(bareme.calcul(BigDecimal.valueOf(196000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("29639.493")));
    assertThat(bareme.calcul(BigDecimal.valueOf(197000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("29812.258")));
    assertThat(bareme.calcul(BigDecimal.valueOf(198000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("29985.135")));
    assertThat(bareme.calcul(BigDecimal.valueOf(199000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("30158.122")));
    assertThat(bareme.calcul(BigDecimal.valueOf(200000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("30331.221")));
    assertThat(bareme.calcul(BigDecimal.valueOf(201000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("30504.428")));
    assertThat(bareme.calcul(BigDecimal.valueOf(202000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("30677.745")));
    assertThat(bareme.calcul(BigDecimal.valueOf(203000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("30851.169")));
    assertThat(bareme.calcul(BigDecimal.valueOf(204000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("31024.701")));
    assertThat(bareme.calcul(BigDecimal.valueOf(205000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("31198.340")));
    assertThat(bareme.calcul(BigDecimal.valueOf(206000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("31372.084")));
    assertThat(bareme.calcul(BigDecimal.valueOf(207000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("31545.934")));
    assertThat(bareme.calcul(BigDecimal.valueOf(208000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("31719.889")));
    assertThat(bareme.calcul(BigDecimal.valueOf(209000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("31893.947")));
    assertThat(bareme.calcul(BigDecimal.valueOf(210000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("32068.109")));
    assertThat(bareme.calcul(BigDecimal.valueOf(211000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("32242.373")));
    assertThat(bareme.calcul(BigDecimal.valueOf(212000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("32416.740")));
    assertThat(bareme.calcul(BigDecimal.valueOf(213000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("32591.207")));
    assertThat(bareme.calcul(BigDecimal.valueOf(214000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("32765.775")));
    assertThat(bareme.calcul(BigDecimal.valueOf(215000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("32940.444")));
    assertThat(bareme.calcul(BigDecimal.valueOf(216000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("33115.211")));
    assertThat(bareme.calcul(BigDecimal.valueOf(217000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("33290.077")));
    assertThat(bareme.calcul(BigDecimal.valueOf(218000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("33465.041")));
    assertThat(bareme.calcul(BigDecimal.valueOf(219000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("33640.103")));
    assertThat(bareme.calcul(BigDecimal.valueOf(220000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("33815.261")));
    assertThat(bareme.calcul(BigDecimal.valueOf(221000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("33990.516")));
    assertThat(bareme.calcul(BigDecimal.valueOf(222000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("34165.866")));
    assertThat(bareme.calcul(BigDecimal.valueOf(223000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("34341.311")));
    assertThat(bareme.calcul(BigDecimal.valueOf(224000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("34516.850")));
    assertThat(bareme.calcul(BigDecimal.valueOf(225000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("34692.483")));
    assertThat(bareme.calcul(BigDecimal.valueOf(226000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("34868.208")));
    assertThat(bareme.calcul(BigDecimal.valueOf(227000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("35044.027")));
    assertThat(bareme.calcul(BigDecimal.valueOf(228000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("35219.937")));
    assertThat(bareme.calcul(BigDecimal.valueOf(229000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("35395.938")));
    assertThat(bareme.calcul(BigDecimal.valueOf(230000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("35572.030")));
    assertThat(bareme.calcul(BigDecimal.valueOf(231000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("35748.212")));
    assertThat(bareme.calcul(BigDecimal.valueOf(232000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("35924.484")));
    assertThat(bareme.calcul(BigDecimal.valueOf(233000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("36100.845")));
    assertThat(bareme.calcul(BigDecimal.valueOf(234000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("36277.293")));
    assertThat(bareme.calcul(BigDecimal.valueOf(235000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("36453.830")));
    assertThat(bareme.calcul(BigDecimal.valueOf(236000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("36630.454")));
    assertThat(bareme.calcul(BigDecimal.valueOf(237000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("36807.164")));
    assertThat(bareme.calcul(BigDecimal.valueOf(238000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("36983.960")));
    assertThat(bareme.calcul(BigDecimal.valueOf(239000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("37160.842")));
    assertThat(bareme.calcul(BigDecimal.valueOf(240000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("37337.809")));
    assertThat(bareme.calcul(BigDecimal.valueOf(241000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("37514.860")));
    assertThat(bareme.calcul(BigDecimal.valueOf(242000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("37691.995")));
    assertThat(bareme.calcul(BigDecimal.valueOf(243000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("37869.214")));
    assertThat(bareme.calcul(BigDecimal.valueOf(244000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("38046.515")));
    assertThat(bareme.calcul(BigDecimal.valueOf(245000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("38223.898")));
    assertThat(bareme.calcul(BigDecimal.valueOf(246000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("38401.363")));
    assertThat(bareme.calcul(BigDecimal.valueOf(247000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("38578.909")));
    assertThat(bareme.calcul(BigDecimal.valueOf(248000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("38756.536")));
    assertThat(bareme.calcul(BigDecimal.valueOf(249000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("38934.243")));
    assertThat(bareme.calcul(BigDecimal.valueOf(250000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("39112.030")));
    assertThat(bareme.calcul(BigDecimal.valueOf(251000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("39289.895")));
    assertThat(bareme.calcul(BigDecimal.valueOf(252000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("39467.839")));
    assertThat(bareme.calcul(BigDecimal.valueOf(253000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("39645.861")));
    assertThat(bareme.calcul(BigDecimal.valueOf(254000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("39823.961")));
    assertThat(bareme.calcul(BigDecimal.valueOf(255000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("40002.138")));
    assertThat(bareme.calcul(BigDecimal.valueOf(256000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("40180.391")));
    assertThat(bareme.calcul(BigDecimal.valueOf(257000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("40358.720")));
    assertThat(bareme.calcul(BigDecimal.valueOf(258000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("40537.125")));
    assertThat(bareme.calcul(BigDecimal.valueOf(259000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("40715.605")));
    assertThat(bareme.calcul(BigDecimal.valueOf(260000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("40894.159")));
    assertThat(bareme.calcul(BigDecimal.valueOf(261000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("41072.788")));
    assertThat(bareme.calcul(BigDecimal.valueOf(262000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("41251.490")));
    assertThat(bareme.calcul(BigDecimal.valueOf(263000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("41430.265")));
    assertThat(bareme.calcul(BigDecimal.valueOf(264000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("41609.113")));
    assertThat(bareme.calcul(BigDecimal.valueOf(265000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("41788.033")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(266000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("41967.025")));
    assertThat(bareme.calcul(BigDecimal.valueOf(267000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("42146.088")));
    assertThat(bareme.calcul(BigDecimal.valueOf(268000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("42325.222")));
    assertThat(bareme.calcul(BigDecimal.valueOf(269000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("42504.426")));
    assertThat(bareme.calcul(BigDecimal.valueOf(270000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("42683.700")));
    assertThat(bareme.calcul(BigDecimal.valueOf(271000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("42863.043")));
    assertThat(bareme.calcul(BigDecimal.valueOf(272000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("43042.455")));
    assertThat(bareme.calcul(BigDecimal.valueOf(273000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("43221.936")));
    assertThat(bareme.calcul(BigDecimal.valueOf(274000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("43401.485")));
    assertThat(bareme.calcul(BigDecimal.valueOf(275000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("43581.102")));
    assertThat(bareme.calcul(BigDecimal.valueOf(276000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("43760.785")));
    assertThat(bareme.calcul(BigDecimal.valueOf(277000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("43940.536")));
    assertThat(bareme.calcul(BigDecimal.valueOf(278000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("44120.353")));
    assertThat(bareme.calcul(BigDecimal.valueOf(279000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("44300.235")));
    assertThat(bareme.calcul(BigDecimal.valueOf(280000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("44480.183")));
    assertThat(bareme.calcul(BigDecimal.valueOf(281000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("44660.197")));
    assertThat(bareme.calcul(BigDecimal.valueOf(282000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("44840.274")));
    assertThat(bareme.calcul(BigDecimal.valueOf(283000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("45020.416")));
    assertThat(bareme.calcul(BigDecimal.valueOf(284000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("45200.622")));
    assertThat(bareme.calcul(BigDecimal.valueOf(285000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("45380.891")));
    assertThat(bareme.calcul(BigDecimal.valueOf(286000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("45561.223")));
    assertThat(bareme.calcul(BigDecimal.valueOf(287000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("45741.618")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(288000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("45922.075")));
    assertThat(bareme.calcul(BigDecimal.valueOf(289000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("46102.593")));
    assertThat(bareme.calcul(BigDecimal.valueOf(290000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("46283.173")));
    assertThat(bareme.calcul(BigDecimal.valueOf(291000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("46463.814")));
    assertThat(bareme.calcul(BigDecimal.valueOf(292000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("46644.515")));
    assertThat(bareme.calcul(BigDecimal.valueOf(293000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("46825.277")));
    assertThat(bareme.calcul(BigDecimal.valueOf(294000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("47006.098")));
    assertThat(bareme.calcul(BigDecimal.valueOf(295000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("47186.978")));
    assertThat(bareme.calcul(BigDecimal.valueOf(296000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("47367.918")));
    assertThat(bareme.calcul(BigDecimal.valueOf(297000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("47548.916")));
    assertThat(bareme.calcul(BigDecimal.valueOf(298000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("47729.972")));
    assertThat(bareme.calcul(BigDecimal.valueOf(299000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("47911.087")));
    assertThat(bareme.calcul(BigDecimal.valueOf(300000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("48092.258")));
    assertThat(bareme.calcul(BigDecimal.valueOf(301000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("48273.487")));
    assertThat(bareme.calcul(BigDecimal.valueOf(302000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("48454.773")));
    assertThat(bareme.calcul(BigDecimal.valueOf(303000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("48636.115")));
    assertThat(bareme.calcul(BigDecimal.valueOf(304000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("48817.513")));
    assertThat(bareme.calcul(BigDecimal.valueOf(305000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("48998.966")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(306000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("49180.475")));
    assertThat(bareme.calcul(BigDecimal.valueOf(307000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("49362.039")));
    assertThat(bareme.calcul(BigDecimal.valueOf(308000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("49543.657")));
    assertThat(bareme.calcul(BigDecimal.valueOf(309000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("49725.329")));
    assertThat(bareme.calcul(BigDecimal.valueOf(310000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("49907.056")));
    assertThat(bareme.calcul(BigDecimal.valueOf(311000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("50088.835")));
    assertThat(bareme.calcul(BigDecimal.valueOf(312000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("50270.668")));
    assertThat(bareme.calcul(BigDecimal.valueOf(313000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("50452.554")));
    assertThat(bareme.calcul(BigDecimal.valueOf(314000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("50634.492")));
    assertThat(bareme.calcul(BigDecimal.valueOf(315000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("50816.483")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(316000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("50998.525")));
    assertThat(bareme.calcul(BigDecimal.valueOf(317000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("51180.618")));
    assertThat(bareme.calcul(BigDecimal.valueOf(318000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("51362.763")));
    assertThat(bareme.calcul(BigDecimal.valueOf(319000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("51544.959")));
    assertThat(bareme.calcul(BigDecimal.valueOf(320000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("51727.205")));
    assertThat(bareme.calcul(BigDecimal.valueOf(321000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("51909.501")));
    assertThat(bareme.calcul(BigDecimal.valueOf(322000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("52091.847")));
    assertThat(bareme.calcul(BigDecimal.valueOf(323000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("52274.242")));
    assertThat(bareme.calcul(BigDecimal.valueOf(324000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("52456.687")));
    assertThat(bareme.calcul(BigDecimal.valueOf(325000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("52639.180")));
    assertThat(bareme.calcul(BigDecimal.valueOf(326000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("52821.722")));
    assertThat(bareme.calcul(BigDecimal.valueOf(327000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("53004.312")));
    assertThat(bareme.calcul(BigDecimal.valueOf(328000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("53186.950")));
    assertThat(bareme.calcul(BigDecimal.valueOf(329000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("53369.636")));
    assertThat(bareme.calcul(BigDecimal.valueOf(330000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("53552.369")));
    assertThat(bareme.calcul(BigDecimal.valueOf(331000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("53735.149")));
    assertThat(bareme.calcul(BigDecimal.valueOf(332000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("53917.975")));
    assertThat(bareme.calcul(BigDecimal.valueOf(333000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("54100.848")));
    assertThat(bareme.calcul(BigDecimal.valueOf(334000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("54283.767")));
    assertThat(bareme.calcul(BigDecimal.valueOf(335000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("54466.732")));
    assertThat(bareme.calcul(BigDecimal.valueOf(336000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("54649.742")));
    assertThat(bareme.calcul(BigDecimal.valueOf(337000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("54832.797")));
    assertThat(bareme.calcul(BigDecimal.valueOf(338000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("55015.898")));
    assertThat(bareme.calcul(BigDecimal.valueOf(339000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("55199.043")));
    assertThat(bareme.calcul(BigDecimal.valueOf(340000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("55382.232")));
    assertThat(bareme.calcul(BigDecimal.valueOf(341000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("55565.465")));
    assertThat(bareme.calcul(BigDecimal.valueOf(342000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("55748.742")));
    assertThat(bareme.calcul(BigDecimal.valueOf(343000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("55932.062")));
    assertThat(bareme.calcul(BigDecimal.valueOf(344000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("56115.426")));
    assertThat(bareme.calcul(BigDecimal.valueOf(345000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("56298.832")));
    assertThat(bareme.calcul(BigDecimal.valueOf(346000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("56482.281")));
    assertThat(bareme.calcul(BigDecimal.valueOf(347000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("56665.773")));
    assertThat(bareme.calcul(BigDecimal.valueOf(348000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("56849.306")));
    assertThat(bareme.calcul(BigDecimal.valueOf(349000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("57032.881")));
    assertThat(bareme.calcul(BigDecimal.valueOf(350000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("57216.498")));
    assertThat(bareme.calcul(BigDecimal.valueOf(351000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("57400.156")));
    assertThat(bareme.calcul(BigDecimal.valueOf(352000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("57583.855")));
    assertThat(bareme.calcul(BigDecimal.valueOf(353000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("57767.595")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(354000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("57951.375")));
    assertThat(bareme.calcul(BigDecimal.valueOf(355000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("58135.195")));
    assertThat(bareme.calcul(BigDecimal.valueOf(356000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("58319.055")));
    assertThat(bareme.calcul(BigDecimal.valueOf(357000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("58502.955")));
    assertThat(bareme.calcul(BigDecimal.valueOf(358000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("58686.895")));
    assertThat(bareme.calcul(BigDecimal.valueOf(359000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("58870.873")));
    assertThat(bareme.calcul(BigDecimal.valueOf(360000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("59054.891")));
    assertThat(bareme.calcul(BigDecimal.valueOf(361000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("59238.947")));
    assertThat(bareme.calcul(BigDecimal.valueOf(362000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("59423.041")));
    assertThat(bareme.calcul(BigDecimal.valueOf(363000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("59607.174")));
    assertThat(bareme.calcul(BigDecimal.valueOf(364000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("59791.344")));
    assertThat(bareme.calcul(BigDecimal.valueOf(365000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("59975.552")));
    assertThat(bareme.calcul(BigDecimal.valueOf(366000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("60159.798")));
    assertThat(bareme.calcul(BigDecimal.valueOf(367000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("60344.080")));
    assertThat(bareme.calcul(BigDecimal.valueOf(368000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("60528.400")));
    assertThat(bareme.calcul(BigDecimal.valueOf(369000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("60712.756")));
    assertThat(bareme.calcul(BigDecimal.valueOf(370000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("60897.149")));
    assertThat(bareme.calcul(BigDecimal.valueOf(371000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("61081.578")));
    assertThat(bareme.calcul(BigDecimal.valueOf(372000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("61266.043")));
    assertThat(bareme.calcul(BigDecimal.valueOf(373000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("61450.544")));
    assertThat(bareme.calcul(BigDecimal.valueOf(374000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("61635.080")));
    assertThat(bareme.calcul(BigDecimal.valueOf(375000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("61819.652")));
    assertThat(bareme.calcul(BigDecimal.valueOf(376000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("62004.259")));
    assertThat(bareme.calcul(BigDecimal.valueOf(377000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("62188.900")));
    assertThat(bareme.calcul(BigDecimal.valueOf(378000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("62373.576")));
    assertThat(bareme.calcul(BigDecimal.valueOf(379000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("62558.287")));
    assertThat(bareme.calcul(BigDecimal.valueOf(380000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("62743.031")));
    assertThat(bareme.calcul(BigDecimal.valueOf(381000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("62927.810")));
    assertThat(bareme.calcul(BigDecimal.valueOf(382000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("63112.622")));
    assertThat(bareme.calcul(BigDecimal.valueOf(383000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("63297.468")));
    assertThat(bareme.calcul(BigDecimal.valueOf(384000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("63482.347")));
    assertThat(bareme.calcul(BigDecimal.valueOf(385000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("63667.259")));
    assertThat(bareme.calcul(BigDecimal.valueOf(386000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("63852.204")));
    assertThat(bareme.calcul(BigDecimal.valueOf(387000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("64037.182")));
    assertThat(bareme.calcul(BigDecimal.valueOf(388000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("64222.192")));
    assertThat(bareme.calcul(BigDecimal.valueOf(389000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("64407.234")));
    assertThat(bareme.calcul(BigDecimal.valueOf(390000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("64592.308")));
    assertThat(bareme.calcul(BigDecimal.valueOf(391000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("64777.414")));
    assertThat(bareme.calcul(BigDecimal.valueOf(392000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("64962.552")));
    assertThat(bareme.calcul(BigDecimal.valueOf(393000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("65147.721")));
    assertThat(bareme.calcul(BigDecimal.valueOf(394000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("65332.921")));
    assertThat(bareme.calcul(BigDecimal.valueOf(395000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("65518.153")));
    assertThat(bareme.calcul(BigDecimal.valueOf(396000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("65703.415")));
    assertThat(bareme.calcul(BigDecimal.valueOf(397000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("65888.707")));
    assertThat(bareme.calcul(BigDecimal.valueOf(398000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("66074.030")));
    assertThat(bareme.calcul(BigDecimal.valueOf(399000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("66259.384")));
    assertThat(bareme.calcul(BigDecimal.valueOf(400000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("66444.767")));
    assertThat(bareme.calcul(BigDecimal.valueOf(401000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("66630.180")));
    assertThat(bareme.calcul(BigDecimal.valueOf(402000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("66815.622")));
    assertThat(bareme.calcul(BigDecimal.valueOf(403000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("67001.095")));
    assertThat(bareme.calcul(BigDecimal.valueOf(404000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("67186.596")));
    assertThat(bareme.calcul(BigDecimal.valueOf(405000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("67372.126")));
    assertThat(bareme.calcul(BigDecimal.valueOf(406000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("67557.685")));
    assertThat(bareme.calcul(BigDecimal.valueOf(407000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("67743.273")));
    assertThat(bareme.calcul(BigDecimal.valueOf(408000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("67928.889")));
    assertThat(bareme.calcul(BigDecimal.valueOf(409000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("68114.534")));
    assertThat(bareme.calcul(BigDecimal.valueOf(410000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("68300.207")));
    assertThat(bareme.calcul(BigDecimal.valueOf(411000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("68485.908")));
    assertThat(bareme.calcul(BigDecimal.valueOf(412000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("68671.636")));
    assertThat(bareme.calcul(BigDecimal.valueOf(413000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("68857.392")));
    assertThat(bareme.calcul(BigDecimal.valueOf(414000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("69043.175")));
    assertThat(bareme.calcul(BigDecimal.valueOf(415000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("69228.986")));
    assertThat(bareme.calcul(BigDecimal.valueOf(416000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("69414.824")));
    assertThat(bareme.calcul(BigDecimal.valueOf(417000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("69600.688")));
    assertThat(bareme.calcul(BigDecimal.valueOf(418000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("69786.579")));
    assertThat(bareme.calcul(BigDecimal.valueOf(419000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("69972.497")));
    assertThat(bareme.calcul(BigDecimal.valueOf(420000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("70158.441")));
    assertThat(bareme.calcul(BigDecimal.valueOf(421000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("70344.411")));
    assertThat(bareme.calcul(BigDecimal.valueOf(422000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("70530.407")));
    assertThat(bareme.calcul(BigDecimal.valueOf(423000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("70716.429")));
    assertThat(bareme.calcul(BigDecimal.valueOf(424000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("70902.477")));
    assertThat(bareme.calcul(BigDecimal.valueOf(425000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("71088.550")));
    assertThat(bareme.calcul(BigDecimal.valueOf(426000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("71274.649")));
    assertThat(bareme.calcul(BigDecimal.valueOf(427000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("71460.773")));
    assertThat(bareme.calcul(BigDecimal.valueOf(428000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("71646.921")));
    assertThat(bareme.calcul(BigDecimal.valueOf(429000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("71833.095")));
    assertThat(bareme.calcul(BigDecimal.valueOf(430000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("72019.293")));
    assertThat(bareme.calcul(BigDecimal.valueOf(431000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("72205.516")));
    assertThat(bareme.calcul(BigDecimal.valueOf(432000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("72391.763")));
    assertThat(bareme.calcul(BigDecimal.valueOf(433000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("72578.035")));
    assertThat(bareme.calcul(BigDecimal.valueOf(434000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("72764.330")));
    assertThat(bareme.calcul(BigDecimal.valueOf(435000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("72950.650")));
    assertThat(bareme.calcul(BigDecimal.valueOf(436000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("73136.993")));
    assertThat(bareme.calcul(BigDecimal.valueOf(437000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("73323.359")));
    assertThat(bareme.calcul(BigDecimal.valueOf(438000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("73509.750")));
    assertThat(bareme.calcul(BigDecimal.valueOf(439000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("73696.163")));
    assertThat(bareme.calcul(BigDecimal.valueOf(440000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("73882.600")));
    assertThat(bareme.calcul(BigDecimal.valueOf(441000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("74069.059")));
    assertThat(bareme.calcul(BigDecimal.valueOf(442000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("74255.541")));
    assertThat(bareme.calcul(BigDecimal.valueOf(443000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("74442.047")));
    assertThat(bareme.calcul(BigDecimal.valueOf(444000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("74628.574")));
    assertThat(bareme.calcul(BigDecimal.valueOf(445000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("74815.124")));
    assertThat(bareme.calcul(BigDecimal.valueOf(446000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("75001.696")));
    assertThat(bareme.calcul(BigDecimal.valueOf(447000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("75188.291")));
    assertThat(bareme.calcul(BigDecimal.valueOf(448000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("75374.907")));
    assertThat(bareme.calcul(BigDecimal.valueOf(449000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("75561.545")));
    assertThat(bareme.calcul(BigDecimal.valueOf(450000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("75748.205")));
    assertThat(bareme.calcul(BigDecimal.valueOf(451000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("75934.887")));
    assertThat(bareme.calcul(BigDecimal.valueOf(452000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("76121.589")));
    assertThat(bareme.calcul(BigDecimal.valueOf(453000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("76308.314")));
    assertThat(bareme.calcul(BigDecimal.valueOf(454000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("76495.059")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(455000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("76681.825")));
    assertThat(bareme.calcul(BigDecimal.valueOf(456000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("76868.612")));
    assertThat(bareme.calcul(BigDecimal.valueOf(457000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("77055.420")));
    assertThat(bareme.calcul(BigDecimal.valueOf(458000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("77242.248")));
    assertThat(bareme.calcul(BigDecimal.valueOf(459000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("77429.097")));
    assertThat(bareme.calcul(BigDecimal.valueOf(460000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("77615.966")));
    assertThat(bareme.calcul(BigDecimal.valueOf(461000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("77802.855")));
    assertThat(bareme.calcul(BigDecimal.valueOf(462000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("77989.765")));
    assertThat(bareme.calcul(BigDecimal.valueOf(463000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("78176.694")));
    assertThat(bareme.calcul(BigDecimal.valueOf(464000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("78363.643")));
    assertThat(bareme.calcul(BigDecimal.valueOf(465000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("78550.612")));
    assertThat(bareme.calcul(BigDecimal.valueOf(466000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("78737.600")));
    assertThat(bareme.calcul(BigDecimal.valueOf(467000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("78924.608")));
    assertThat(bareme.calcul(BigDecimal.valueOf(468000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("79111.635")));
    assertThat(bareme.calcul(BigDecimal.valueOf(469000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("79298.681")));
    assertThat(bareme.calcul(BigDecimal.valueOf(470000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("79485.746")));
    assertThat(bareme.calcul(BigDecimal.valueOf(471000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("79672.831")));
    assertThat(bareme.calcul(BigDecimal.valueOf(472000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("79859.934")));
    assertThat(bareme.calcul(BigDecimal.valueOf(473000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("80047.055")));
    assertThat(bareme.calcul(BigDecimal.valueOf(474000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("80234.195")));
    assertThat(bareme.calcul(BigDecimal.valueOf(475000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("80421.354")));
    assertThat(bareme.calcul(BigDecimal.valueOf(476000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("80608.531")));
    assertThat(bareme.calcul(BigDecimal.valueOf(477000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("80795.726")));
    assertThat(bareme.calcul(BigDecimal.valueOf(478000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("80982.939")));
    assertThat(bareme.calcul(BigDecimal.valueOf(479000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("81170.171")));
    assertThat(bareme.calcul(BigDecimal.valueOf(480000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("81357.420")));
    assertThat(bareme.calcul(BigDecimal.valueOf(481000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("81544.686")));
    assertThat(bareme.calcul(BigDecimal.valueOf(482000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("81731.971")));
    assertThat(bareme.calcul(BigDecimal.valueOf(483000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("81919.273")));
    assertThat(bareme.calcul(BigDecimal.valueOf(484000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("82106.592")));
    assertThat(bareme.calcul(BigDecimal.valueOf(485000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("82293.929")));
    assertThat(bareme.calcul(BigDecimal.valueOf(486000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("82481.282")));
    assertThat(bareme.calcul(BigDecimal.valueOf(487000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("82668.653")));
    assertThat(bareme.calcul(BigDecimal.valueOf(488000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("82856.041")));
    assertThat(bareme.calcul(BigDecimal.valueOf(489000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("83043.446")));
    assertThat(bareme.calcul(BigDecimal.valueOf(490000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("83230.867")));
    assertThat(bareme.calcul(BigDecimal.valueOf(491000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("83418.305")));
    assertThat(bareme.calcul(BigDecimal.valueOf(492000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("83605.759")));
    assertThat(bareme.calcul(BigDecimal.valueOf(493000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("83793.230")));
    assertThat(bareme.calcul(BigDecimal.valueOf(494000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("83980.717")));
    assertThat(bareme.calcul(BigDecimal.valueOf(495000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("84168.221")));
    assertThat(bareme.calcul(BigDecimal.valueOf(496000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("84355.740")));
    assertThat(bareme.calcul(BigDecimal.valueOf(497000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("84543.275")));
    assertThat(bareme.calcul(BigDecimal.valueOf(498000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("84730.827")));
    assertThat(bareme.calcul(BigDecimal.valueOf(499000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("84918.394")));
    assertThat(bareme.calcul(BigDecimal.valueOf(500000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("85105.977")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(501000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("85293.575")));
    assertThat(bareme.calcul(BigDecimal.valueOf(502000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("85481.189")));
    assertThat(bareme.calcul(BigDecimal.valueOf(503000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("85668.818")));
    assertThat(bareme.calcul(BigDecimal.valueOf(504000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("85856.462")));
    assertThat(bareme.calcul(BigDecimal.valueOf(505000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("86044.122")));
    assertThat(bareme.calcul(BigDecimal.valueOf(506000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("86231.797")));
    assertThat(bareme.calcul(BigDecimal.valueOf(507000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("86419.486")));
    assertThat(bareme.calcul(BigDecimal.valueOf(508000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("86607.191")));
    assertThat(bareme.calcul(BigDecimal.valueOf(509000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("86794.910")));
    assertThat(bareme.calcul(BigDecimal.valueOf(510000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("86982.644")));
    assertThat(bareme.calcul(BigDecimal.valueOf(511000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("87170.393")));
    assertThat(bareme.calcul(BigDecimal.valueOf(512000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("87358.156")));
    assertThat(bareme.calcul(BigDecimal.valueOf(513000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("87545.934")));
    assertThat(bareme.calcul(BigDecimal.valueOf(514000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("87733.726")));
    assertThat(bareme.calcul(BigDecimal.valueOf(515000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("87921.532")));
    assertThat(bareme.calcul(BigDecimal.valueOf(516000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("88109.352")));
    assertThat(bareme.calcul(BigDecimal.valueOf(517000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("88297.186")));
    assertThat(bareme.calcul(BigDecimal.valueOf(518000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("88485.035")));
    assertThat(bareme.calcul(BigDecimal.valueOf(519000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("88672.897")));
    assertThat(bareme.calcul(BigDecimal.valueOf(520000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("88860.773")));
    assertThat(bareme.calcul(BigDecimal.valueOf(521000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("89048.662")));
    assertThat(bareme.calcul(BigDecimal.valueOf(522000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("89236.565")));
    assertThat(bareme.calcul(BigDecimal.valueOf(523000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("89424.482")));
    assertThat(bareme.calcul(BigDecimal.valueOf(524000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("89612.412")));
    assertThat(bareme.calcul(BigDecimal.valueOf(525000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("89800.356")));
    assertThat(bareme.calcul(BigDecimal.valueOf(526000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("89988.312")));
    assertThat(bareme.calcul(BigDecimal.valueOf(527000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("90176.282")));
    assertThat(bareme.calcul(BigDecimal.valueOf(528000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("90364.265")));
    assertThat(bareme.calcul(BigDecimal.valueOf(529000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("90552.261")));
    assertThat(bareme.calcul(BigDecimal.valueOf(530000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("90740.270")));
    assertThat(bareme.calcul(BigDecimal.valueOf(531000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("90928.291")));
    assertThat(bareme.calcul(BigDecimal.valueOf(532000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("91116.326")));
    assertThat(bareme.calcul(BigDecimal.valueOf(533000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("91304.373")));
    assertThat(bareme.calcul(BigDecimal.valueOf(534000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("91492.432")));
    assertThat(bareme.calcul(BigDecimal.valueOf(535000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("91680.504")));
    assertThat(bareme.calcul(BigDecimal.valueOf(536000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("91868.589")));
    assertThat(bareme.calcul(BigDecimal.valueOf(537000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("92056.686")));
    assertThat(bareme.calcul(BigDecimal.valueOf(538000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("92244.795")));
    assertThat(bareme.calcul(BigDecimal.valueOf(539000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("92432.916")));
    assertThat(bareme.calcul(BigDecimal.valueOf(540000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("92621.049")));
    assertThat(bareme.calcul(BigDecimal.valueOf(541000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("92809.195")));
    assertThat(bareme.calcul(BigDecimal.valueOf(542000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("92997.352")));
    assertThat(bareme.calcul(BigDecimal.valueOf(543000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("93185.521")));
    assertThat(bareme.calcul(BigDecimal.valueOf(544000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("93373.702")));
    assertThat(bareme.calcul(BigDecimal.valueOf(545000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("93561.895")));
    assertThat(bareme.calcul(BigDecimal.valueOf(546000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("93750.099")));
    assertThat(bareme.calcul(BigDecimal.valueOf(547000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("93938.315")));
    assertThat(bareme.calcul(BigDecimal.valueOf(548000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("94126.543")));
    assertThat(bareme.calcul(BigDecimal.valueOf(549000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("94314.781")));
    assertThat(bareme.calcul(BigDecimal.valueOf(550000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("94503.031")));
    assertThat(bareme.calcul(BigDecimal.valueOf(551000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("94691.293")));
    assertThat(bareme.calcul(BigDecimal.valueOf(552000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("94879.565")));
    assertThat(bareme.calcul(BigDecimal.valueOf(553000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("95067.849")));
    assertThat(bareme.calcul(BigDecimal.valueOf(554000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("95256.144")));
    assertThat(bareme.calcul(BigDecimal.valueOf(555000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("95444.450")));
    assertThat(bareme.calcul(BigDecimal.valueOf(556000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("95632.766")));
    assertThat(bareme.calcul(BigDecimal.valueOf(557000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("95821.094")));
    assertThat(bareme.calcul(BigDecimal.valueOf(558000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("96009.432")));
    assertThat(bareme.calcul(BigDecimal.valueOf(559000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("96197.781")));
    assertThat(bareme.calcul(BigDecimal.valueOf(560000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("96386.141")));
    assertThat(bareme.calcul(BigDecimal.valueOf(561000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("96574.511")));
    assertThat(bareme.calcul(BigDecimal.valueOf(562000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("96762.891")));
    assertThat(bareme.calcul(BigDecimal.valueOf(563000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("96951.282")));
    assertThat(bareme.calcul(BigDecimal.valueOf(564000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("97139.684")));
    assertThat(bareme.calcul(BigDecimal.valueOf(565000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("97328.095")));
    assertThat(bareme.calcul(BigDecimal.valueOf(566000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("97516.517")));
    assertThat(bareme.calcul(BigDecimal.valueOf(567000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("97704.949")));
    assertThat(bareme.calcul(BigDecimal.valueOf(568000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("97893.392")));
    assertThat(bareme.calcul(BigDecimal.valueOf(569000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("98081.844")));
    assertThat(bareme.calcul(BigDecimal.valueOf(570000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("98270.306")));
    assertThat(bareme.calcul(BigDecimal.valueOf(571000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("98458.778")));
    assertThat(bareme.calcul(BigDecimal.valueOf(572000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("98647.260")));
    assertThat(bareme.calcul(BigDecimal.valueOf(573000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("98835.751")));
    assertThat(bareme.calcul(BigDecimal.valueOf(574000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("99024.253")));
    assertThat(bareme.calcul(BigDecimal.valueOf(575000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("99212.764")));
    assertThat(bareme.calcul(BigDecimal.valueOf(576000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("99401.284")));
    assertThat(bareme.calcul(BigDecimal.valueOf(577000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("99589.814")));
    assertThat(bareme.calcul(BigDecimal.valueOf(578000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("99778.354")));
    assertThat(bareme.calcul(BigDecimal.valueOf(579000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("99966.903")));
    assertThat(bareme.calcul(BigDecimal.valueOf(580000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("100155.461")));
    assertThat(bareme.calcul(BigDecimal.valueOf(581000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("100344.029")));
    assertThat(bareme.calcul(BigDecimal.valueOf(582000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("100532.606")));
    assertThat(bareme.calcul(BigDecimal.valueOf(583000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("100721.192")));
    assertThat(bareme.calcul(BigDecimal.valueOf(584000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("100909.787")));
    assertThat(bareme.calcul(BigDecimal.valueOf(585000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("101098.391")));
    assertThat(bareme.calcul(BigDecimal.valueOf(586000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("101287.004")));
    assertThat(bareme.calcul(BigDecimal.valueOf(587000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("101475.626")));
    assertThat(bareme.calcul(BigDecimal.valueOf(588000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("101664.257")));
    assertThat(bareme.calcul(BigDecimal.valueOf(589000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("101852.896")));
    assertThat(bareme.calcul(BigDecimal.valueOf(590000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("102041.545")));
    assertThat(bareme.calcul(BigDecimal.valueOf(591000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("102230.202")));
    assertThat(bareme.calcul(BigDecimal.valueOf(592000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("102418.867")));
    assertThat(bareme.calcul(BigDecimal.valueOf(593000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("102607.542")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(594000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("102796.225")));
    assertThat(bareme.calcul(BigDecimal.valueOf(595000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("102984.916")));
    assertThat(bareme.calcul(BigDecimal.valueOf(596000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("103173.616")));
    assertThat(bareme.calcul(BigDecimal.valueOf(597000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("103362.324")));
    assertThat(bareme.calcul(BigDecimal.valueOf(598000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("103551.040")));
    assertThat(bareme.calcul(BigDecimal.valueOf(599000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("103739.765")));
    assertThat(bareme.calcul(BigDecimal.valueOf(600000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("103928.498")));
    assertThat(bareme.calcul(BigDecimal.valueOf(601000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("104117.239")));
    assertThat(bareme.calcul(BigDecimal.valueOf(602000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("104305.988")));
    assertThat(bareme.calcul(BigDecimal.valueOf(603000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("104494.745")));
    assertThat(bareme.calcul(BigDecimal.valueOf(604000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("104683.510")));
    assertThat(bareme.calcul(BigDecimal.valueOf(605000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("104872.283")));
    assertThat(bareme.calcul(BigDecimal.valueOf(606000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("105061.064")));
    assertThat(bareme.calcul(BigDecimal.valueOf(607000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("105249.853")));
    assertThat(bareme.calcul(BigDecimal.valueOf(608000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("105438.650")));
    assertThat(bareme.calcul(BigDecimal.valueOf(609000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("105627.454")));
    assertThat(bareme.calcul(BigDecimal.valueOf(610000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("105816.266")));
    assertThat(bareme.calcul(BigDecimal.valueOf(611000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("106005.086")));
    assertThat(bareme.calcul(BigDecimal.valueOf(612000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("106193.913")));
    assertThat(bareme.calcul(BigDecimal.valueOf(613000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("106382.748")));
    assertThat(bareme.calcul(BigDecimal.valueOf(614000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("106571.590")));
    assertThat(bareme.calcul(BigDecimal.valueOf(615000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("106760.440")));
    assertThat(bareme.calcul(BigDecimal.valueOf(616000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("106949.297")));
    assertThat(bareme.calcul(BigDecimal.valueOf(617000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("107138.162")));
    assertThat(bareme.calcul(BigDecimal.valueOf(618000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("107327.033")));
    assertThat(bareme.calcul(BigDecimal.valueOf(619000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("107515.913")));
    assertThat(bareme.calcul(BigDecimal.valueOf(620000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("107704.799")));
    assertThat(bareme.calcul(BigDecimal.valueOf(621000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("107893.692")));
    assertThat(bareme.calcul(BigDecimal.valueOf(622000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("108082.593")));
    assertThat(bareme.calcul(BigDecimal.valueOf(623000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("108271.500")));
    assertThat(bareme.calcul(BigDecimal.valueOf(624000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("108460.415")));
    assertThat(bareme.calcul(BigDecimal.valueOf(625000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("108649.337")));
    assertThat(bareme.calcul(BigDecimal.valueOf(626000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("108838.265")));
    assertThat(bareme.calcul(BigDecimal.valueOf(627000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("109027.201")));
    assertThat(bareme.calcul(BigDecimal.valueOf(628000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("109216.143")));
    assertThat(bareme.calcul(BigDecimal.valueOf(629000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("109405.092")));
    assertThat(bareme.calcul(BigDecimal.valueOf(630000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("109594.048")));
    assertThat(bareme.calcul(BigDecimal.valueOf(631000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("109783.010")));
    assertThat(bareme.calcul(BigDecimal.valueOf(632000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("109971.980")));
    assertThat(bareme.calcul(BigDecimal.valueOf(633000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("110160.955")));
    assertThat(bareme.calcul(BigDecimal.valueOf(634000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("110349.938")));
    assertThat(bareme.calcul(BigDecimal.valueOf(635000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("110538.927")));
    assertThat(bareme.calcul(BigDecimal.valueOf(636000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("110727.922")));
    assertThat(bareme.calcul(BigDecimal.valueOf(637000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("110916.924")));
    assertThat(bareme.calcul(BigDecimal.valueOf(638000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("111105.933")));
    assertThat(bareme.calcul(BigDecimal.valueOf(639000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("111294.947")));
    assertThat(bareme.calcul(BigDecimal.valueOf(640000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("111483.968")));
    assertThat(bareme.calcul(BigDecimal.valueOf(641000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("111672.996")));
    assertThat(bareme.calcul(BigDecimal.valueOf(642000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("111862.029")));
    assertThat(bareme.calcul(BigDecimal.valueOf(643000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("112051.069")));
    assertThat(bareme.calcul(BigDecimal.valueOf(644000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("112240.115")));
    assertThat(bareme.calcul(BigDecimal.valueOf(645000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("112429.167")));
    assertThat(bareme.calcul(BigDecimal.valueOf(646000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("112618.225")));
    assertThat(bareme.calcul(BigDecimal.valueOf(647000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("112807.289")));
    assertThat(bareme.calcul(BigDecimal.valueOf(648000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("112996.360")));
    assertThat(bareme.calcul(BigDecimal.valueOf(649000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("113185.436")));
    assertThat(bareme.calcul(BigDecimal.valueOf(650000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("113374.518")));
    assertThat(bareme.calcul(BigDecimal.valueOf(651000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("113563.606")));
    assertThat(bareme.calcul(BigDecimal.valueOf(652000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("113752.700")));
    assertThat(bareme.calcul(BigDecimal.valueOf(653000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("113941.800")));
    assertThat(bareme.calcul(BigDecimal.valueOf(654000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("114130.905")));
    assertThat(bareme.calcul(BigDecimal.valueOf(655000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("114320.017")));
    assertThat(bareme.calcul(BigDecimal.valueOf(656000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("114509.134")));
    assertThat(bareme.calcul(BigDecimal.valueOf(657000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("114698.256")));
    assertThat(bareme.calcul(BigDecimal.valueOf(658000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("114887.385")));
    assertThat(bareme.calcul(BigDecimal.valueOf(659000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("115076.519")));
    assertThat(bareme.calcul(BigDecimal.valueOf(660000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("115265.658")));
    assertThat(bareme.calcul(BigDecimal.valueOf(661000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("115454.803")));
    assertThat(bareme.calcul(BigDecimal.valueOf(662000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("115643.954")));
    assertThat(bareme.calcul(BigDecimal.valueOf(663000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("115833.109")));
    assertThat(bareme.calcul(BigDecimal.valueOf(664000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("116022.271")));
    assertThat(bareme.calcul(BigDecimal.valueOf(665000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("116211.438")));
    assertThat(bareme.calcul(BigDecimal.valueOf(666000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("116400.610")));
    assertThat(bareme.calcul(BigDecimal.valueOf(667000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("116589.787")));
    assertThat(bareme.calcul(BigDecimal.valueOf(668000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("116778.970")));
    assertThat(bareme.calcul(BigDecimal.valueOf(669000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("116968.158")));
    assertThat(bareme.calcul(BigDecimal.valueOf(670000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("117157.351")));
    assertThat(bareme.calcul(BigDecimal.valueOf(671000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("117346.549")));
    assertThat(bareme.calcul(BigDecimal.valueOf(672000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("117535.753")));
    assertThat(bareme.calcul(BigDecimal.valueOf(673000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("117724.962")));
    assertThat(bareme.calcul(BigDecimal.valueOf(674000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("117914.175")));
    assertThat(bareme.calcul(BigDecimal.valueOf(675000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("118103.394")));
    assertThat(bareme.calcul(BigDecimal.valueOf(676000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("118292.618")));
    assertThat(bareme.calcul(BigDecimal.valueOf(677000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("118481.847")));
    assertThat(bareme.calcul(BigDecimal.valueOf(678000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("118671.080")));
    assertThat(bareme.calcul(BigDecimal.valueOf(679000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("118860.319")));
    assertThat(bareme.calcul(BigDecimal.valueOf(680000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("119049.562")));
    assertThat(bareme.calcul(BigDecimal.valueOf(681000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("119238.811")));
    assertThat(bareme.calcul(BigDecimal.valueOf(682000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("119428.064")));
    assertThat(bareme.calcul(BigDecimal.valueOf(683000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("119617.322")));
    assertThat(bareme.calcul(BigDecimal.valueOf(684000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("119806.585")));
    assertThat(bareme.calcul(BigDecimal.valueOf(685000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("119995.852")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(686000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("120185.125")));
    assertThat(bareme.calcul(BigDecimal.valueOf(687000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("120374.401")));
    assertThat(bareme.calcul(BigDecimal.valueOf(688000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("120563.683")));
    assertThat(bareme.calcul(BigDecimal.valueOf(689000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("120752.969")));
    assertThat(bareme.calcul(BigDecimal.valueOf(690000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("120942.260")));
    assertThat(bareme.calcul(BigDecimal.valueOf(691000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("121131.555")));
    assertThat(bareme.calcul(BigDecimal.valueOf(692000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("121320.855")));
    assertThat(bareme.calcul(BigDecimal.valueOf(693000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("121510.159")));
    assertThat(bareme.calcul(BigDecimal.valueOf(694000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("121699.468")));
    assertThat(bareme.calcul(BigDecimal.valueOf(695000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("121888.781")));
    assertThat(bareme.calcul(BigDecimal.valueOf(696000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("122078.099")));
    assertThat(bareme.calcul(BigDecimal.valueOf(697000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("122267.421")));
    assertThat(bareme.calcul(BigDecimal.valueOf(698000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("122456.747")));
    assertThat(bareme.calcul(BigDecimal.valueOf(699000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("122646.078")));
    assertThat(bareme.calcul(BigDecimal.valueOf(700000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("122835.413")));
    assertThat(bareme.calcul(BigDecimal.valueOf(701000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("123024.752")));
    assertThat(bareme.calcul(BigDecimal.valueOf(702000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("123214.096")));
    assertThat(bareme.calcul(BigDecimal.valueOf(703000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("123403.443")));
    assertThat(bareme.calcul(BigDecimal.valueOf(704000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("123592.795")));
    assertThat(bareme.calcul(BigDecimal.valueOf(705000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("123782.151")));
    assertThat(bareme.calcul(BigDecimal.valueOf(706000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("123971.511")));
    assertThat(bareme.calcul(BigDecimal.valueOf(707000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("124160.876")));
    assertThat(bareme.calcul(BigDecimal.valueOf(708000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("124350.244")));
    assertThat(bareme.calcul(BigDecimal.valueOf(709000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("124539.617")));
    assertThat(bareme.calcul(BigDecimal.valueOf(710000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("124728.993")));
    assertThat(bareme.calcul(BigDecimal.valueOf(711000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("124918.374")));
    assertThat(bareme.calcul(BigDecimal.valueOf(712000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("125107.758")));
    assertThat(bareme.calcul(BigDecimal.valueOf(713000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("125297.146")));
    assertThat(bareme.calcul(BigDecimal.valueOf(714000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("125486.539")));
    assertThat(bareme.calcul(BigDecimal.valueOf(715000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("125675.935")));
    assertThat(bareme.calcul(BigDecimal.valueOf(716000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("125865.335")));
    assertThat(bareme.calcul(BigDecimal.valueOf(717000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("126054.739")));
    assertThat(bareme.calcul(BigDecimal.valueOf(718000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("126244.147")));
    assertThat(bareme.calcul(BigDecimal.valueOf(719000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("126433.558")));
    assertThat(bareme.calcul(BigDecimal.valueOf(720000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("126622.974")));
    assertThat(bareme.calcul(BigDecimal.valueOf(721000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("126812.393")));
    assertThat(bareme.calcul(BigDecimal.valueOf(722000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("127001.816")));
    assertThat(bareme.calcul(BigDecimal.valueOf(723000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("127191.242")));
    assertThat(bareme.calcul(BigDecimal.valueOf(724000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("127380.672")));
    assertThat(bareme.calcul(BigDecimal.valueOf(725000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("127570.106")));
    assertThat(bareme.calcul(BigDecimal.valueOf(726000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("127759.544")));
    assertThat(bareme.calcul(BigDecimal.valueOf(727000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("127948.985")));
    assertThat(bareme.calcul(BigDecimal.valueOf(728000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("128138.429")));
    assertThat(bareme.calcul(BigDecimal.valueOf(729000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("128327.878")));
    assertThat(bareme.calcul(BigDecimal.valueOf(730000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("128517.329")));
    assertThat(bareme.calcul(BigDecimal.valueOf(731000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("128706.785")));
    assertThat(bareme.calcul(BigDecimal.valueOf(732000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("128896.244")));
    assertThat(bareme.calcul(BigDecimal.valueOf(733000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("129085.706")));
    assertThat(bareme.calcul(BigDecimal.valueOf(734000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("129275.172")));
    assertThat(bareme.calcul(BigDecimal.valueOf(735000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("129464.641")));
    assertThat(bareme.calcul(BigDecimal.valueOf(736000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("129654.113")));
    assertThat(bareme.calcul(BigDecimal.valueOf(737000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("129843.589")));
    assertThat(bareme.calcul(BigDecimal.valueOf(738000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("130033.069")));
    assertThat(bareme.calcul(BigDecimal.valueOf(739000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("130222.551")));
    assertThat(bareme.calcul(BigDecimal.valueOf(740000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("130412.037")));
    assertThat(bareme.calcul(BigDecimal.valueOf(741000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("130601.527")));
    assertThat(bareme.calcul(BigDecimal.valueOf(742000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("130791.019")));
    assertThat(bareme.calcul(BigDecimal.valueOf(743000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("130980.515")));
    assertThat(bareme.calcul(BigDecimal.valueOf(744000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("131170.014")));
    assertThat(bareme.calcul(BigDecimal.valueOf(745000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("131359.516")));
    assertThat(bareme.calcul(BigDecimal.valueOf(746000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("131549.022")));
    assertThat(bareme.calcul(BigDecimal.valueOf(747000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("131738.530")));
    assertThat(bareme.calcul(BigDecimal.valueOf(748000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("131928.042")));
    assertThat(bareme.calcul(BigDecimal.valueOf(749000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("132117.557")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(750000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("132307.075")));
    assertThat(bareme.calcul(BigDecimal.valueOf(751000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("132496.596")));
    assertThat(bareme.calcul(BigDecimal.valueOf(752000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("132686.120")));
    assertThat(bareme.calcul(BigDecimal.valueOf(753000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("132875.647")));
    assertThat(bareme.calcul(BigDecimal.valueOf(754000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("133065.178")));
    assertThat(bareme.calcul(BigDecimal.valueOf(755000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("133254.711")));
    assertThat(bareme.calcul(BigDecimal.valueOf(756000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("133444.247")));
    assertThat(bareme.calcul(BigDecimal.valueOf(757000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("133633.786")));
    assertThat(bareme.calcul(BigDecimal.valueOf(758000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("133823.329")));
    assertThat(bareme.calcul(BigDecimal.valueOf(759000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("134012.874")));
    assertThat(bareme.calcul(BigDecimal.valueOf(760000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("134202.422")));
    assertThat(bareme.calcul(BigDecimal.valueOf(761000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("134391.973")));
    assertThat(bareme.calcul(BigDecimal.valueOf(762000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("134581.527")));
    assertThat(bareme.calcul(BigDecimal.valueOf(763000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("134771.083")));
    assertThat(bareme.calcul(BigDecimal.valueOf(764000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("134960.643")));
    assertThat(bareme.calcul(BigDecimal.valueOf(765000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("135150.205")));
    assertThat(bareme.calcul(BigDecimal.valueOf(766000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("135339.770")));
    assertThat(bareme.calcul(BigDecimal.valueOf(767000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("135529.338")));
    assertThat(bareme.calcul(BigDecimal.valueOf(768000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("135718.909")));
    assertThat(bareme.calcul(BigDecimal.valueOf(769000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("135908.483")));
    assertThat(bareme.calcul(BigDecimal.valueOf(770000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("136098.059")));
    assertThat(bareme.calcul(BigDecimal.valueOf(771000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("136287.638")));
    assertThat(bareme.calcul(BigDecimal.valueOf(772000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("136477.219")));
    assertThat(bareme.calcul(BigDecimal.valueOf(773000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("136666.804")));
    assertThat(bareme.calcul(BigDecimal.valueOf(774000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("136856.391")));
    assertThat(bareme.calcul(BigDecimal.valueOf(775000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("137045.980")));
    assertThat(bareme.calcul(BigDecimal.valueOf(776000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("137235.572")));
    assertThat(bareme.calcul(BigDecimal.valueOf(777000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("137425.167")));
    assertThat(bareme.calcul(BigDecimal.valueOf(778000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("137614.765")));
    assertThat(bareme.calcul(BigDecimal.valueOf(779000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("137804.365")));
    assertThat(bareme.calcul(BigDecimal.valueOf(780000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("137993.967")));
    assertThat(bareme.calcul(BigDecimal.valueOf(781000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("138183.573")));
    assertThat(bareme.calcul(BigDecimal.valueOf(782000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("138373.180")));
    assertThat(bareme.calcul(BigDecimal.valueOf(783000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("138562.790")));
    assertThat(bareme.calcul(BigDecimal.valueOf(784000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("138752.403")));
    assertThat(bareme.calcul(BigDecimal.valueOf(785000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("138942.018")));
    assertThat(bareme.calcul(BigDecimal.valueOf(786000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("139131.636")));
    assertThat(bareme.calcul(BigDecimal.valueOf(787000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("139321.256")));
    assertThat(bareme.calcul(BigDecimal.valueOf(788000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("139510.879")));
    assertThat(bareme.calcul(BigDecimal.valueOf(789000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("139700.504")));
    assertThat(bareme.calcul(BigDecimal.valueOf(790000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("139890.131")));
    assertThat(bareme.calcul(BigDecimal.valueOf(791000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("140079.761")));
    assertThat(bareme.calcul(BigDecimal.valueOf(792000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("140269.393")));
    assertThat(bareme.calcul(BigDecimal.valueOf(793000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("140459.027")));
    assertThat(bareme.calcul(BigDecimal.valueOf(794000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("140648.664")));
    assertThat(bareme.calcul(BigDecimal.valueOf(795000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("140838.303")));
    assertThat(bareme.calcul(BigDecimal.valueOf(796000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("141027.945")));
    assertThat(bareme.calcul(BigDecimal.valueOf(797000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("141217.589")));
    assertThat(bareme.calcul(BigDecimal.valueOf(798000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("141407.235")));
    assertThat(bareme.calcul(BigDecimal.valueOf(799000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("141596.883")));
    assertThat(bareme.calcul(BigDecimal.valueOf(800000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("141786.533")));
    assertThat(bareme.calcul(BigDecimal.valueOf(801000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("141976.186")));
    assertThat(bareme.calcul(BigDecimal.valueOf(802000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("142165.841")));
    assertThat(bareme.calcul(BigDecimal.valueOf(803000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("142355.499")));
    assertThat(bareme.calcul(BigDecimal.valueOf(804000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("142545.158")));
    assertThat(bareme.calcul(BigDecimal.valueOf(805000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("142734.820")));
    assertThat(bareme.calcul(BigDecimal.valueOf(806000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("142924.483")));
    assertThat(bareme.calcul(BigDecimal.valueOf(807000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("143114.149")));
    assertThat(bareme.calcul(BigDecimal.valueOf(808000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("143303.817")));
    assertThat(bareme.calcul(BigDecimal.valueOf(809000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("143493.488")));
    assertThat(bareme.calcul(BigDecimal.valueOf(810000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("143683.160")));
    assertThat(bareme.calcul(BigDecimal.valueOf(811000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("143872.834")));
    assertThat(bareme.calcul(BigDecimal.valueOf(812000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("144062.511")));
    assertThat(bareme.calcul(BigDecimal.valueOf(813000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("144252.189")));
    assertThat(bareme.calcul(BigDecimal.valueOf(814000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("144441.870")));
    assertThat(bareme.calcul(BigDecimal.valueOf(815000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("144631.553")));
    assertThat(bareme.calcul(BigDecimal.valueOf(816000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("144821.238")));
    assertThat(bareme.calcul(BigDecimal.valueOf(817000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("145010.924")));
    assertThat(bareme.calcul(BigDecimal.valueOf(818000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("145200.613")));
    assertThat(bareme.calcul(BigDecimal.valueOf(819000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("145390.304")));
    assertThat(bareme.calcul(BigDecimal.valueOf(820000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("145579.996")));
    assertThat(bareme.calcul(BigDecimal.valueOf(821000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("145769.691")));
    assertThat(bareme.calcul(BigDecimal.valueOf(822000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("145959.388")));
    assertThat(bareme.calcul(BigDecimal.valueOf(823000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("146149.086")));
    assertThat(bareme.calcul(BigDecimal.valueOf(824000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("146338.787")));
    assertThat(bareme.calcul(BigDecimal.valueOf(825000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("146528.489")));
    assertThat(bareme.calcul(BigDecimal.valueOf(826000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("146718.194")));
    assertThat(bareme.calcul(BigDecimal.valueOf(827000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("146907.900")));
    assertThat(bareme.calcul(BigDecimal.valueOf(828000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("147097.608")));
    assertThat(bareme.calcul(BigDecimal.valueOf(829000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("147287.318")));
    assertThat(bareme.calcul(BigDecimal.valueOf(830000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("147477.030")));
    assertThat(bareme.calcul(BigDecimal.valueOf(831000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("147666.744")));
    assertThat(bareme.calcul(BigDecimal.valueOf(832000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("147856.459")));
    assertThat(bareme.calcul(BigDecimal.valueOf(833000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("148046.176")));
    assertThat(bareme.calcul(BigDecimal.valueOf(834000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("148235.896")));
    assertThat(bareme.calcul(BigDecimal.valueOf(835000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("148425.617")));
    assertThat(bareme.calcul(BigDecimal.valueOf(836000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("148615.339")));
    assertThat(bareme.calcul(BigDecimal.valueOf(837000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("148805.064")));
    assertThat(bareme.calcul(BigDecimal.valueOf(838000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("148994.790")));
    assertThat(bareme.calcul(BigDecimal.valueOf(839000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("149184.518")));
    assertThat(bareme.calcul(BigDecimal.valueOf(840000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("149374.248")));
    assertThat(bareme.calcul(BigDecimal.valueOf(841000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("149563.979")));
    assertThat(bareme.calcul(BigDecimal.valueOf(842000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("149753.713")));
    assertThat(bareme.calcul(BigDecimal.valueOf(843000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("149943.448")));
    assertThat(bareme.calcul(BigDecimal.valueOf(844000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("150133.184")));
    assertThat(bareme.calcul(BigDecimal.valueOf(845000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("150322.923")));
    assertThat(bareme.calcul(BigDecimal.valueOf(846000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("150512.663")));
    assertThat(bareme.calcul(BigDecimal.valueOf(847000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("150702.404")));
    assertThat(bareme.calcul(BigDecimal.valueOf(848000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("150892.148")));
    assertThat(bareme.calcul(BigDecimal.valueOf(849000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("151081.893")));
    assertThat(bareme.calcul(BigDecimal.valueOf(850000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("151271.639")));
    assertThat(bareme.calcul(BigDecimal.valueOf(851000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("151461.387")));
    assertThat(bareme.calcul(BigDecimal.valueOf(852000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("151651.137")));
    assertThat(bareme.calcul(BigDecimal.valueOf(853000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("151840.889")));
    assertThat(bareme.calcul(BigDecimal.valueOf(854000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("152030.642")));
    assertThat(bareme.calcul(BigDecimal.valueOf(855000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("152220.396")));
    assertThat(bareme.calcul(BigDecimal.valueOf(856000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("152410.152")));
    assertThat(bareme.calcul(BigDecimal.valueOf(857000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("152599.910")));
    assertThat(bareme.calcul(BigDecimal.valueOf(858000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("152789.669")));
    assertThat(bareme.calcul(BigDecimal.valueOf(859000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("152979.430")));
    assertThat(bareme.calcul(BigDecimal.valueOf(860000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("153169.193")));
    assertThat(bareme.calcul(BigDecimal.valueOf(861000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("153358.956")));
    assertThat(bareme.calcul(BigDecimal.valueOf(862000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("153548.722")));
    assertThat(bareme.calcul(BigDecimal.valueOf(863000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("153738.489")));
    assertThat(bareme.calcul(BigDecimal.valueOf(864000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("153928.257")));
    assertThat(bareme.calcul(BigDecimal.valueOf(865000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("154118.027")));
    assertThat(bareme.calcul(BigDecimal.valueOf(866000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("154307.798")));
    assertThat(bareme.calcul(BigDecimal.valueOf(867000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("154497.571")));
    assertThat(bareme.calcul(BigDecimal.valueOf(868000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("154687.345")));
    assertThat(bareme.calcul(BigDecimal.valueOf(869000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("154877.121")));
    assertThat(bareme.calcul(BigDecimal.valueOf(870000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("155066.898")));
    assertThat(bareme.calcul(BigDecimal.valueOf(871000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("155256.677")));
    assertThat(bareme.calcul(BigDecimal.valueOf(872000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("155446.457")));
    assertThat(bareme.calcul(BigDecimal.valueOf(873000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("155636.238")));
    assertThat(bareme.calcul(BigDecimal.valueOf(874000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("155826.021")));
    assertThat(bareme.calcul(BigDecimal.valueOf(875000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("156015.805")));
    assertThat(bareme.calcul(BigDecimal.valueOf(876000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("156205.591")));
    assertThat(bareme.calcul(BigDecimal.valueOf(877000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("156395.378")));
    assertThat(bareme.calcul(BigDecimal.valueOf(878000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("156585.166")));
    assertThat(bareme.calcul(BigDecimal.valueOf(879000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("156774.956")));
    assertThat(bareme.calcul(BigDecimal.valueOf(880000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("156964.747")));
    assertThat(bareme.calcul(BigDecimal.valueOf(881000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("157154.539")));
    assertThat(bareme.calcul(BigDecimal.valueOf(882000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("157344.333")));
    assertThat(bareme.calcul(BigDecimal.valueOf(883000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("157534.128")));
    assertThat(bareme.calcul(BigDecimal.valueOf(884000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("157723.924")));
    assertThat(bareme.calcul(BigDecimal.valueOf(885000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("157913.721")));
    assertThat(bareme.calcul(BigDecimal.valueOf(886000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("158103.520")));
    assertThat(bareme.calcul(BigDecimal.valueOf(887000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("158293.320")));
    assertThat(bareme.calcul(BigDecimal.valueOf(888000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("158483.122")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(889000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("158672.925")));
    assertThat(bareme.calcul(BigDecimal.valueOf(890000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("158862.729")));
    assertThat(bareme.calcul(BigDecimal.valueOf(891000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("159052.534")));
    assertThat(bareme.calcul(BigDecimal.valueOf(892000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("159242.340")));
    assertThat(bareme.calcul(BigDecimal.valueOf(893000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("159432.148")));
    assertThat(bareme.calcul(BigDecimal.valueOf(894000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("159621.957")));
    assertThat(bareme.calcul(BigDecimal.valueOf(895000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("159811.767")));
    assertThat(bareme.calcul(BigDecimal.valueOf(896000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("160001.579")));
    assertThat(bareme.calcul(BigDecimal.valueOf(897000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("160191.391")));
    assertThat(bareme.calcul(BigDecimal.valueOf(898000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("160381.205")));
    assertThat(bareme.calcul(BigDecimal.valueOf(899000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("160571.020")));
    assertThat(bareme.calcul(BigDecimal.valueOf(900000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("160760.836")));
    assertThat(bareme.calcul(BigDecimal.valueOf(901000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("160950.654")));
    assertThat(bareme.calcul(BigDecimal.valueOf(902000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("161140.472")));
    assertThat(bareme.calcul(BigDecimal.valueOf(903000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("161330.292")));
    assertThat(bareme.calcul(BigDecimal.valueOf(904000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("161520.113")));
    assertThat(bareme.calcul(BigDecimal.valueOf(905000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("161709.935")));
    assertThat(bareme.calcul(BigDecimal.valueOf(906000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("161899.758")));
    assertThat(bareme.calcul(BigDecimal.valueOf(907000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("162089.582")));
    assertThat(bareme.calcul(BigDecimal.valueOf(908000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("162279.407")));
    assertThat(bareme.calcul(BigDecimal.valueOf(909000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("162469.234")));
    assertThat(bareme.calcul(BigDecimal.valueOf(910000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("162659.061")));
    assertThat(bareme.calcul(BigDecimal.valueOf(911000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("162848.890")));
    assertThat(bareme.calcul(BigDecimal.valueOf(912000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("163038.720")));
    assertThat(bareme.calcul(BigDecimal.valueOf(913000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("163228.551")));
    assertThat(bareme.calcul(BigDecimal.valueOf(914000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("163418.383")));
    assertThat(bareme.calcul(BigDecimal.valueOf(915000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("163608.216")));
    assertThat(bareme.calcul(BigDecimal.valueOf(916000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("163798.050")));
    assertThat(bareme.calcul(BigDecimal.valueOf(917000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("163987.885")));
    assertThat(bareme.calcul(BigDecimal.valueOf(918000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("164177.721")));
    assertThat(bareme.calcul(BigDecimal.valueOf(919000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("164367.559")));
    assertThat(bareme.calcul(BigDecimal.valueOf(920000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("164557.397")));
    assertThat(bareme.calcul(BigDecimal.valueOf(921000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("164747.236")));
    assertThat(bareme.calcul(BigDecimal.valueOf(922000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("164937.077")));
    assertThat(bareme.calcul(BigDecimal.valueOf(923000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("165126.918")));
    assertThat(bareme.calcul(BigDecimal.valueOf(924000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("165316.760")));
    assertThat(bareme.calcul(BigDecimal.valueOf(925000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("165506.604")));
    assertThat(bareme.calcul(BigDecimal.valueOf(926000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("165696.448")));
    assertThat(bareme.calcul(BigDecimal.valueOf(927000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("165886.294")));
    assertThat(bareme.calcul(BigDecimal.valueOf(928000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("166076.140")));
    assertThat(bareme.calcul(BigDecimal.valueOf(929000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("166265.987")));
    assertThat(bareme.calcul(BigDecimal.valueOf(930000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("166455.836")));
    assertThat(bareme.calcul(BigDecimal.valueOf(931000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("166645.685")));
    assertThat(bareme.calcul(BigDecimal.valueOf(932000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("166835.535")));
    assertThat(bareme.calcul(BigDecimal.valueOf(933000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("167025.387")));
    assertThat(bareme.calcul(BigDecimal.valueOf(934000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("167215.239")));
    assertThat(bareme.calcul(BigDecimal.valueOf(935000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("167405.092")));
    assertThat(bareme.calcul(BigDecimal.valueOf(936000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("167594.946")));
    assertThat(bareme.calcul(BigDecimal.valueOf(937000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("167784.801")));
    assertThat(bareme.calcul(BigDecimal.valueOf(938000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("167974.657")));
    assertThat(bareme.calcul(BigDecimal.valueOf(939000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("168164.514")));
    assertThat(bareme.calcul(BigDecimal.valueOf(940000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("168354.372")));
    assertThat(bareme.calcul(BigDecimal.valueOf(941000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("168544.230")));
    assertThat(bareme.calcul(BigDecimal.valueOf(942000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("168734.090")));
    assertThat(bareme.calcul(BigDecimal.valueOf(943000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("168923.950")));
    assertThat(bareme.calcul(BigDecimal.valueOf(944000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("169113.812")));
    assertThat(bareme.calcul(BigDecimal.valueOf(945000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("169303.674")));
    assertThat(bareme.calcul(BigDecimal.valueOf(946000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("169493.537")));
    assertThat(bareme.calcul(BigDecimal.valueOf(947000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("169683.401")));
    assertThat(bareme.calcul(BigDecimal.valueOf(948000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("169873.266")));
    assertThat(bareme.calcul(BigDecimal.valueOf(949000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("170063.132")));
    assertThat(bareme.calcul(BigDecimal.valueOf(950000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("170252.999")));
    assertThat(bareme.calcul(BigDecimal.valueOf(951000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("170442.866")));
    assertThat(bareme.calcul(BigDecimal.valueOf(952000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("170632.734")));
    assertThat(bareme.calcul(BigDecimal.valueOf(953000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("170822.603")));
    assertThat(bareme.calcul(BigDecimal.valueOf(954000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("171012.473")));
    assertThat(bareme.calcul(BigDecimal.valueOf(955000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("171202.344")));
    assertThat(bareme.calcul(BigDecimal.valueOf(956000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("171392.216")));
    assertThat(bareme.calcul(BigDecimal.valueOf(957000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("171582.088")));
    assertThat(bareme.calcul(BigDecimal.valueOf(958000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("171771.962")));
    assertThat(bareme.calcul(BigDecimal.valueOf(959000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("171961.836")));
    assertThat(bareme.calcul(BigDecimal.valueOf(960000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("172151.711")));
    assertThat(bareme.calcul(BigDecimal.valueOf(961000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("172341.586")));
    assertThat(bareme.calcul(BigDecimal.valueOf(962000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("172531.463")));
    assertThat(bareme.calcul(BigDecimal.valueOf(963000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("172721.340")));
    assertThat(bareme.calcul(BigDecimal.valueOf(964000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("172911.218")));
    assertThat(bareme.calcul(BigDecimal.valueOf(965000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("173101.097")));
    assertThat(bareme.calcul(BigDecimal.valueOf(966000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("173290.977")));
    assertThat(bareme.calcul(BigDecimal.valueOf(967000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("173480.857")));
    assertThat(bareme.calcul(BigDecimal.valueOf(968000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("173670.738")));
    assertThat(bareme.calcul(BigDecimal.valueOf(969000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("173860.620")));
    assertThat(bareme.calcul(BigDecimal.valueOf(970000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("174050.503")));
    assertThat(bareme.calcul(BigDecimal.valueOf(971000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("174240.386")));
    assertThat(bareme.calcul(BigDecimal.valueOf(972000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("174430.270")));
    assertThat(bareme.calcul(BigDecimal.valueOf(973000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("174620.155")));
    assertThat(bareme.calcul(BigDecimal.valueOf(974000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("174810.041")));
    assertThat(bareme.calcul(BigDecimal.valueOf(975000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("174999.927")));
    assertThat(bareme.calcul(BigDecimal.valueOf(976000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("175189.814")));
    assertThat(bareme.calcul(BigDecimal.valueOf(977000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("175379.702")));
    assertThat(bareme.calcul(BigDecimal.valueOf(978000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("175569.591")));
    assertThat(bareme.calcul(BigDecimal.valueOf(979000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("175759.480")));
    assertThat(bareme.calcul(BigDecimal.valueOf(980000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("175949.370")));
    assertThat(bareme.calcul(BigDecimal.valueOf(981000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("176139.260")));
    assertThat(bareme.calcul(BigDecimal.valueOf(982000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("176329.152")));
    assertThat(bareme.calcul(BigDecimal.valueOf(983000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("176519.044")));
    assertThat(bareme.calcul(BigDecimal.valueOf(984000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("176708.937")));
    assertThat(bareme.calcul(BigDecimal.valueOf(985000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("176898.830")));
    assertThat(bareme.calcul(BigDecimal.valueOf(986000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("177088.724")));
    assertThat(bareme.calcul(BigDecimal.valueOf(987000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("177278.619")));
    assertThat(bareme.calcul(BigDecimal.valueOf(988000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("177468.514")));
    assertThat(bareme.calcul(BigDecimal.valueOf(989000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("177658.410")));
    assertThat(bareme.calcul(BigDecimal.valueOf(990000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("177848.307")));
    assertThat(bareme.calcul(BigDecimal.valueOf(991000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("178038.205")));
    assertThat(bareme.calcul(BigDecimal.valueOf(992000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("178228.103")));
    assertThat(bareme.calcul(BigDecimal.valueOf(993000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("178418.002")));
    assertThat(bareme.calcul(BigDecimal.valueOf(994000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("178607.901")));
    assertThat(bareme.calcul(BigDecimal.valueOf(995000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("178797.801")));
    assertThat(bareme.calcul(BigDecimal.valueOf(996000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("178987.702")));
    assertThat(bareme.calcul(BigDecimal.valueOf(997000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("179177.603")));
    assertThat(bareme.calcul(BigDecimal.valueOf(998000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("179367.505")));
    assertThat(bareme.calcul(BigDecimal.valueOf(999000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("179557.407")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1000000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("179747.311")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1001000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("179937.214")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1002000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("180127.119")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1003000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("180317.024")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1004000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("180506.929")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1005000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("180696.836")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1006000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("180886.743")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1007000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("181076.650")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1008000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("181266.558")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1009000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("181456.467")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1010000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("181646.376")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1011000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("181836.286")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1012000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("182026.196")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1013000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("182216.107")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1014000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("182406.018")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1015000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("182595.930")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1016000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("182785.843")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1017000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("182975.756")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1018000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("183165.670")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1019000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("183355.584")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1020000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("183545.499")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1021000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("183735.414")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1022000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("183925.330")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1023000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("184115.247")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1024000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("184305.164")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1025000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("184495.081")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1026000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("184684.999")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1027000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("184874.918")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1028000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("185064.837")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1029000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("185254.756")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1030000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("185444.676")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1031000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("185634.597")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1032000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("185824.518")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1033000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("186014.440")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1034000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("186204.362")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1035000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("186394.285")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1036000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("186584.208")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1037000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("186774.131")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1038000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("186964.055")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1039000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("187153.980")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1040000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("187343.905")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1041000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("187533.831")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1042000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("187723.757")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1043000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("187913.683")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1044000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("188103.610")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1045000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("188293.537")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1046000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("188483.465")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1047000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("188673.394")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1048000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("188863.322")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1049000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("189053.252")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1050000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("189243.181")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1051000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("189433.112")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1052000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("189623.042")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1053000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("189812.973")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1054000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("190002.905")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1055000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("190192.837")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1056000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("190382.769")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1057000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("190572.702")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1058000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("190762.635")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1059000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("190952.569")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1060000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("191142.503")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1061000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("191332.437")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1062000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("191522.372")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1063000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("191712.307")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1064000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("191902.243")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1065000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("192092.179")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1066000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("192282.116")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1067000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("192472.053")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1068000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("192661.990")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1069000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("192851.928")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1070000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("193041.866")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1071000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("193231.805")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1072000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("193421.743")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1073000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("193611.683")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1074000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("193801.623")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1075000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("193991.563")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1076000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("194181.503")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1077000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("194371.444")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1078000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("194561.385")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1079000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("194751.327")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1080000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("194941.269")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1081000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("195131.211")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1082000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("195321.154")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1083000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("195511.097")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1084000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("195701.040")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1085000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("195890.984")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1086000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("196080.928")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1087000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("196270.873")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1088000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("196460.818")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1089000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("196650.763")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1090000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("196840.709")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1091000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("197030.654")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1092000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("197220.601")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1093000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("197410.547")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1094000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("197600.494")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1095000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("197790.442")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1096000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("197980.389")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1097000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("198170.337")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1098000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("198360.285")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1099000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("198550.234")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1100000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("198740.183")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1101000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("198930.132")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1102000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("199120.082")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1103000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("199310.032")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1104000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("199499.982")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1105000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("199689.933")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1106000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("199879.883")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1107000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("200069.835")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1108000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("200259.786")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1109000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("200449.738")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1110000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("200639.690")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1111000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("200829.642")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1112000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("201019.595")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1113000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("201209.548")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1114000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("201399.502")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1115000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("201589.455")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1116000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("201779.409")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1117000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("201969.363")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1118000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("202159.318")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1119000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("202349.273")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1120000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("202539.228")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1121000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("202729.183")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1122000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("202919.139")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1123000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("203109.095")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1124000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("203299.051")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1125000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("203489.007")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1126000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("203678.964")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1127000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("203868.921")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1128000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("204058.878")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1129000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("204248.836")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1130000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("204438.794")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1131000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("204628.752")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1132000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("204818.710")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1133000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("205008.669")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1134000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("205198.628")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1135000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("205388.587")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1136000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("205578.547")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1137000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("205768.506")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1138000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("205958.466")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1139000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("206148.426")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1140000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("206338.387")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1141000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("206528.348")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1142000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("206718.309")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1143000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("206908.270")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1144000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("207098.231")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1145000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("207288.193")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1146000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("207478.155")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1147000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("207668.117")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1148000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("207858.080")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1149000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("208048.042")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1150000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("208238.005")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1151000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("208427.968")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1152000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("208617.932")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1153000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("208807.895")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1154000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("208997.859")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1155000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("209187.823")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1156000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("209377.787")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1157000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("209567.752")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1158000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("209757.717")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1159000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("209947.682")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1160000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("210137.647")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1161000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("210327.612")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1162000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("210517.578")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1163000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("210707.544")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1164000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("210897.510")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1165000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("211087.476")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1166000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("211277.443")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1167000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("211467.410")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1168000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("211657.376")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1169000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("211847.344")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1170000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("212037.311")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1171000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("212227.279")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1172000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("212417.246")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1173000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("212607.214")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1174000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("212797.183")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1175000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("212987.151")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1176000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("213177.119")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1177000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("213367.088")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1178000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("213557.057")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1179000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("213747.026")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1180000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("213936.996")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1181000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("214126.965")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1182000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("214316.935")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1183000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("214506.905")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1184000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("214696.875")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1185000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("214886.846")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1186000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("215076.816")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1187000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("215266.787")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1188000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("215456.758")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1189000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("215646.729")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1190000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("215836.700")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1191000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("216026.672")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1192000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("216216.643")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1193000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("216406.615")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1194000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("216596.587")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1195000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("216786.559")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1196000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("216976.532")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1197000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("217166.504")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1198000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("217356.477")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1199000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("217546.450")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1200000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("217736.423")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1201000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("217926.396")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1202000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("218116.369")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1203000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("218306.343")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1204000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("218496.317")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1205000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("218686.290")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1206000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("218876.265")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1207000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("219066.239")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1208000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("219256.213")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1209000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("219446.188")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1210000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("219636.162")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1211000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("219826.137")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1212000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("220016.112")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1213000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("220206.088")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1214000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("220396.063")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1215000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("220586.038")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1216000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("220776.014")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1217000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("220965.990")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1218000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("221155.966")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1219000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("221345.942")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1220000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("221535.918")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1221000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("221725.895")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1222000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("221915.871")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1223000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("222105.848")));
    //        assertThat(bareme.calcul(BigDecimal.valueOf(1224000))).isEqualTo(arrond.arrondirMontant(new BigDecimal("222295.825")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1225000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("222485.802")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1226000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("222675.779")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1227000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("222865.756")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1228000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("223055.734")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1229000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("223245.711")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1230000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("223435.689")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1231000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("223625.667")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1232000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("223815.645")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1233000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("224005.623")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1234000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("224195.602")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1235000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("224385.580")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1236000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("224575.559")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1237000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("224765.537")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1238000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("224955.516")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1239000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("225145.495")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1240000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("225335.474")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1241000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("225525.454")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1242000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("225715.433")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1243000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("225905.412")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1244000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("226095.392")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1245000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("226285.372")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1246000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("226475.352")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1247000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("226665.332")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1248000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("226855.312")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1249000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("227045.292")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1250000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("227235.273")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1251000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("227425.253")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1252000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("227615.234")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1253000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("227805.215")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1254000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("227995.195")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1255000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("228185.177")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1256000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("228375.158")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1257000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("228565.139")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1258000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("228755.120")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1259000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("228945.102")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1260000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("229135.083")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1261000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("229325.065")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1262000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("229515.047")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1263000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("229705.029")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1264000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("229895.011")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1265000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("230084.993")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1266000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("230274.976")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1267000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("230464.958")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1268000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("230654.941")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1269000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("230844.923")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1270000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("231034.906")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1271000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("231224.889")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1272000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("231414.872")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1273000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("231604.855")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1274000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("231794.838")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1275000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("231984.821")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1276000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("232174.805")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1277000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("232364.788")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1278000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("232554.772")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1279000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("232744.756")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1280000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("232934.739")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1281000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("233124.723")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1282000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("233314.707")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1283000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("233504.691")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1284000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("233694.676")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1285000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("233884.660")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1286000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("234074.644")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1287000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("234264.629")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1288000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("234454.614")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1289000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("234644.598")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1290000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("234834.583")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1291000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("235024.568")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1292000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("235214.553")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1293000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("235404.538")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1294000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("235594.523")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1295000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("235784.509")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1296000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("235974.494")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1297000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("236164.480")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1298000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("236354.465")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1299000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("236544.451")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1300000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("236734.437")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1301000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("236924.422")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1302000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("237114.408")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1303000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("237304.394")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1304000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("237494.380")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1305000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("237684.367")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1306000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("237874.353")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1307000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("238064.339")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1308000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("238254.326")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1309000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("238444.312")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1310000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("238634.299")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1311000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("238824.286")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1312000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("239014.272")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1313000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("239204.259")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1314000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("239394.246")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1315000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("239584.233")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1316000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("239774.221")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1317000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("239964.208")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1318000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("240154.195")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1319000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("240344.182")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1320000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("240534.170")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1321000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("240724.157")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1322000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("240914.145")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1323000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("241104.133")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1324000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("241294.120")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1325000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("241484.108")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1326000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("241674.096")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1327000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("241864.084")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1328000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("242054.072")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1329000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("242244.061")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1330000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("242434.049")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1331000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("242624.037")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1332000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("242814.025")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1333000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("243004.014")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1334000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("243194.002")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1335000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("243383.991")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1336000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("243573.980")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1337000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("243763.968")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1338000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("243953.957")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1339000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("244143.946")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1340000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("244333.935")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1341000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("244523.924")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1342000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("244713.913")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1343000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("244903.902")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1344000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("245093.892")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1345000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("245283.881")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1346000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("245473.870")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1347000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("245663.860")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1348000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("245853.849")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1349000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("246043.839")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1350000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("246233.828")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1351000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("246423.818")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1352000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("246613.808")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1353000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("246803.798")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1354000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("246993.788")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1355000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("247183.778")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1356000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("247373.768")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1357000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("247563.758")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1358000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("247753.748")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1359000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("247943.738")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1360000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("248133.728")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1361000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("248323.719")));
    assertThat(bareme.calcul(BigDecimal.valueOf(1362000)))
            .isEqualTo(arrond.arrondirMontant(new BigDecimal("248513.709")));
}

---

From source file:NumberUtils.java

/**
 * Converts the given number to a <code>java.math.BigDecimal</code>.
 *
 * @param number/*  ww w.j a v  a  2 s  .  c  o  m*/
 * @return java.math.BigDecimal
 * @throws IllegalArgumentException The given number is 'not a number' or infinite.
 */
public static BigDecimal toBigDecimal(Number number) throws IllegalArgumentException {
    if (number == null || number instanceof BigDecimal)
        return (BigDecimal) number;
    if (number instanceof BigInteger)
        return new BigDecimal((BigInteger) number);
    if (isDoubleCompatible(number)) {
        if (isNaN(number) || isInfinite(number))
            throw new IllegalArgumentException("Argument must not be NaN or infinite.");
        return new BigDecimal(number.toString());
    }
    if (isLongCompatible(number))
        return BigDecimal.valueOf(number.longValue());
    // => unknown Number type
    return new BigDecimal(String.valueOf(number.doubleValue()));
}

---

From source file:org.killbill.billing.plugin.avatax.dao.AvaTaxDao.java

public void addResponse(final UUID kbAccountId, final UUID kbInvoiceId,
        final Map<UUID, Iterable<InvoiceItem>> kbInvoiceItems, final GetTaxResult taxResult,
        final DateTime utcNow, final UUID kbTenantId) throws SQLException {
    execute(dataSource.getConnection(), new WithConnectionCallback<Void>() {
        @Override//  www .  ja v  a 2 s .  c  o m
        public Void withConnection(final Connection conn) throws SQLException {
            DSL.using(conn, dialect, settings)
                    .insertInto(AVATAX_RESPONSES, AVATAX_RESPONSES.KB_ACCOUNT_ID,
                            AVATAX_RESPONSES.KB_INVOICE_ID, AVATAX_RESPONSES.KB_INVOICE_ITEM_IDS,
                            AVATAX_RESPONSES.DOC_CODE, AVATAX_RESPONSES.DOC_DATE, AVATAX_RESPONSES.TIMESTAMP,
                            AVATAX_RESPONSES.TOTAL_AMOUNT, AVATAX_RESPONSES.TOTAL_DISCOUNT,
                            AVATAX_RESPONSES.TOTAL_EXEMPTION, AVATAX_RESPONSES.TOTAL_TAXABLE,
                            AVATAX_RESPONSES.TOTAL_TAX, AVATAX_RESPONSES.TOTAL_TAX_CALCULATED,
                            AVATAX_RESPONSES.TAX_DATE, AVATAX_RESPONSES.TAX_LINES, AVATAX_RESPONSES.TAX_SUMMARY,
                            AVATAX_RESPONSES.TAX_ADDRESSES, AVATAX_RESPONSES.RESULT_CODE,
                            AVATAX_RESPONSES.MESSAGES, AVATAX_RESPONSES.ADDITIONAL_DATA,
                            AVATAX_RESPONSES.CREATED_DATE, AVATAX_RESPONSES.KB_TENANT_ID)
                    .values(kbAccountId.toString(), kbInvoiceId.toString(),
                            kbInvoiceItemsIdsAsString(kbInvoiceItems), taxResult.DocCode,
                            toTimestamp(taxResult.DocDate), toTimestamp(taxResult.Timestamp),
                            BigDecimal.valueOf(taxResult.TotalAmount),
                            BigDecimal.valueOf(taxResult.TotalDiscount),
                            BigDecimal.valueOf(taxResult.TotalExemption),
                            BigDecimal.valueOf(taxResult.TotalTaxable), BigDecimal.valueOf(taxResult.TotalTax),
                            BigDecimal.valueOf(taxResult.TotalTaxCalculated), toTimestamp(taxResult.TaxDate),
                            asString(taxResult.TaxLines), asString(taxResult.TaxSummary),
                            asString(taxResult.TaxAddresses),
                            taxResult.ResultCode == null ? null : taxResult.ResultCode.name(),
                            asString(taxResult.Messages), null, toTimestamp(utcNow), kbTenantId.toString())
                    .execute();
            return null;
        }
    });
}

---

From source file:org.fineract.module.stellar.TestPaymentInSimpleNetwork.java

@Test
public void paymentSumApproachesCreditLimit() throws Exception {
    logger.info("paymentSumApproachesCreditLimit test begin");

    final BigDecimal transferIncrement = BigDecimal.valueOf(99.99);
    final BigDecimal lastBit = BigDecimal.valueOf(0.1);

    final AccountListener accountListener = new AccountListener(serverAddress, firstTenantId, secondTenantId);

    //Approach the creditMatcher limit, then go back down to zero.
    Collections.nCopies(10, transferIncrement).parallelStream()
            .forEach((transferAmount) -> makePayment(firstTenantId, firstTenantApiKey, secondTenantId,
                    ASSET_CODE, transferAmount));

    {//from   w w  w  .j av  a  2s  .  c  om
        final List<AccountListener.CreditMatcher> transfers = new ArrayList<>();
        transfers.addAll(Collections.nCopies(10,
                creditMatcher(secondTenantId, transferIncrement, ASSET_CODE, firstTenantId)));

        accountListener.waitForCredits(PAY_WAIT * 3, transfers);
    }

    checkBalance(secondTenantId, secondTenantApiKey, ASSET_CODE, tenantVaultStellarAddress(secondTenantId),
            VAULT_BALANCE);

    checkBalance(secondTenantId, secondTenantApiKey, ASSET_CODE, tenantVaultStellarAddress(firstTenantId),
            transferIncrement.multiply(BigDecimal.TEN));

    logger.info("paymentSumApproachesCreditLimit transfers back");
    Collections.nCopies(10, transferIncrement).parallelStream()
            .forEach((transferAmount) -> makePayment(secondTenantId, secondTenantApiKey, firstTenantId,
                    ASSET_CODE, transferAmount));

    {
        final List<AccountListener.CreditMatcher> transfers = new ArrayList<>();
        transfers.addAll(Collections.nCopies(10, creditMatcher(firstTenantId, transferIncrement, ASSET_CODE,
                vaultMatcher(firstTenantId, secondTenantId))));

        accountListener.waitForCredits(PAY_WAIT * 3, transfers);

        accountListener.waitForCreditsToAccumulate(PAY_WAIT * 3,
                creditMatcher(secondTenantId, transferIncrement.multiply(BigDecimal.TEN), ASSET_CODE,
                        vaultMatcher(firstTenantId, secondTenantId)));

        accountListener.waitForCreditsToAccumulate(PAY_WAIT * 3,
                creditMatcher(firstTenantId, transferIncrement.multiply(BigDecimal.TEN), ASSET_CODE,
                        vaultMatcher(firstTenantId, secondTenantId)));
    }

    checkBalance(firstTenantId, firstTenantApiKey, ASSET_CODE, tenantVaultStellarAddress(secondTenantId),
            BigDecimal.ZERO);
    checkBalance(secondTenantId, secondTenantApiKey, ASSET_CODE, tenantVaultStellarAddress(firstTenantId),
            BigDecimal.ZERO);

    //Approach the creditMatcher limit again, then go to exactly the creditMatcher limit
    Collections.nCopies(10, transferIncrement).parallelStream()
            .forEach((transferAmount) -> makePayment(firstTenantId, firstTenantApiKey, secondTenantId,
                    ASSET_CODE, transferAmount));
    makePayment(firstTenantId, firstTenantApiKey, secondTenantId, ASSET_CODE, lastBit);

    {
        final List<AccountListener.CreditMatcher> transfers = new ArrayList<>();
        transfers.addAll(Collections.nCopies(10,
                creditMatcher(secondTenantId, transferIncrement, ASSET_CODE, firstTenantId)));
        transfers.add(creditMatcher(secondTenantId, lastBit, ASSET_CODE, firstTenantId));

        accountListener.waitForCredits(PAY_WAIT * 3, transfers);
    }

    checkBalance(secondTenantId, secondTenantApiKey, ASSET_CODE, tenantVaultStellarAddress(firstTenantId),
            TRUST_LIMIT);

    //Now try to go over the creditMatcher limit.
    makePayment(firstTenantId, firstTenantApiKey, secondTenantId, ASSET_CODE, lastBit);

    accountListener.waitForCredits(PAY_WAIT,
            creditMatcher(secondTenantId, lastBit, ASSET_CODE, vaultMatcher(firstTenantId, secondTenantId)));

    checkBalance(secondTenantId, secondTenantApiKey, ASSET_CODE, tenantVaultStellarAddress(firstTenantId),
            TRUST_LIMIT);

    //Zero out balance for next test.
    makePayment(secondTenantId, secondTenantApiKey, firstTenantId, ASSET_CODE, TRUST_LIMIT);
    accountListener.waitForCredits(PAY_WAIT,
            creditMatcher(firstTenantId, TRUST_LIMIT, ASSET_CODE, vaultMatcher(firstTenantId, secondTenantId)));
}

---

From source file:gpps.service.impl.ThirdPaySupportServiceImpl.java

@Override
public Recharge getCompanyRecharge(String amount) throws LoginException {

    float am = Float.parseFloat(amount);
    if (am < 1000.0) {
        throw new LoginException("?1000");
    }/*from   ww  w  .  j a  va 2 s.  co  m*/

    Recharge recharge = new Recharge();
    recharge.setBaseUrl(innerThirdPaySupportService.getBaseUrl(IInnerThirdPaySupportService.ACTION_RECHARGE));
    HttpServletRequest req = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
            .getRequest();
    HttpSession session = req.getSession();
    Object currentUser = session.getAttribute(ILoginService.SESSION_ATTRIBUTENAME_USER);
    if (currentUser == null)
        throw new LoginException("??");
    recharge.setAmount(amount);
    recharge.setReturnURL(innerThirdPaySupportService.getReturnUrl() + "/account/recharge/response");
    if ("1".equals(innerThirdPaySupportService.getAppendFlag()))
        recharge.setNotifyURL(
                innerThirdPaySupportService.getNotifyUrl() + "/account/recharge/response" + "/bg");
    else
        recharge.setNotifyURL(innerThirdPaySupportService.getNotifyUrl());
    recharge.setPlatformMoneymoremore(innerThirdPaySupportService.getPlatformMoneymoremore());

    recharge.setRechargeType("4"); //RechargeType==4??
    recharge.setFeeType("2"); //??FeeType==2??20

    Integer cashStreamId = null;
    if (currentUser instanceof Lender) {
        throw new RuntimeException("??");
    } else if (currentUser instanceof Borrower) {
        Borrower borrower = (Borrower) currentUser;
        recharge.setRechargeMoneymoremore(borrower.getThirdPartyAccount());
        cashStreamId = accountService.rechargeBorrowerAccount(borrower.getAccountId(),
                BigDecimal.valueOf(Double.valueOf(amount)), "");
    } else {
        throw new RuntimeException("??");
    }
    recharge.setOrderNo(String.valueOf(cashStreamId));
    recharge.setSignInfo(recharge.getSign(innerThirdPaySupportService.getPrivateKey()));
    return recharge;
}

---

From source file:com.opengamma.examples.bloomberg.loader.ExampleEquityPortfolioLoader.java

/**
 * Create a position of a random number of shares.
 * <p>//from  w w w. ja va  2 s . co m
 * This creates the position using a random number of units and create one or two trades making up the position.
 *
 * @param security  the security to add a position for, not null
 * @return the position, not null
 */
protected ManageablePosition createPositionAndTrade(final EquitySecurity security) {
    s_logger.debug("Creating position {}", security);
    final int shares = (RandomUtils.nextInt(490) + 10) * 10;

    final ExternalIdBundle bundle = security.getExternalIdBundle(); // we could add an identifier pointing back to the original source database if we're doing an ETL.

    final ManageablePosition position = new ManageablePosition(BigDecimal.valueOf(shares), bundle);

    // create random trades that add up in shares to the position they're under (this is not enforced by the system)
    if (shares <= 2000) {
        final ManageableTrade trade = new ManageableTrade(BigDecimal.valueOf(shares), bundle,
                LocalDate.of(2010, 12, 3), null, ExternalId.of("CPARTY", "BACS"));
        position.addTrade(trade);
    } else {
        final ManageableTrade trade1 = new ManageableTrade(BigDecimal.valueOf(2000), bundle,
                LocalDate.of(2010, 12, 1), null, ExternalId.of("CPARTY", "BACS"));
        position.addTrade(trade1);
        final ManageableTrade trade2 = new ManageableTrade(BigDecimal.valueOf(shares - 2000), bundle,
                LocalDate.of(2010, 12, 2), null, ExternalId.of("CPARTY", "BACS"));
        position.addTrade(trade2);
    }
    return position;
}

---

From source file:net.pms.util.Rational.java

/**
 * Returns an instance that represents the value of {@code value}.
 *
 * @param value the value.//  ww w  .  ja  va  2s .c  o  m
 * @return An instance that represents the value of {@code value}.
 */
@Nonnull
public static Rational valueOf(float value) {
    if (value == Float.POSITIVE_INFINITY) {
        return POSITIVE_INFINITY;
    }
    if (value == Float.NEGATIVE_INFINITY) {
        return NEGATIVE_INFINITY;
    }
    if (Float.isNaN(value)) {
        return NaN;
    }
    return valueOf(BigDecimal.valueOf(value));
}

---

From source file:com.gst.portfolio.tax.serialization.TaxValidator.java

public void validateForTaxComponentUpdate(final String json) {
    if (StringUtils.isBlank(json)) {
        throw new InvalidJsonException();
    }/*  www  . j av  a  2  s .  c  o m*/

    final Type typeOfMap = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, json,
            this.supportedTaxComponentUpdateParameters);

    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource("tax.component");

    final JsonElement element = this.fromApiJsonHelper.parse(json);

    if (this.fromApiJsonHelper.parameterExists(TaxApiConstants.nameParamName, element)) {
        final String name = this.fromApiJsonHelper.extractStringNamed(TaxApiConstants.nameParamName, element);
        baseDataValidator.reset().parameter(TaxApiConstants.nameParamName).value(name).notBlank();
    }

    if (this.fromApiJsonHelper.parameterExists(TaxApiConstants.percentageParamName, element)) {
        final BigDecimal percentage = this.fromApiJsonHelper
                .extractBigDecimalWithLocaleNamed(TaxApiConstants.percentageParamName, element);
        baseDataValidator.reset().parameter(TaxApiConstants.percentageParamName).value(percentage).notBlank()
                .positiveAmount().notGreaterThanMax(BigDecimal.valueOf(100));
    }

    if (this.fromApiJsonHelper.parameterExists(TaxApiConstants.startDateParamName, element)) {
        final LocalDate startDate = this.fromApiJsonHelper
                .extractLocalDateNamed(TaxApiConstants.startDateParamName, element);
        baseDataValidator.reset().parameter(TaxApiConstants.startDateParamName).value(startDate)
                .validateDateAfter(DateUtils.getLocalDateOfTenant());
    }
    throwExceptionIfValidationWarningsExist(dataValidationErrors);
}

---

From source file:edu.zipcloud.cloudstreetmarket.api.controllers.UsersController.java

private void prepareUserForUpdate(User user) {
    User existingUser = communityService.findOne(user.getId());
    if (!existingUser.getCurrency().equals(user.getCurrency())) {
        CurrencyExchange currencyExchange = currencyExchangeService
                .gather(existingUser.getCurrency().name() + user.getCurrency().name() + "=X");
        BigDecimal change = BigDecimal.valueOf(1L);
        if (currencyExchange != null && currencyExchange.getAsk() != null
                && currencyExchange.getAsk().compareTo(BigDecimal.ZERO) > 0) {
            change = currencyExchange.getAsk();
        }/*from w ww. j  a  v a 2s . c o  m*/
        //Let's say 2.5% virtual charge applied for now 
        user.setBalance(change.multiply(existingUser.getBalance()).multiply(BigDecimal.valueOf(0.975)));
    } else {
        user.setBalance(existingUser.getBalance());
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• »