Skip to content

Commit

Permalink
8316559: Refactor some util/Calendar tests to JUnit
Browse files Browse the repository at this point in the history
Reviewed-by: naoto, lancea
  • Loading branch information
Justin Lu committed Sep 28, 2023
1 parent ecb5e8a commit 355811a
Show file tree
Hide file tree
Showing 10 changed files with 554 additions and 474 deletions.
349 changes: 175 additions & 174 deletions test/jdk/java/util/Calendar/BuddhistCalendarTest.java
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
* 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
Expand All @@ -24,191 +24,200 @@
/*
* @test
* @bug 4817812 4847186 4956227 4956479
* @summary Confirm that BuddhistCalendar's add(), roll() and toString() work correctly with Buddhist Era years.
* @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 static java.util.Calendar.*;
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");

public static void main(String[] args) {
testAddRoll();
testToString();
testException();
testLeastMax();
/*
* 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");
}

/**
* 4817812
/*
* Given in the format: Calendar, amount to roll, and field to roll.
* Test rolling of positive and negative week_of_year values.
*/
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);
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);
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);
assertEquals(cal.get(YEAR), 3001);
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
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().
*/
static void testToString() {
@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");
if (Integer.parseInt(y) != year) {
throw new RuntimeException("toString(): wrong year value: got " + y
+ ", expected " + year);
}
assertEquals(year, Integer.parseInt(y), "Wrong year value");
}

/**
* 4956479: BuddhistCalendar methods may return wrong values after exception
*/
static void testException() {
// 4956479: BuddhistCalendar methods may return wrong values after exception
@Test
public void buddhistValuesAfterExceptionTest() {
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");
}
assertThrows(IllegalArgumentException.class, ()-> cal.add(100, +1));
int year2 = cal.get(YEAR);
if (year2 != year) {
throw new RuntimeException("wrong year value after exception: got " + year2
+ ", expected " + year);
}
assertEquals(year2, year, "Wrong year value after exception thrown");
}

/**
* 4956227: getLeastMaximum(WEEK_OF_MONTH) return diff. val. for Greg. and Buddhist Calendar
*/
static void testLeastMax() {
// 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).
Expand All @@ -219,25 +228,17 @@ static void testLeastMax() {
}
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);
}
assertEquals(bn, gn, "Inconsistent Least Max value for " + Koyomi.getFieldName(f));
}
}

/**
* @return a BuddhistCalendar
*/
static Calendar getBuddhistCalendar() {
return Calendar.getInstance(THAI_LOCALE);
// 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);
}

static void check(int got, int expected, String s) {
if (got != expected) {
throw new RuntimeException("Failed: " +
s + ": got:" + got + ", expected:" + expected);
}
// Utility to get a new Buddhist calendar
private static Calendar getBuddhistCalendar() {
return Calendar.getInstance(THAI_LOCALE);
}
}

3 comments on commit 355811a

@openjdk-notifier
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@GoeLin
Copy link
Member

@GoeLin GoeLin commented on 355811a Mar 13, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

/backport jdk21u-dev

@openjdk
Copy link

@openjdk openjdk bot commented on 355811a Mar 13, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@GoeLin the backport was successfully created on the branch backport-GoeLin-355811a9 in my personal fork of openjdk/jdk21u-dev. To create a pull request with this backport targeting openjdk/jdk21u-dev:master, just click the following link:

➡️ Create pull request

The title of the pull request is automatically filled in correctly and below you find a suggestion for the pull request body:

Hi all,

This pull request contains a backport of commit 355811a9 from the openjdk/jdk repository.

The commit being backported was authored by Justin Lu on 28 Sep 2023 and was reviewed by Naoto Sato and Lance Andersen.

Thanks!

If you need to update the source branch of the pull then run the following commands in a local clone of your personal fork of openjdk/jdk21u-dev:

$ git fetch https://github.com/openjdk-bots/jdk21u-dev.git backport-GoeLin-355811a9:backport-GoeLin-355811a9
$ git checkout backport-GoeLin-355811a9
# make changes
$ git add paths/to/changed/files
$ git commit --message 'Describe additional changes made'
$ git push https://github.com/openjdk-bots/jdk21u-dev.git backport-GoeLin-355811a9

Please sign in to comment.