Skip to content

Commit

Permalink
8316559: Refactor some util/Calendar tests to JUnit
Browse files Browse the repository at this point in the history
Backport-of: 355811a996544c54cde9ff232450f5e5c8e1e632
  • Loading branch information
GoeLin committed Mar 14, 2024
1 parent 390e647 commit a69c437
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);
}
}

1 comment on commit a69c437

@openjdk-notifier
Copy link

Choose a reason for hiding this comment

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

Please sign in to comment.