jdk-24/test/jdk/java/util/Calendar/BuddhistCalendarTest.java

/*
 * Copyright (c) 2003, 2022, 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() and toString() work correctly with Buddhist Era years.
 */

import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;
import static java.util.Calendar.*;

public class BuddhistCalendarTest {

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

    public static void main(String[] args) {
        testAddRoll();
        testToString();
        testException();
        testLeastMax();
    }

    /**
     * 4817812
     */
    static void testAddRoll() {
        Calendar cal;
        int base, year;

        /*
         * Test: BuddhistCalendar.add(YEAR)
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.add(YEAR, 1);
        year = cal.get(YEAR);
        check(year, base+1, "add(+YEAR)");

        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.add(YEAR, -3);
        year = cal.get(YEAR);
        check(year, base-3, "add(-YEAR)");

        /*
         * Test BuddhistCalendar.add(MONTH)
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.set(MONTH, DECEMBER);
        cal.add(MONTH, 2);
        year = cal.get(YEAR);
        check(year, base+1, "add(+MONTH)");

        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.set(MONTH, FEBRUARY);
        cal.add(MONTH, -4);
        year = cal.get(YEAR);
        check(year, base-1, "add(-MONTH)");

        /*
         * Test BuddhistCalendar.roll(YEAR)
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.roll(YEAR, 2);
        year = cal.get(YEAR);
        check(year, base+2, "roll(+YEAR)");

        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.roll(YEAR, -4);
        year = cal.get(YEAR);
        check(year, base-4, "roll(-YEAR)");

        /*
         * Test BuddhistCalendar.roll(WEEK_OF_YEAR)
         */
        cal = getBuddhistCalendar();
        cal.set(YEAR, 2543);   // A.D.2000
        cal.set(MONTH, DECEMBER);
        cal.set(DATE, 31);
        base = cal.get(YEAR);
        check(base, 2543, "roll(+WEEK_OF_YEAR)");
        cal.roll(WEEK_OF_YEAR, 10);
        year = cal.get(YEAR);
        check(year, base, "roll(+WEEK_OF_YEAR)");

        cal = getBuddhistCalendar();
        cal.set(YEAR, 2543);   // A.D.2000
        cal.set(MONTH, JANUARY);
        cal.set(DATE, 1);
        base = cal.get(YEAR);
        check(base, 2543, "roll(+WEEK_OF_YEAR)");
        cal.roll(WEEK_OF_YEAR, -10);
        year = cal.get(YEAR);
        check(year, base, "roll(-WEEK_OF_YEAR)");

        /*
         * Test Calendar.set(year, month, date)
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.set(3001, APRIL, 10);
        year = cal.get(YEAR);
        check(year, 3001, "set(year, month, date)");

        /*
         * Test Calendar.set(year, month, date, hour, minute)
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.set(3020, MAY, 20, 9, 10);
        year = cal.get(YEAR);
        check(year, 3020, "set(year, month, date, hour, minute)");

        /*
         * Test Calendar.set(year, month, date, hour, minute, second)
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        cal.set(3120, MAY, 20, 9, 10, 52);
        year = cal.get(YEAR);
        check(year, 3120, "set(year, month, date, hour, minute, second)");

        /*
         * 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()&get().
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        int limit = cal.getActualMaximum(YEAR);
        year = cal.get(YEAR);
        check(year, base, "BuddhistCalendar.getActualMaximum(YEAR)");

        /*
         * Test BuddhistCalendar.getActualMinimum(YEAR);
         *   This doesn't call set(YEAR) nor get(YEAR), though.
         */
        cal = getBuddhistCalendar();
        base = cal.get(YEAR);
        limit = cal.getActualMinimum(YEAR);
        year = cal.get(YEAR);
        check(year, base, "BuddhistCalendar.getActualMinimum(YEAR)");
    }

    /**
     * 4847186: BuddhistCalendar: toString() returns Gregorian year
     */
    static void testToString() {
        Calendar cal = getBuddhistCalendar();
        int year = cal.get(YEAR);
        String s = cal.toString();
        String y = s.replaceAll(".+,YEAR=(\\d+),.+", "$1");
        if (Integer.parseInt(y) != year) {
            throw new RuntimeException("toString(): wrong year value: got " + y
                                       + ", expected " + year);
        }
    }

    /**
     * 4956479: BuddhistCalendar methods may return wrong values after exception
     */
    static void testException() {
        Calendar cal = getBuddhistCalendar();
        int year = cal.get(YEAR);
        boolean exceptionOccurred = false;
        try {
            cal.add(100, +1); // cause exception
        } catch (Exception e) {
            exceptionOccurred = true;
        }
        if (!exceptionOccurred) {
            throw new RuntimeException("testException: test case failed: no exception thrown");
        }
        int year2 = cal.get(YEAR);
        if (year2 != year) {
            throw new RuntimeException("wrong year value after exception: got " + year2
                                       + ", expected " + year);
        }
    }

    /**
     * 4956227: getLeastMaximum(WEEK_OF_MONTH) return diff. val. for Greg. and Buddhist Calendar
     */
    static void testLeastMax() {
        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);
            if (bn != gn) {
                throw new RuntimeException("inconsistent Least Max value for " + Koyomi.getFieldName(f)
                                           + ": Buddhist=" + bn
                                           + ": Gregorian=" + gn);
            }
        }
    }

    /**
     * @return a BuddhistCalendar
     */
    static Calendar getBuddhistCalendar() {
        return Calendar.getInstance(THAI_LOCALE);
    }

    static void check(int got, int expected, String s) {
        if (got != expected) {
            throw new RuntimeException("Failed: " +
                s + ": got:" + got + ", expected:" + expected);
        }
    }
}