< prev index next >

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

Print this page
*** 1,7 ***
  /*
!  * 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.
--- 1,7 ---
  /*
!  * 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.

*** 22,222 ***
   */
  
  /*
   * @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);
-         }
      }
  }
--- 22,223 ---
   */
  
  /*
   * @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);
      }
  }
< prev index next >