test/jdk/java/util/Calendar/BuddhistCalendarTest.java - master - githubmirror/jdk22

test/jdk/java/util/Calendar/BuddhistCalendarTest.java
244 строки9 KB
Justin Lu
8316559: Refactor some util/Calendar tests to JUnit
29 сен 2023, 02:51
29 сен 2023, 02:51355811a
/*
 * Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 4817812 4847186 4956227 4956479
 * @summary Confirm that BuddhistCalendar's add(), roll(), set(), and toString()
 *          work correctly with Buddhist Era years.
 * @run junit BuddhistCalendarTest
 */

import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.stream.Stream;

import static java.util.Calendar.APRIL;
import static java.util.Calendar.DATE;
import static java.util.Calendar.DECEMBER;
import static java.util.Calendar.ERA;
import static java.util.Calendar.FEBRUARY;
import static java.util.Calendar.JANUARY;
import static java.util.Calendar.MAY;
import static java.util.Calendar.MONTH;
import static java.util.Calendar.WEEK_OF_YEAR;
import static java.util.Calendar.YEAR;


import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class BuddhistCalendarTest {

    private static final Locale THAI_LOCALE = Locale.of("th", "TH");

    /*
     * Test some add values for the BuddhistCalendar. This test compares the same field
     * as the one added.
     */
    @ParameterizedTest
    @MethodSource("addDataProvider")
    public void buddhistAddTest(Calendar cal, int amount, int fieldToAdd) {
        int base = cal.get(YEAR);
        cal.add(fieldToAdd, amount);
        int yearAfterRoll = cal.get(YEAR);
        assertEquals(yearAfterRoll, base+amount, String.format(
                "Added: %s to field: %s", amount, fieldToAdd));
    }

    /*
     * Given in the format: Calendar, amount to add, and field to add.
     * Test adding of positive and negative year values.
     */
    private static Stream<Arguments> addDataProvider() {
        return Stream.of(
                Arguments.of(getBuddhistCalendar(), 1, YEAR),
                Arguments.of(getBuddhistCalendar(), -3, YEAR)
        );
    }

    /*
     * Test some add values for the BuddhistCalendar. Compare a bigger field
     * (year) than the one added (month). Larger field should roll over.
     */
    @ParameterizedTest
    @MethodSource("alternateAddDataProvider")
    public void buddhistAlternateAddTest(Calendar cal, int amount, int fieldToAdd) {
        int base = cal.get(YEAR);
        cal.add(fieldToAdd, amount);
        int yearAfterRoll = cal.get(YEAR);
        assertEquals(yearAfterRoll, (amount>0) ? (base+1): (base-1), String.format(
                "Added: %s to field: %s", amount, fieldToAdd));
    }

    /*
     * Given in the format: Calendar, amount to add, and field to add.
     * Test adding of positive and negative month values.
     */
    private static Stream<Arguments> alternateAddDataProvider() {
        return Stream.of(
                Arguments.of(getBuddhistCalendarBuilder().set(MONTH, DECEMBER).build(), 2, MONTH),
                Arguments.of(getBuddhistCalendarBuilder().set(MONTH, FEBRUARY).build(), -4, MONTH)
                );
    }

    /*
     * Test some roll values for the BuddhistCalendar. Compare same field
     * that was rolled, value should change.
     */
    @ParameterizedTest
    @MethodSource("rollProvider")
    public void buddhistRollTest(Calendar cal, int amount, int fieldToRoll) {
        int base = cal.get(YEAR);
        cal.roll(fieldToRoll, amount);
        int year = cal.get(YEAR);
        assertEquals(year, base+amount, "Rolling field should change value");
    }

    /*
     * Given in the format: Calendar, amount to roll, and field to roll.
     * Test rolling of positive and negative year values.
     */
    private static Stream<Arguments> rollProvider() {
        return Stream.of(
                Arguments.of(getBuddhistCalendar(), 2, YEAR),
                Arguments.of(getBuddhistCalendar(), -4, YEAR)
        );
    }

    /*
     * Set some calendar values and roll, however, measure a different
     * field than the field that was rolled. Rolling should not change the
     * larger field.
     */
    @ParameterizedTest
    @MethodSource("alternateRollProvider")
    public void buddhistAlternateRollTest(Calendar cal, int amount, int fieldToRoll) {
        int base = cal.get(YEAR);
        cal.roll(fieldToRoll, amount);
        int year = cal.get(YEAR);
        assertEquals(year, base, "Rolling smaller field should not change bigger field");
    }

    /*
     * Given in the format: Calendar, amount to roll, and field to roll.
     * Test rolling of positive and negative week_of_year values.
     */
    private static Stream<Arguments> alternateRollProvider() {
        return Stream.of(
                Arguments.of(getBuddhistCalendarBuilder().set(YEAR, 2543)
                        .set(MONTH, DECEMBER).set(DATE, 31).build(), 10, WEEK_OF_YEAR),
                Arguments.of(getBuddhistCalendarBuilder().set(YEAR, 2543)
                        .set(MONTH, JANUARY).set(DATE, 1).build(), -10, WEEK_OF_YEAR)
        );
    }

    // Test the overloaded set() methods. Check year value.
    @Test
    public void buddhistSetTest() {
        Calendar cal = getBuddhistCalendar();
        cal.set(3001, APRIL, 10);
        assertEquals(cal.get(YEAR), 3001);
        cal.set(3020, MAY, 20, 9, 10);
        assertEquals(cal.get(YEAR), 3020);
        cal.set(3120, MAY, 20, 9, 10, 52 );
        assertEquals(cal.get(YEAR), 3120);
    }

    /*
     * Test BuddhistCalendar.getActualMaximum(YEAR);
     * set(YEAR)/get(YEAR) in this method doesn't affect the real
     * YEAR value because a clone is used with set() and get().
     */
    @Test
    public void buddhistActualMaximumTest() {
        Calendar cal = getBuddhistCalendar();
        int base = cal.get(YEAR);
        int ignored = cal.getActualMaximum(YEAR);
        int year = cal.get(YEAR);
        assertEquals(year, base, "BuddhistCalendar.getActualMaximum(YEAR)");
    }

    // Test BuddhistCalendar.getActualMinimum(YEAR), doesn't call set(YEAR) nor get(YEAR).
    @Test
    public void buddhistActualMinimumTest() {
        Calendar cal = getBuddhistCalendar();
        int base = cal.get(YEAR);
        int ignored = cal.getActualMinimum(YEAR);
        int year = cal.get(YEAR);
        assertEquals(year, base, "BuddhistCalendar.getActualMinimum(YEAR)");
    }

    // 4847186: BuddhistCalendar: toString() returns Gregorian year
    @Test
    public void buddhistToStringTest() {
        Calendar cal = getBuddhistCalendar();
        int year = cal.get(YEAR);
        String s = cal.toString();
        String y = s.replaceAll(".+,YEAR=(\\d+),.+", "$1");
        assertEquals(year, Integer.parseInt(y), "Wrong year value");
    }

    // 4956479: BuddhistCalendar methods may return wrong values after exception
    @Test
    public void buddhistValuesAfterExceptionTest() {
        Calendar cal = getBuddhistCalendar();
        int year = cal.get(YEAR);
        assertThrows(IllegalArgumentException.class, ()-> cal.add(100, +1));
        int year2 = cal.get(YEAR);
        assertEquals(year2, year, "Wrong year value after exception thrown");
    }

    // 4956227: getLeastMaximum(WEEK_OF_MONTH) return diff. val. for Greg. and Buddhist Calendar
    @Test
    public void buddhistLeastMaximumTest() {
        Calendar bc = getBuddhistCalendar();
        // Specify THAI_LOCALE to get the same params for WEEK
        // calculations (6904680).
        Calendar gc = new GregorianCalendar(THAI_LOCALE);
        for (int f = 0; f < Calendar.FIELD_COUNT; f++) {
            if (f == ERA || f == YEAR) {
                continue;
            }
            int bn = bc.getLeastMaximum(f);
            int gn = gc.getLeastMaximum(f);
            assertEquals(bn, gn, "Inconsistent Least Max value for " + Koyomi.getFieldName(f));
        }
    }

    // Utility to get a new Buddhist Calendar Builder (to allow setting of other values)
    private static Calendar.Builder getBuddhistCalendarBuilder() {
        return new Calendar.Builder().setLocale(THAI_LOCALE);
    }

    // Utility to get a new Buddhist calendar
    private static Calendar getBuddhistCalendar() {
        return Calendar.getInstance(THAI_LOCALE);
    }
}